# Golang Math Module: math.Abs, Pow

Perform mathematical computations with the math module. Call math.Abs and math.Pow.**Math.** Languages often have built-in math methods. With Go we import the math module. This provides commonly-used methods like Abs and Pow.

**Float64.** Math methods here operate on the float64 numeric type. So we cannot use an int directly with them—we must cast it first. This requires some extra complexity.

**Math.Abs.** Let us begin with Abs. We import the math module in the import-statement at the top. Next we introduce the "negative" integer.

**Then:** We convert the "negative" number to a float64 and pass that to the math.Abs method. This returns a positive number.

**Golang program that uses math.Abs, float64**
package main
import (
"fmt"
"math"
)
func main() {
negative := *-10*
fmt.Println(negative)*
// Use math.Abs to convert to a positive number.
// ... We first convert to a float64.
*result := __math.Abs__(float64(negative))
fmt.Println(result)
}
**Output**
-10
10

**Pow, compute exponents.** Pow raises one number to another. Here we compute the cube of 2, which is 8. We can also square numbers (with a second argument of 2) or use higher powers.

**Golang program that uses math.Pow**
package main
import (
"fmt"
"math"
)
func main() {*
// This can handle ints.
*result := __math.Pow__(2, 3)
fmt.Println(result)
}
**Output**
8

**Max, Min.** The math.Max and math.Min methods both receive two float64 values. Max returns the higher of the two. Min returns the lower.

**Note:** If both values are equal, the result is that value. A separate comparison must determine this case.

**Golang program that uses Max, Min**
package main
import (
"fmt"
"math"
)
func main() {
small := float64(3)
large := float64(40)*
// Get the larger of the two numbers.
*max := __math.Max__(small, large)
fmt.Println(max)*
// Get the smaller value.
*min := __math.Min__(small, large)
fmt.Println(min)
}
**Output**
40
3

**Floor.** The floor is beneath us. With math.Floor, a number with a fractional part is always reduced so the fractional part does not exist. Both negative and positive numbers are reduced.

**Golang program that uses math.Floor**
package main
import (
"fmt"
"math"
)
func main() {
value1 := *1.23*
fmt.Println(value1)
fmt.Println(__math.Floor__(value1))
value2 := *2.99*
fmt.Println(value2)
fmt.Println(__math.Floor__(value2))
value3 := *-1.1*
fmt.Println(value3)
fmt.Println(__math.Floor__(value3))
}
**Output**
*1.23*
1
*2.99*
2
*-1.1*
-2

**Signbit.** This math method returns a bool. If the number is negative (has a sign bit) then Signbit returns true. For positive numbers, it returns false.

**Golang program that uses math.Signbit**
package main
import (
"fmt"
"math"
)
func main() {
value1 := float64(*1*)
negative := __math.Signbit__(value1)
fmt.Println(negative)
value2 := float64(*-1*)
negative = __math.Signbit__(value2)
fmt.Println(negative)
value3 := float64(*0*)
negative = __math.Signbit__(value3)
fmt.Println(negative)
}
**Output**
false
true
false

**Odd, even.** An int has a parity: this is whether it is odd or even. To compute parity, we use a modulo division. We can define "odd" as "not even."

Odd, Even

**Fibonacci.** In the Fibonacci sequence, each number is equal to the preceding two numbers. This sequence occurs often in the natural world. It has many uses.

Fibonacci

**Many math methods** are available in the math package. We can implement math methods directly, with imperative statements. But this often leads to unneeded, unwanted complexity.

© 2007-2020 Sam Allen. Every person is special and unique. Send bug reports to info@dotnetperls.com.