Skip to content

math Module

The math module provides basic mathematical operations.

Functions

Abs(number)

Returns the absolute value of a number.

Parameters:

  • number: An integer or a float.

Returns:

  • (number, error): The absolute value of the number, or an error if the argument is not a number.

Example:

Abs Example
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
package main
import fmt
import math

var result, err = math.Abs(-42)
if err != None {
    fmt.Println("Error:", err)
} else {
    fmt.Println("Result:", result) // Output: Result: 42
}

Ceil(x)

Returns the least integer value greater than or equal to x.

Parameters:

  • x: A number (int or float).

Returns:

  • (number, error): The ceiling of x as a float, or an error.

Example:

Ceil Example
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
package main
import fmt
import math

var result, err = math.Ceil(3.14)
if err != None {
    fmt.Println("Error:", err)
} else {
    fmt.Println("Result:", result) // Output: 4
}

Floor(x)

Returns the greatest integer value less than or equal to x.

Parameters:

  • x: A number (int or float).

Returns:

  • (number, error): The floor of x as a float, or an error.

Example:

Floor Example
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
package main
import fmt
import math

var result, err = math.Floor(3.14)
if err != None {
    fmt.Println("Error:", err)
} else {
    fmt.Println("Result:", result) // Output: 3
}

Round(x)

Returns the nearest integer to x, rounding halves away from zero.

Parameters:

  • x: A number (int or float).

Returns:

  • (number, error): The rounded value as a float, or an error.

Example:

Round Example
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
package main
import fmt
import math

var result, err = math.Round(3.14)
if err != None {
    fmt.Println("Error:", err)
} else {
    fmt.Println("Result:", result) // Output: 3
}

RoundToEven(x)

Returns the nearest integer to x, rounding ties to even.

Parameters:

  • x: A number (int or float).

Returns:

  • (number, error): The rounded value as a float, or an error.

Example:

RoundToEven Example
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
package main
import fmt
import math

var result, err = math.RoundToEven(2.5)
if err != None {
    fmt.Println("Error:", err)
} else {
    fmt.Println("Result:", result) // Output: 2
}

Trunc(x)

Returns the integer value of x toward zero.

Parameters:

  • x: A number (int or float).

Returns:

  • (number, error): The truncated value as a float, or an error.

Example:

Trunc Example
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
package main
import fmt
import math

var result, err = math.Trunc(-3.9)
if err != None {
    fmt.Println("Error:", err)
} else {
    fmt.Println("Result:", result) // Output: -3
}

Pow10(n)

Returns 10**n.

Parameters:

  • n: An integer exponent.

Returns:

  • (number, error): The result as a float, or an error.

Example:

Pow10 Example
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
package main
import fmt
import math

var result, err = math.Pow10(3)
if err != None {
    fmt.Println("Error:", err)
} else {
    fmt.Println("Result:", result) // Output: 1000
}

Sqrt(x) and Cbrt(x)

Return the square root and cube root of x respectively.

Parameters:

  • x: A number (int or float).

Returns:

  • (number, error): The root as a float, or an error.

Example:

Sqrt Example
1
2
3
4
5
6
7
8
package main
import fmt
import math

var s, es = math.Sqrt(9)
var c, ec = math.Cbrt(27)
fmt.Println("Sqrt(9) =", s)   // 3
fmt.Println("Cbrt(27) =", c)  // 3

Mod(x, y) and Remainder(x, y)

Mod returns the truncating floating remainder of x/y. Remainder returns the IEEE 754 floating remainder.

Parameters:

  • x, y: Numbers (int or float).

Returns:

  • (number, error): The remainder as a float, or an error.

Example:

Mod Example
1
2
3
4
5
6
7
8
package main
import fmt
import math

var m, em = math.Mod(5.5, 2)
var r, er = math.Remainder(5.5, 2)
fmt.Println("Mod(5.5,2) =", m)       // 1.5
fmt.Println("Remainder(5.5,2) =", r) // may be -0.5 or 1.5 depending on rule

Exp(x), Exp2(x), Expm1(x), Log(x), Log10(x), Log2(x), Log1p(x)

Exponential and logarithmic functions.

Example:

Exponential and Logarithmic
1
2
3
4
5
6
7
8
package main
import fmt
import math

var e, ee = math.Exp(1)
var l, el = math.Log(1)
fmt.Println("Exp(1) =", e)
fmt.Println("Log(1) =", l)   // 0

Trigonometric: Sin(x), Cos(x), Tan(x), Asin(x), Acos(x), Atan(x), Atan2(y, x), Sincos(x)

Compute trigonometric values in radians.

Example:

Trigonometric Functions
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
package main
import fmt
import math

var s, es = math.Sin(1.57079632679) // ~pi/2
var a2, ea2 = math.Atan2(1, 0)
var sn, cs, esc = math.Sincos(0.5)
fmt.Println("Sin(pi/2) =", s)
fmt.Println("Atan2(1,0) =", a2)
fmt.Println("Sincos(0.5) =", sn, cs)

Hyperbolic: Sinh(x), Cosh(x), Tanh(x), Asinh(x), Acosh(x), Atanh(x)

Hyperbolic functions and their inverses.

Example:

Hyperbolic Functions
1
2
3
4
5
6
7
8
package main
import fmt
import math

var sh, eh = math.Sinh(1)
var ah, eah = math.Asinh(1)
fmt.Println("Sinh(1) =", sh)
fmt.Println("Asinh(1) =", ah)

Special: Gamma(x), Lgamma(x), Erf(x), Erfc(x)

Special functions from mathematics and statistics.

Example:

Special Functions
1
2
3
4
5
6
7
8
package main
import fmt
import math

var g, eg = math.Gamma(5)           // 24
var lg, sign, elg = math.Lgamma(5)  // (log gamma, sign)
fmt.Println("Gamma(5) =", g)
fmt.Println("Lgamma(5) =", lg, sign)

Utilities: Copysign, Signbit, Dim, FMA, Hypot, Frexp, Ldexp, Modf, Nextafter, Nextafter32

Floating helpers and IEEE 754 utilities.

Example:

Utility Functions
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
package main
import fmt
import math

var cps, ecps = math.Copysign(3.5, -1)
var hyp, ehyp = math.Hypot(3, 4)
var intp, frac, em = math.Modf(3.14)
fmt.Println("Copysign(3.5,-1) =", cps)
fmt.Println("Hypot(3,4) =", hyp)
fmt.Println("Modf(3.14) =", intp, frac)

Bit-level: Float32bits, Float64bits, Float32frombits, Float64frombits, Inf, IsInf, IsNaN, NaN, Ilogb, Logb

Inspect and construct floating point values and metadata.

Example:

Bit-level Functions
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
package main
import fmt
import math

var bits, eb = math.Float64bits(3.5)
var f, ef = math.Float64frombits(bits)
var pinf, ei = math.Inf(1)
var infp, eip = math.IsInf(pinf, 1)
var nanv, en = math.NaN()
fmt.Println("bits:", bits, " value:", f)
fmt.Println("IsInf(Inf,+1) =", infp)
fmt.Println("NaN() =", nanv)

Constants: Pi(), E(), Phi()

Return common mathematical constants.

Example:

Mathematical Constants
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
package main
import fmt
import math

var pi = math.Pi
var e = math.E
var phi = math.Phi
fmt.Println("Pi:", pi)
fmt.Println("E:", e)
fmt.Println("Phi:", phi)

Max(a, b)

Returns the maximum of two numbers.

Parameters:

  • a: An integer or a float.
  • b: An integer or a float.

Returns:

  • (number, error): The larger of the two numbers, or an error if the arguments are not numbers.

Example:

Max Example
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
package main
import fmt
import math

var result, err = math.Max(10, 20)
if err != None {
    fmt.Println("Error:", err)
} else {
    fmt.Println("Result:", result) // Output: Result: 20
}

Min(a, b)

Returns the minimum of two numbers.

Parameters:

  • a: An integer or a float.
  • b: An integer or a float.

Returns:

  • (number, error): The smaller of the two numbers, or an error if the arguments are not numbers.

Example:

Min Example
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
package main
import fmt
import math

var result, err = math.Min(10, 20)
if err != None {
    fmt.Println("Error:", err)
} else {
    fmt.Println("Result:", result) // Output: Result: 10
}

Pow(base, exponent)

Returns the base to the power of the exponent.

Parameters:

  • base: An integer or a float.
  • exponent: An integer or a float.

Returns:

  • (number, error): The result of the power operation, or an error if the arguments are not numbers.

Example:

Pow Example
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
package main
import fmt
import math

var result, err = math.Pow(2, 3)
if err != None {
    fmt.Println("Error:", err)
} else {
    fmt.Println("Result:", result) // Output: Result: 8
}