package math

Import Path
	math (on go.dev)

Dependency Relation
	imports 3 packages, and imported by 36 packages

Involved Source Files

	    abs.go
	    acosh.go
	    asin.go
	    asinh.go
	    atan.go
	    atan2.go
	    atanh.go
	    bits.go
	    cbrt.go
	  d const.go
		Package math provides basic constants and mathematical functions.
		
		This package does not guarantee bit-identical results across architectures.

	    copysign.go
	    dim.go
	    dim_asm.go
	    erf.go
	    erfinv.go
	    exp.go
	    exp2_noasm.go
	    exp_amd64.go
	    exp_asm.go
	    expm1.go
	    floor.go
	    floor_asm.go
	    fma.go
	    frexp.go
	    gamma.go
	    hypot.go
	    hypot_asm.go
	    j0.go
	    j1.go
	    jn.go
	    ldexp.go
	    lgamma.go
	    log.go
	    log10.go
	    log1p.go
	    log_asm.go
	    logb.go
	    mod.go
	    modf.go
	    modf_noasm.go
	    nextafter.go
	    pow.go
	    pow10.go
	    remainder.go
	    signbit.go
	    sin.go
	    sincos.go
	    sinh.go
	    sqrt.go
	    stubs.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
Code Examples

	Abs
		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)
		}

	Acos
		package main
		
		import (
			"fmt"
			"math"
		)
		
		func main() {
			fmt.Printf("%.2f", math.Acos(1))
		}

	Acosh
		package main
		
		import (
			"fmt"
			"math"
		)
		
		func main() {
			fmt.Printf("%.2f", math.Acosh(1))
		}

	Asin
		package main
		
		import (
			"fmt"
			"math"
		)
		
		func main() {
			fmt.Printf("%.2f", math.Asin(0))
		}

	Asinh
		package main
		
		import (
			"fmt"
			"math"
		)
		
		func main() {
			fmt.Printf("%.2f", math.Asinh(0))
		}

	Atan
		package main
		
		import (
			"fmt"
			"math"
		)
		
		func main() {
			fmt.Printf("%.2f", math.Atan(0))
		}

	Atan2
		package main
		
		import (
			"fmt"
			"math"
		)
		
		func main() {
			fmt.Printf("%.2f", math.Atan2(0, 0))
		}

	Atanh
		package main
		
		import (
			"fmt"
			"math"
		)
		
		func main() {
			fmt.Printf("%.2f", math.Atanh(0))
		}

	Cbrt
		package main
		
		import (
			"fmt"
			"math"
		)
		
		func main() {
			fmt.Printf("%.2f\n", math.Cbrt(8))
			fmt.Printf("%.2f\n", math.Cbrt(27))
		}

	Ceil
		package main
		
		import (
			"fmt"
			"math"
		)
		
		func main() {
			c := math.Ceil(1.49)
			fmt.Printf("%.1f", c)
		}

	Copysign
		package main
		
		import (
			"fmt"
			"math"
		)
		
		func main() {
			fmt.Printf("%.2f", math.Copysign(3.2, -1))
		}

	Cos
		package main
		
		import (
			"fmt"
			"math"
		)
		
		func main() {
			fmt.Printf("%.2f", math.Cos(math.Pi/2))
		}

	Cosh
		package main
		
		import (
			"fmt"
			"math"
		)
		
		func main() {
			fmt.Printf("%.2f", math.Cosh(0))
		}

	Dim
		package main
		
		import (
			"fmt"
			"math"
		)
		
		func main() {
			fmt.Printf("%.2f\n", math.Dim(4, -2))
			fmt.Printf("%.2f\n", math.Dim(-4, 2))
		}

	Exp
		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))
		}

	Exp2
		package main
		
		import (
			"fmt"
			"math"
		)
		
		func main() {
			fmt.Printf("%.2f\n", math.Exp2(1))
			fmt.Printf("%.2f\n", math.Exp2(-3))
		}

	Expm1
		package main
		
		import (
			"fmt"
			"math"
		)
		
		func main() {
			fmt.Printf("%.6f\n", math.Expm1(0.01))
			fmt.Printf("%.6f\n", math.Expm1(-1))
		}

	Floor
		package main
		
		import (
			"fmt"
			"math"
		)
		
		func main() {
			c := math.Floor(1.51)
			fmt.Printf("%.1f", c)
		}

	Log
		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)
		}

	Log10
		package main
		
		import (
			"fmt"
			"math"
		)
		
		func main() {
			fmt.Printf("%.1f", math.Log10(100))
		}

	Log2
		package main
		
		import (
			"fmt"
			"math"
		)
		
		func main() {
			fmt.Printf("%.1f", math.Log2(256))
		}

	Mod
		package main
		
		import (
			"fmt"
			"math"
		)
		
		func main() {
			c := math.Mod(7, 4)
			fmt.Printf("%.1f", c)
		}

	Modf
		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)
		}

	Pow
		package main
		
		import (
			"fmt"
			"math"
		)
		
		func main() {
			c := math.Pow(2, 3)
			fmt.Printf("%.1f", c)
		}

	Pow10
		package main
		
		import (
			"fmt"
			"math"
		)
		
		func main() {
			c := math.Pow10(2)
			fmt.Printf("%.1f", c)
		}

	Remainder
		package main
		
		import (
			"fmt"
			"math"
		)
		
		func main() {
			fmt.Printf("%.1f", math.Remainder(100, 30))
		}

	Round
		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)
		}

	RoundToEven
		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)
		}

	Sin
		package main
		
		import (
			"fmt"
			"math"
		)
		
		func main() {
			fmt.Printf("%.2f", math.Sin(math.Pi))
		}

	Sincos
		package main
		
		import (
			"fmt"
			"math"
		)
		
		func main() {
			sin, cos := math.Sincos(0)
			fmt.Printf("%.2f, %.2f", sin, cos)
		}

	Sinh
		package main
		
		import (
			"fmt"
			"math"
		)
		
		func main() {
			fmt.Printf("%.2f", math.Sinh(0))
		}

	Sqrt
		package main
		
		import (
			"fmt"
			"math"
		)
		
		func main() {
			const (
				a = 3
				b = 4
			)
			c := math.Sqrt(a*a + b*b)
			fmt.Printf("%.1f", c)
		}

	Tan
		package main
		
		import (
			"fmt"
			"math"
		)
		
		func main() {
			fmt.Printf("%.2f", math.Tan(0))
		}

	Tanh
		package main
		
		import (
			"fmt"
			"math"
		)
		
		func main() {
			fmt.Printf("%.2f", math.Tanh(0))
		}

	Trunc
		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 67)

	 func Abs(x float64) float64
		Abs returns the absolute value of x.
		
		Special cases are:
		
			Abs(±Inf) = +Inf
			Abs(NaN) = NaN

	 func Acos(x float64) float64
		Acos returns the arccosine, in radians, of x.
		
		Special case is:
		
			Acos(x) = NaN if x < -1 or x > 1

	 func Acosh(x float64) float64
		Acosh returns the inverse hyperbolic cosine of x.
		
		Special cases are:
		
			Acosh(+Inf) = +Inf
			Acosh(x) = NaN if x < 1
			Acosh(NaN) = NaN

	 func Asin(x float64) float64
		Asin returns the arcsine, in radians, of x.
		
		Special cases are:
		
			Asin(±0) = ±0
			Asin(x) = NaN if x < -1 or x > 1

	 func Asinh(x float64) float64
		Asinh returns the inverse hyperbolic sine of x.
		
		Special cases are:
		
			Asinh(±0) = ±0
			Asinh(±Inf) = ±Inf
			Asinh(NaN) = NaN

	 func Atan(x float64) float64
		Atan returns the arctangent, in radians, of x.
		
		Special cases are:
		
			Atan(±0) = ±0
			Atan(±Inf) = ±Pi/2

	 func Atan2(y, x float64) float64
		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

	 func Atanh(x float64) float64
		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

	 func Cbrt(x float64) float64
		Cbrt returns the cube root of x.
		
		Special cases are:
		
			Cbrt(±0) = ±0
			Cbrt(±Inf) = ±Inf
			Cbrt(NaN) = NaN

	 func Ceil(x float64) float64
		Ceil returns the least integer value greater than or equal to x.
		
		Special cases are:
		
			Ceil(±0) = ±0
			Ceil(±Inf) = ±Inf
			Ceil(NaN) = NaN

	 func Copysign(f, sign float64) float64
		Copysign returns a value with the magnitude of f
		and the sign of sign.

	 func Cos(x float64) float64
		Cos returns the cosine of the radian argument x.
		
		Special cases are:
		
			Cos(±Inf) = NaN
			Cos(NaN) = NaN

	 func Cosh(x float64) float64
		Cosh returns the hyperbolic cosine of x.
		
		Special cases are:
		
			Cosh(±0) = 1
			Cosh(±Inf) = +Inf
			Cosh(NaN) = NaN

	 func Dim(x, y float64) float64
		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

	 func Erf(x float64) float64
		Erf returns the error function of x.
		
		Special cases are:
		
			Erf(+Inf) = 1
			Erf(-Inf) = -1
			Erf(NaN) = NaN

	 func Erfc(x float64) float64
		Erfc returns the complementary error function of x.
		
		Special cases are:
		
			Erfc(+Inf) = 0
			Erfc(-Inf) = 2
			Erfc(NaN) = NaN

	 func Erfcinv(x float64) float64
		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

	 func Erfinv(x float64) float64
		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

	 func Exp(x float64) float64
		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.

	 func Exp2(x float64) float64
		Exp2 returns 2**x, the base-2 exponential of x.
		
		Special cases are the same as [Exp].

	 func Expm1(x float64) float64
		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.

	 func Float32bits(f float32) uint32
		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.

	 func Float32frombits(b uint32) float32
		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.

	 func Float64bits(f float64) uint64
		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.

	 func Float64frombits(b uint64) float64
		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.

	 func Floor(x float64) float64
		Floor returns the greatest integer value less than or equal to x.
		
		Special cases are:
		
			Floor(±0) = ±0
			Floor(±Inf) = ±Inf
			Floor(NaN) = NaN

	 func FMA(x, y, z float64) float64
		FMA returns x * y + z, computed with only one rounding.
		(That is, FMA returns the fused multiply-add of x, y, and z.)

	 func Frexp(f float64) (frac float64, exp int)
		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

	 func Gamma(x float64) float64
		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

	 func Hypot(p, q float64) float64
		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

	 func Ilogb(x float64) int
		Ilogb returns the binary exponent of x as an integer.
		
		Special cases are:
		
			Ilogb(±Inf) = MaxInt32
			Ilogb(0) = MinInt32
			Ilogb(NaN) = MaxInt32

	 func Inf(sign int) float64
		Inf returns positive infinity if sign >= 0, negative infinity if sign < 0.

	 func IsInf(f float64, sign int) bool
		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.

	 func IsNaN(f float64) (is bool)
		IsNaN reports whether f is an IEEE 754 “not-a-number” value.

	 func J0(x float64) float64
		J0 returns the order-zero Bessel function of the first kind.
		
		Special cases are:
		
			J0(±Inf) = 0
			J0(0) = 1
			J0(NaN) = NaN

	 func J1(x float64) float64
		J1 returns the order-one Bessel function of the first kind.
		
		Special cases are:
		
			J1(±Inf) = 0
			J1(NaN) = NaN

	 func Jn(n int, x float64) float64
		Jn returns the order-n Bessel function of the first kind.
		
		Special cases are:
		
			Jn(n, ±Inf) = 0
			Jn(n, NaN) = NaN

	 func Ldexp(frac float64, exp int) float64
		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

	 func Lgamma(x float64) (lgamma float64, sign int)
		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

	 func Log(x float64) float64
		Log returns the natural logarithm of x.
		
		Special cases are:
		
			Log(+Inf) = +Inf
			Log(0) = -Inf
			Log(x < 0) = NaN
			Log(NaN) = NaN

	 func Log10(x float64) float64
		Log10 returns the decimal logarithm of x.
		The special cases are the same as for [Log].

	 func Log1p(x float64) float64
		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

	 func Log2(x float64) float64
		Log2 returns the binary logarithm of x.
		The special cases are the same as for [Log].

	 func Logb(x float64) float64
		Logb returns the binary exponent of x.
		
		Special cases are:
		
			Logb(±Inf) = +Inf
			Logb(0) = -Inf
			Logb(NaN) = NaN

	 func Max(x, y float64) float64
		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
		
		Note that this differs from the built-in function max when called
		with NaN and +Inf.

	 func Min(x, y float64) float64
		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
		
		Note that this differs from the built-in function min when called
		with NaN and -Inf.

	 func Mod(x, y float64) float64
		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

	 func Modf(f float64) (int float64, frac float64)
		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

	 func NaN() float64
		NaN returns an IEEE 754 “not-a-number” value.

	 func Nextafter(x, y float64) (r float64)
		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

	 func Nextafter32(x, y float32) (r float32)
		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

	 func Pow(x, y float64) float64
		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

	 func Pow10(n int) float64
		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

	 func Remainder(x, y float64) float64
		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

	 func Round(x float64) float64
		Round returns the nearest integer, rounding half away from zero.
		
		Special cases are:
		
			Round(±0) = ±0
			Round(±Inf) = ±Inf
			Round(NaN) = NaN

	 func RoundToEven(x float64) float64
		RoundToEven returns the nearest integer, rounding ties to even.
		
		Special cases are:
		
			RoundToEven(±0) = ±0
			RoundToEven(±Inf) = ±Inf
			RoundToEven(NaN) = NaN

	 func Signbit(x float64) bool
		Signbit reports whether x is negative or negative zero.

	 func Sin(x float64) float64
		Sin returns the sine of the radian argument x.
		
		Special cases are:
		
			Sin(±0) = ±0
			Sin(±Inf) = NaN
			Sin(NaN) = NaN

	 func Sincos(x float64) (sin, cos float64)
		Sincos returns Sin(x), Cos(x).
		
		Special cases are:
		
			Sincos(±0) = ±0, 1
			Sincos(±Inf) = NaN, NaN
			Sincos(NaN) = NaN, NaN

	 func Sinh(x float64) float64
		Sinh returns the hyperbolic sine of x.
		
		Special cases are:
		
			Sinh(±0) = ±0
			Sinh(±Inf) = ±Inf
			Sinh(NaN) = NaN

	 func Sqrt(x float64) float64
		Sqrt returns the square root of x.
		
		Special cases are:
		
			Sqrt(+Inf) = +Inf
			Sqrt(±0) = ±0
			Sqrt(x < 0) = NaN
			Sqrt(NaN) = NaN

	 func Tan(x float64) float64
		Tan returns the tangent of the radian argument x.
		
		Special cases are:
		
			Tan(±0) = ±0
			Tan(±Inf) = NaN
			Tan(NaN) = NaN

	 func Tanh(x float64) float64
		Tanh returns the hyperbolic tangent of x.
		
		Special cases are:
		
			Tanh(±0) = ±0
			Tanh(±Inf) = ±1
			Tanh(NaN) = NaN

	 func Trunc(x float64) float64
		Trunc returns the integer value of x.
		
		Special cases are:
		
			Trunc(±0) = ±0
			Trunc(±Inf) = ±Inf
			Trunc(NaN) = NaN

	 func Y0(x float64) float64
		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

	 func Y1(x float64) float64
		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

	 func Yn(n int, x float64) float64
		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 Constants (total 30)

	const E = 2.71828 // https://oeis.org/A001113
		Mathematical constants.

	const Ln10 = 2.30259 // https://oeis.org/A002392
		Mathematical constants.

	const Ln2 = 0.693147 // https://oeis.org/A002162
		Mathematical constants.

	const Log10E = 0.434294
		Mathematical constants.

	const Log2E = 1.4427
		Mathematical constants.

	const MaxFloat32 = 3.40282e+38 // 3.40282346638528859811704183484516925440e+38
		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.

	const MaxFloat64 = 1.79769e+308 // 1.79769313486231570814527423731704356798070e+308
		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.

	const MaxInt = 9223372036854775807 // MaxInt32 or MaxInt64 depending on intSize.
		Integer limit values.

	const MaxInt16 = 32767 // 32767
		Integer limit values.

	const MaxInt32 = 2147483647 // 2147483647
		Integer limit values.

	const MaxInt64 = 9223372036854775807 // 9223372036854775807
		Integer limit values.

	const MaxInt8 = 127 // 127
		Integer limit values.

	const MaxUint = 18446744073709551615 // MaxUint32 or MaxUint64 depending on intSize.
		Integer limit values.

	const MaxUint16 = 65535 // 65535
		Integer limit values.

	const MaxUint32 = 4294967295 // 4294967295
		Integer limit values.

	const MaxUint64 = 18446744073709551615 // 18446744073709551615
		Integer limit values.

	const MaxUint8 = 255 // 255
		Integer limit values.

	const MinInt = -9223372036854775808 // MinInt32 or MinInt64 depending on intSize.
		Integer limit values.

	const MinInt16 = -32768 // -32768
		Integer limit values.

	const MinInt32 = -2147483648 // -2147483648
		Integer limit values.

	const MinInt64 = -9223372036854775808 // -9223372036854775808
		Integer limit values.

	const MinInt8 = -128 // -128
		Integer limit values.

	const Phi = 1.61803 // https://oeis.org/A001622
		Mathematical constants.

	const Pi = 3.14159 // https://oeis.org/A000796
		Mathematical constants.

	const SmallestNonzeroFloat32 = 1.4013e-45 // 1.401298464324817070923729583289916131280e-45
		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.

	const SmallestNonzeroFloat64 = 4.94066e-324 // 4.9406564584124654417656879286822137236505980e-324
		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.

	const Sqrt2 = 1.41421 // https://oeis.org/A002193
		Mathematical constants.

	const SqrtE = 1.64872 // https://oeis.org/A019774
		Mathematical constants.

	const SqrtPhi = 1.27202 // https://oeis.org/A139339
		Mathematical constants.

	const SqrtPi = 1.77245 // https://oeis.org/A002161
		Mathematical constants.

The pages are generated with Golds v0.7.0-preview. (GOOS=linux 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 @zigo_101 (reachable from the left QR code) to get the latest news of Golds.