package math
Import Path
math (on go.dev)
Dependency Relation
imports 3 packages, and imported by 11 packages
Involved Source Files
abs.go
acosh.go
asin.go
asinh.go
atan.go
atan2.go
atanh.go
bits.go
cbrt.go
Package math provides basic constants and mathematical functions.
This package does not guarantee bit-identical results across architectures.
copysign.go
dim.go
erf.go
erfinv.go
exp.go
exp_asm.go
expm1.go
floor.go
fma.go
frexp.go
gamma.go
hypot.go
j0.go
j1.go
jn.go
ldexp.go
lgamma.go
log.go
log10.go
log1p.go
logb.go
mod.go
modf.go
nextafter.go
pow.go
pow10.go
remainder.go
signbit.go
sin.go
sincos.go
sinh.go
sqrt.go
tan.go
tanh.go
trig_reduce.go
unsafe.go
dim_amd64.s
exp_amd64.s
floor_amd64.s
hypot_amd64.s
log_amd64.s
sqrt_amd64.s
stubs_amd64.s
Code Examples
package main
import (
"fmt"
"math"
)
func main() {
x := math.Abs(-2)
fmt.Printf("%.1f\n", x)
y := math.Abs(2)
fmt.Printf("%.1f\n", y)
}
package main
import (
"fmt"
"math"
)
func main() {
fmt.Printf("%.2f", math.Acos(1))
}
package main
import (
"fmt"
"math"
)
func main() {
fmt.Printf("%.2f", math.Acosh(1))
}
package main
import (
"fmt"
"math"
)
func main() {
fmt.Printf("%.2f", math.Asin(0))
}
package main
import (
"fmt"
"math"
)
func main() {
fmt.Printf("%.2f", math.Asinh(0))
}
package main
import (
"fmt"
"math"
)
func main() {
fmt.Printf("%.2f", math.Atan(0))
}
package main
import (
"fmt"
"math"
)
func main() {
fmt.Printf("%.2f", math.Atan2(0, 0))
}
package main
import (
"fmt"
"math"
)
func main() {
fmt.Printf("%.2f", math.Atanh(0))
}
package main
import (
"fmt"
"math"
)
func main() {
fmt.Printf("%.2f\n", math.Cbrt(8))
fmt.Printf("%.2f\n", math.Cbrt(27))
}
package main
import (
"fmt"
"math"
)
func main() {
c := math.Ceil(1.49)
fmt.Printf("%.1f", c)
}
package main
import (
"fmt"
"math"
)
func main() {
fmt.Printf("%.2f", math.Copysign(3.2, -1))
}
package main
import (
"fmt"
"math"
)
func main() {
fmt.Printf("%.2f", math.Cos(math.Pi/2))
}
package main
import (
"fmt"
"math"
)
func main() {
fmt.Printf("%.2f", math.Cosh(0))
}
package main
import (
"fmt"
"math"
)
func main() {
fmt.Printf("%.2f\n", math.Dim(4, -2))
fmt.Printf("%.2f\n", math.Dim(-4, 2))
}
package main
import (
"fmt"
"math"
)
func main() {
fmt.Printf("%.2f\n", math.Exp(1))
fmt.Printf("%.2f\n", math.Exp(2))
fmt.Printf("%.2f\n", math.Exp(-1))
}
package main
import (
"fmt"
"math"
)
func main() {
fmt.Printf("%.2f\n", math.Exp2(1))
fmt.Printf("%.2f\n", math.Exp2(-3))
}
package main
import (
"fmt"
"math"
)
func main() {
fmt.Printf("%.6f\n", math.Expm1(0.01))
fmt.Printf("%.6f\n", math.Expm1(-1))
}
package main
import (
"fmt"
"math"
)
func main() {
c := math.Floor(1.51)
fmt.Printf("%.1f", c)
}
package main
import (
"fmt"
"math"
)
func main() {
x := math.Log(1)
fmt.Printf("%.1f\n", x)
y := math.Log(2.7183)
fmt.Printf("%.1f\n", y)
}
package main
import (
"fmt"
"math"
)
func main() {
fmt.Printf("%.1f", math.Log10(100))
}
package main
import (
"fmt"
"math"
)
func main() {
fmt.Printf("%.1f", math.Log2(256))
}
package main
import (
"fmt"
"math"
)
func main() {
c := math.Mod(7, 4)
fmt.Printf("%.1f", c)
}
package main
import (
"fmt"
"math"
)
func main() {
int, frac := math.Modf(3.14)
fmt.Printf("%.2f, %.2f\n", int, frac)
int, frac = math.Modf(-2.71)
fmt.Printf("%.2f, %.2f\n", int, frac)
}
package main
import (
"fmt"
"math"
)
func main() {
c := math.Pow(2, 3)
fmt.Printf("%.1f", c)
}
package main
import (
"fmt"
"math"
)
func main() {
c := math.Pow10(2)
fmt.Printf("%.1f", c)
}
package main
import (
"fmt"
"math"
)
func main() {
p := math.Round(10.5)
fmt.Printf("%.1f\n", p)
n := math.Round(-10.5)
fmt.Printf("%.1f\n", n)
}
package main
import (
"fmt"
"math"
)
func main() {
u := math.RoundToEven(11.5)
fmt.Printf("%.1f\n", u)
d := math.RoundToEven(12.5)
fmt.Printf("%.1f\n", d)
}
package main
import (
"fmt"
"math"
)
func main() {
fmt.Printf("%.2f", math.Sin(math.Pi))
}
package main
import (
"fmt"
"math"
)
func main() {
sin, cos := math.Sincos(0)
fmt.Printf("%.2f, %.2f", sin, cos)
}
package main
import (
"fmt"
"math"
)
func main() {
fmt.Printf("%.2f", math.Sinh(0))
}
package main
import (
"fmt"
"math"
)
func main() {
const (
a = 3
b = 4
)
c := math.Sqrt(a*a + b*b)
fmt.Printf("%.1f", c)
}
package main
import (
"fmt"
"math"
)
func main() {
fmt.Printf("%.2f", math.Tan(0))
}
package main
import (
"fmt"
"math"
)
func main() {
fmt.Printf("%.2f", math.Tanh(0))
}
package main
import (
"fmt"
"math"
)
func main() {
fmt.Printf("%.2f\n", math.Trunc(math.Pi))
fmt.Printf("%.2f\n", math.Trunc(-1.2345))
}
Package-Level Functions (total 124, in which 67 are exported)
Abs returns the absolute value of x.
Special cases are:
Abs(±Inf) = +Inf
Abs(NaN) = NaN
Acos returns the arccosine, in radians, of x.
Special case is:
Acos(x) = NaN if x < -1 or x > 1
Acosh returns the inverse hyperbolic cosine of x.
Special cases are:
Acosh(+Inf) = +Inf
Acosh(x) = NaN if x < 1
Acosh(NaN) = NaN
Asin returns the arcsine, in radians, of x.
Special cases are:
Asin(±0) = ±0
Asin(x) = NaN if x < -1 or x > 1
Asinh returns the inverse hyperbolic sine of x.
Special cases are:
Asinh(±0) = ±0
Asinh(±Inf) = ±Inf
Asinh(NaN) = NaN
Atan returns the arctangent, in radians, of x.
Special cases are:
Atan(±0) = ±0
Atan(±Inf) = ±Pi/2
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
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
Cbrt returns the cube root of x.
Special cases are:
Cbrt(±0) = ±0
Cbrt(±Inf) = ±Inf
Cbrt(NaN) = NaN
Ceil returns the least integer value greater than or equal to x.
Special cases are:
Ceil(±0) = ±0
Ceil(±Inf) = ±Inf
Ceil(NaN) = NaN
Copysign returns a value with the magnitude
of x and the sign of y.
Cos returns the cosine of the radian argument x.
Special cases are:
Cos(±Inf) = NaN
Cos(NaN) = NaN
Cosh returns the hyperbolic cosine of x.
Special cases are:
Cosh(±0) = 1
Cosh(±Inf) = +Inf
Cosh(NaN) = NaN
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
Erf returns the error function of x.
Special cases are:
Erf(+Inf) = 1
Erf(-Inf) = -1
Erf(NaN) = NaN
Erfc returns the complementary error function of x.
Special cases are:
Erfc(+Inf) = 0
Erfc(-Inf) = 2
Erfc(NaN) = NaN
Erfcinv 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) = NaN
Erfinv 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) = NaN
Exp returns e**x, the base-e exponential of x.
Special cases are:
Exp(+Inf) = +Inf
Exp(NaN) = NaN
Very large values overflow to 0 or +Inf.
Very small values underflow to 1.
Exp2 returns 2**x, the base-2 exponential of x.
Special cases are the same as Exp.
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) = NaN
Very large values overflow to -1 or +Inf.
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
FMA returns x * y + z, computed with only one rounding.
(That is, FMA returns the fused multiply-add of x, y, and z.)
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, 0
Gamma 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) = NaN
Hypot 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) = NaN
Ilogb returns the binary exponent of x as an integer.
Special cases are:
Ilogb(±Inf) = MaxInt32
Ilogb(0) = MinInt32
Ilogb(NaN) = MaxInt32
Inf returns positive infinity if sign >= 0, negative infinity if sign < 0.
IsInf 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.
IsNaN reports whether f is an IEEE 754 ``not-a-number'' value.
J0 returns the order-zero Bessel function of the first kind.
Special cases are:
J0(±Inf) = 0
J0(0) = 1
J0(NaN) = NaN
J1 returns the order-one Bessel function of the first kind.
Special cases are:
J1(±Inf) = 0
J1(NaN) = NaN
Jn returns the order-n Bessel function of the first kind.
Special cases are:
Jn(n, ±Inf) = 0
Jn(n, NaN) = NaN
Ldexp is the inverse of Frexp.
It returns frac × 2**exp.
Special cases are:
Ldexp(±0, exp) = ±0
Ldexp(±Inf, exp) = ±Inf
Ldexp(NaN, exp) = NaN
Lgamma 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) = NaN
Log returns the natural logarithm of x.
Special cases are:
Log(+Inf) = +Inf
Log(0) = -Inf
Log(x < 0) = NaN
Log(NaN) = NaN
Log10 returns the decimal logarithm of x.
The special cases are the same as for Log.
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) = NaN
Log2 returns the binary logarithm of x.
The special cases are the same as for Log.
Logb returns the binary exponent of x.
Special cases are:
Logb(±Inf) = +Inf
Logb(0) = -Inf
Logb(NaN) = NaN
Max 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) = -0
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) = -0
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
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
NaN returns an IEEE 754 ``not-a-number'' value.
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) = NaN
Nextafter32 returns the next representable float32 value after x towards y.
Special cases are:
Nextafter32(x, x) = x
Nextafter32(NaN, y) = NaN
Nextafter32(x, NaN) = NaN
Pow 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
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
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
Round returns the nearest integer, rounding half away from zero.
Special cases are:
Round(±0) = ±0
Round(±Inf) = ±Inf
Round(NaN) = NaN
RoundToEven returns the nearest integer, rounding ties to even.
Special cases are:
RoundToEven(±0) = ±0
RoundToEven(±Inf) = ±Inf
RoundToEven(NaN) = NaN
Signbit reports whether x is negative or negative zero.
Sin returns the sine of the radian argument x.
Special cases are:
Sin(±0) = ±0
Sin(±Inf) = NaN
Sin(NaN) = NaN
Sincos returns Sin(x), Cos(x).
Special cases are:
Sincos(±0) = ±0, 1
Sincos(±Inf) = NaN, NaN
Sincos(NaN) = NaN, NaN
Sinh returns the hyperbolic sine of x.
Special cases are:
Sinh(±0) = ±0
Sinh(±Inf) = ±Inf
Sinh(NaN) = NaN
Sqrt returns the square root of x.
Special cases are:
Sqrt(+Inf) = +Inf
Sqrt(±0) = ±0
Sqrt(x < 0) = NaN
Sqrt(NaN) = NaN
Tan returns the tangent of the radian argument x.
Special cases are:
Tan(±0) = ±0
Tan(±Inf) = NaN
Tan(NaN) = NaN
Tanh returns the hyperbolic tangent of x.
Special cases are:
Tanh(±0) = ±0
Tanh(±Inf) = ±1
Tanh(NaN) = NaN
Trunc returns the integer value of x.
Special cases are:
Trunc(±0) = ±0
Trunc(±Inf) = ±Inf
Trunc(NaN) = NaN
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) = NaN
Y1 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) = NaN
Yn 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) = NaN
Package-Level Variables (total 53, none are exported)
Package-Level Constants (total 141, in which 27 are exported)
Mathematical constants.
Mathematical constants.
Mathematical constants.
Mathematical constants.
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.
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.
Integer limit values.
Integer limit values.
Integer limit values.
Integer limit values.
Integer limit values.
Integer limit values.
Integer limit values.
Integer limit values.
Integer limit values.
Integer limit values.
Integer limit values.
Mathematical constants.
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.
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.
Mathematical constants.
Mathematical constants.
Mathematical constants.
Mathematical constants.
 |
The pages are generated with Golds v0.4.2. (GOOS=darwin GOARCH=amd64) Golds is a Go 101 project developed by Tapir Liu. PR and bug reports are welcome and can be submitted to the issue list. Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds. |