This package is not in the latest version of its module.
Go to latest Published: Jul 7, 2026 License: BSD-3-ClauseThe Go module system was introduced in Go 1.11 and is the official dependency management solution for Go.
Redistributable licenses place minimal restrictions on how software can be used, modified, and redistributed.
Modules with tagged versions give importers more predictable builds.
When a project reaches major version v1 it is considered stable.
Package math provides basic constants and mathematical functions.
This package does not guarantee bit-identical results across architectures.
Mathematical constants.
Floating-point limit values. Max is the largest finite value representable by the type. SmallestNonzero is the smallest positive, non-zero value representable by the type.
Integer limit values.
This section is empty.
Abs returns the absolute value of x.
Special cases are:
Abs(±Inf) = +Inf Abs(NaN) = NaN Example ¶Acos returns the arccosine, in radians, of x.
Special case is:
Acos(x) = NaN if x < -1 or x > 1 Example ¶Acosh returns the inverse hyperbolic cosine of x.
Special cases are:
Acosh(+Inf) = +Inf Acosh(x) = NaN if x < 1 Acosh(NaN) = NaN Example ¶Asin returns the arcsine, in radians, of x.
Special cases are:
Asin(±0) = ±0 Asin(x) = NaN if x < -1 or x > 1 Example ¶Asinh returns the inverse hyperbolic sine of x.
Special cases are:
Asinh(±0) = ±0 Asinh(±Inf) = ±Inf Asinh(NaN) = NaN Example ¶Atan returns the arctangent, in radians, of x.
Special cases are:
Atan(±0) = ±0 Atan(±Inf) = ±Pi/2 Example ¶Atan2 returns the arc tangent of y/x, using the signs of the two to determine the quadrant of the return value.
Special cases are (in order):
Atan2(y, NaN) = NaN Atan2(NaN, x) = NaN Atan2(+0, x>=0) = +0 Atan2(-0, x>=0) = -0 Atan2(+0, x<=-0) = +Pi Atan2(-0, x<=-0) = -Pi Atan2(y>0, 0) = +Pi/2 Atan2(y<0, 0) = -Pi/2 Atan2(+Inf, +Inf) = +Pi/4 Atan2(-Inf, +Inf) = -Pi/4 Atan2(+Inf, -Inf) = 3Pi/4 Atan2(-Inf, -Inf) = -3Pi/4 Atan2(y, +Inf) = 0 Atan2(y>0, -Inf) = +Pi Atan2(y<0, -Inf) = -Pi Atan2(+Inf, x) = +Pi/2 Atan2(-Inf, x) = -Pi/2 Example ¶Atanh returns the inverse hyperbolic tangent of x.
Special cases are:
Atanh(1) = +Inf Atanh(±0) = ±0 Atanh(-1) = -Inf Atanh(x) = NaN if x < -1 or x > 1 Atanh(NaN) = NaN Example ¶Cbrt returns the cube root of x.
Special cases are:
Cbrt(±0) = ±0 Cbrt(±Inf) = ±Inf Cbrt(NaN) = NaN Example ¶Ceil returns the least integer value greater than or equal to x.
Special cases are:
Ceil(±0) = ±0 Ceil(±Inf) = ±Inf Ceil(NaN) = NaN Example ¶Copysign returns a value with the magnitude of f and the sign of sign.
Example ¶Cos returns the cosine of the radian argument x.
Special cases are:
Cos(±Inf) = NaN Cos(NaN) = NaN Example ¶Cosh returns the hyperbolic cosine of x.
Special cases are:
Cosh(±0) = 1 Cosh(±Inf) = +Inf Cosh(NaN) = NaN Example ¶Dim returns the maximum of x-y or 0.
Special cases are:
Dim(+Inf, +Inf) = NaN Dim(-Inf, -Inf) = NaN Dim(x, NaN) = Dim(NaN, x) = NaN Example ¶Erf returns the error function of x.
Special cases are:
Erf(+Inf) = 1 Erf(-Inf) = -1 Erf(NaN) = NaNErfc returns the complementary error function of x.
Special cases are:
Erfc(+Inf) = 0 Erfc(-Inf) = 2 Erfc(NaN) = NaNErfcinv returns the inverse of Erfc(x).
Special cases are:
Erfcinv(0) = +Inf Erfcinv(2) = -Inf Erfcinv(x) = NaN if x < 0 or x > 2 Erfcinv(NaN) = NaNErfinv returns the inverse error function of x.
Special cases are:
Erfinv(1) = +Inf Erfinv(-1) = -Inf Erfinv(x) = NaN if x < -1 or x > 1 Erfinv(NaN) = NaNExp returns e**x, the base-e exponential of x.
Special cases are:
Exp(+Inf) = +Inf Exp(NaN) = NaNVery large values overflow to 0 or +Inf. Very small values underflow to 1.
Example ¶Exp2 returns 2**x, the base-2 exponential of x.
Special cases are the same as Exp.
Example ¶Expm1 returns e**x - 1, the base-e exponential of x minus 1. It is more accurate than Exp(x) - 1 when x is near zero.
Special cases are:
Expm1(+Inf) = +Inf Expm1(-Inf) = -1 Expm1(NaN) = NaNVery large values overflow to -1 or +Inf.
Example ¶FMA returns x * y + z, computed with only one rounding. (That is, FMA returns the fused multiply-add of x, y, and z.)
Float32bits returns the IEEE 754 binary representation of f, with the sign bit of f and the result in the same bit position. Float32bits(Float32frombits(x)) == x.
Float32frombits returns the floating-point number corresponding to the IEEE 754 binary representation b, with the sign bit of b and the result in the same bit position. Float32frombits(Float32bits(x)) == x.
Float64bits returns the IEEE 754 binary representation of f, with the sign bit of f and the result in the same bit position, and Float64bits(Float64frombits(x)) == x.
Float64frombits returns the floating-point number corresponding to the IEEE 754 binary representation b, with the sign bit of b and the result in the same bit position. Float64frombits(Float64bits(x)) == x.
Floor returns the greatest integer value less than or equal to x.
Special cases are:
Floor(±0) = ±0 Floor(±Inf) = ±Inf Floor(NaN) = NaN Example ¶Frexp breaks f into a normalized fraction and an integral power of two. It returns frac and exp satisfying f == frac × 2**exp, with the absolute value of frac in the interval [½, 1).
Special cases are:
Frexp(±0) = ±0, 0 Frexp(±Inf) = ±Inf, 0 Frexp(NaN) = NaN, 0Gamma returns the Gamma function of x.
Special cases are:
Gamma(+Inf) = +Inf Gamma(+0) = +Inf Gamma(-0) = -Inf Gamma(x) = NaN for integer x < 0 Gamma(-Inf) = NaN Gamma(NaN) = NaNHypot returns Sqrt(p*p + q*q), taking care to avoid unnecessary overflow and underflow.
Special cases are:
Hypot(±Inf, q) = +Inf Hypot(p, ±Inf) = +Inf Hypot(NaN, q) = NaN Hypot(p, NaN) = NaNIlogb returns the binary exponent of x as an integer.
Special cases are:
Ilogb(±Inf) = MaxInt32 Ilogb(0) = MinInt32 Ilogb(NaN) = MaxInt32IsInf reports whether f is an infinity, according to sign. If sign > 0, IsInf reports whether f is positive infinity. If sign < 0, IsInf reports whether f is negative infinity. If sign == 0, IsInf reports whether f is either infinity.
J0 returns the order-zero Bessel function of the first kind.
Special cases are:
J0(±Inf) = 0 J0(0) = 1 J0(NaN) = NaNJ1 returns the order-one Bessel function of the first kind.
Special cases are:
J1(±Inf) = 0 J1(NaN) = NaNJn returns the order-n Bessel function of the first kind.
Special cases are:
Jn(n, ±Inf) = 0 Jn(n, NaN) = NaNLdexp is the inverse of Frexp. It returns frac × 2**exp.
Special cases are:
Ldexp(±0, exp) = ±0 Ldexp(±Inf, exp) = ±Inf Ldexp(NaN, exp) = NaNLgamma returns the natural logarithm and sign (-1 or +1) of Gamma(x).
Special cases are:
Lgamma(+Inf) = +Inf Lgamma(0) = +Inf Lgamma(-integer) = +Inf Lgamma(-Inf) = -Inf Lgamma(NaN) = NaNLog returns the natural logarithm of x.
Special cases are:
Log(+Inf) = +Inf Log(0) = -Inf Log(x < 0) = NaN Log(NaN) = NaN Example ¶Log1p returns the natural logarithm of 1 plus its argument x. It is more accurate than Log(1 + x) when x is near zero.
Special cases are:
Log1p(+Inf) = +Inf Log1p(±0) = ±0 Log1p(-1) = -Inf Log1p(x < -1) = NaN Log1p(NaN) = NaNLog2 returns the binary logarithm of x. The special cases are the same as for Log.
Example ¶Log10 returns the decimal logarithm of x. The special cases are the same as for Log.
Example ¶Logb returns the binary exponent of x.
Special cases are:
Logb(±Inf) = +Inf Logb(0) = -Inf Logb(NaN) = NaNMax returns the larger of x or y.
Special cases are:
Max(x, +Inf) = Max(+Inf, x) = +Inf Max(x, NaN) = Max(NaN, x) = NaN Max(+0, ±0) = Max(±0, +0) = +0 Max(-0, -0) = -0Note that this differs from the built-in function max when called with NaN and +Inf.
Min returns the smaller of x or y.
Special cases are:
Min(x, -Inf) = Min(-Inf, x) = -Inf Min(x, NaN) = Min(NaN, x) = NaN Min(-0, ±0) = Min(±0, -0) = -0Note that this differs from the built-in function min when called with NaN and -Inf.
Mod returns the floating-point remainder of x/y. The magnitude of the result is less than y and its sign agrees with that of x.
Special cases are:
Mod(±Inf, y) = NaN Mod(NaN, y) = NaN Mod(x, 0) = NaN Mod(x, ±Inf) = x Mod(x, NaN) = NaN Example ¶Modf returns integer and fractional floating-point numbers that sum to f. Both values have the same sign as f.
Special cases are:
Modf(±Inf) = ±Inf, NaN Modf(NaN) = NaN, NaN Example ¶Nextafter returns the next representable float64 value after x towards y.
Special cases are:
Nextafter(x, x) = x Nextafter(NaN, y) = NaN Nextafter(x, NaN) = NaNNextafter32 returns the next representable float32 value after x towards y.
Special cases are:
Nextafter32(x, x) = x Nextafter32(NaN, y) = NaN Nextafter32(x, NaN) = NaNPow returns x**y, the base-x exponential of y.
Special cases are (in order):
Pow(x, ±0) = 1 for any x Pow(1, y) = 1 for any y Pow(x, 1) = x for any x Pow(NaN, y) = NaN Pow(x, NaN) = NaN Pow(±0, y) = ±Inf for y an odd integer < 0 Pow(±0, -Inf) = +Inf Pow(±0, +Inf) = +0 Pow(±0, y) = +Inf for finite y < 0 and not an odd integer Pow(±0, y) = ±0 for y an odd integer > 0 Pow(±0, y) = +0 for finite y > 0 and not an odd integer Pow(-1, ±Inf) = 1 Pow(x, +Inf) = +Inf for |x| > 1 Pow(x, -Inf) = +0 for |x| > 1 Pow(x, +Inf) = +0 for |x| < 1 Pow(x, -Inf) = +Inf for |x| < 1 Pow(+Inf, y) = +Inf for y > 0 Pow(+Inf, y) = +0 for y < 0 Pow(-Inf, y) = Pow(-0, -y) Pow(x, y) = NaN for finite x < 0 and finite non-integer y Example ¶Pow10 returns 10**n, the base-10 exponential of n.
Special cases are:
Pow10(n) = 0 for n < -323 Pow10(n) = +Inf for n > 308 Example ¶Remainder returns the IEEE 754 floating-point remainder of x/y.
Special cases are:
Remainder(±Inf, y) = NaN Remainder(NaN, y) = NaN Remainder(x, 0) = NaN Remainder(x, ±Inf) = x Remainder(x, NaN) = NaN Example ¶Round returns the nearest integer, rounding half away from zero.
Special cases are:
Round(±0) = ±0 Round(±Inf) = ±Inf Round(NaN) = NaN Example ¶RoundToEven returns the nearest integer, rounding ties to even.
Special cases are:
RoundToEven(±0) = ±0 RoundToEven(±Inf) = ±Inf RoundToEven(NaN) = NaN Example ¶Sin returns the sine of the radian argument x.
Special cases are:
Sin(±0) = ±0 Sin(±Inf) = NaN Sin(NaN) = NaN Example ¶Sincos returns Sin(x), Cos(x).
Special cases are:
Sincos(±0) = ±0, 1 Sincos(±Inf) = NaN, NaN Sincos(NaN) = NaN, NaN Example ¶Sinh returns the hyperbolic sine of x.
Special cases are:
Sinh(±0) = ±0 Sinh(±Inf) = ±Inf Sinh(NaN) = NaN Example ¶Sqrt returns the square root of x.
Special cases are:
Sqrt(+Inf) = +Inf Sqrt(±0) = ±0 Sqrt(x < 0) = NaN Sqrt(NaN) = NaN Example ¶Tan returns the tangent of the radian argument x.
Special cases are:
Tan(±0) = ±0 Tan(±Inf) = NaN Tan(NaN) = NaN Example ¶Tanh returns the hyperbolic tangent of x.
Special cases are:
Tanh(±0) = ±0 Tanh(±Inf) = ±1 Tanh(NaN) = NaN Example ¶Trunc returns the integer value of x.
Special cases are:
Trunc(±0) = ±0 Trunc(±Inf) = ±Inf Trunc(NaN) = NaN Example ¶Y0 returns the order-zero Bessel function of the second kind.
Special cases are:
Y0(+Inf) = 0 Y0(0) = -Inf Y0(x < 0) = NaN Y0(NaN) = NaNY1 returns the order-one Bessel function of the second kind.
Special cases are:
Y1(+Inf) = 0 Y1(0) = -Inf Y1(x < 0) = NaN Y1(NaN) = NaNYn returns the order-n Bessel function of the second kind.
Special cases are:
Yn(n, +Inf) = 0 Yn(n ≥ 0, 0) = -Inf Yn(n < 0, 0) = +Inf if n is odd, -Inf if n is even Yn(n, x < 0) = NaN Yn(n, NaN) = NaNThis section is empty.
|
Package big implements arbitrary-precision arithmetic (big numbers).
|
Package big implements arbitrary-precision arithmetic (big numbers). |
|
internal/asmgen
Asmgen generates math/big assembly.
|
Asmgen generates math/big assembly. |
|
Package bits implements bit counting and manipulation functions for the predeclared unsigned integer types.
|
Package bits implements bit counting and manipulation functions for the predeclared unsigned integer types. |
|
Package cmplx provides basic constants and mathematical functions for complex numbers.
|
Package cmplx provides basic constants and mathematical functions for complex numbers. |
|
Package rand implements pseudo-random number generators suitable for tasks such as simulation, but it should not be used for security-sensitive work.
|
Package rand implements pseudo-random number generators suitable for tasks such as simulation, but it should not be used for security-sensitive work. |
|
v2
Package rand implements pseudo-random number generators suitable for tasks such as simulation, but it should not be used for security-sensitive work.
|
Package rand implements pseudo-random number generators suitable for tasks such as simulation, but it should not be used for security-sensitive work. |
| ? | : This menu |
| / | : Search site |
| f or F | : Jump to |
| y or Y | : Canonical URL |