package math

Import Path
	math (on golang.org and go.dev)

Dependency Relation
	imports 3 packages, and imported by 14 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
	    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

Exported Values

	 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(x, y float64) float64
		Copysign returns a value with the magnitude
		of x and the sign of y.
	 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
	const E = 2.71828 // https://oeis.org/A001113
		Mathematical constants.
	 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
	const Ln10 = 2.30259 // https://oeis.org/A002392
		Mathematical constants.
	const Ln2 = 0.693147 // https://oeis.org/A002162
		Mathematical constants.
	 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.
	const Log10E = 0.434294
		Mathematical constants.
	 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.
	const Log2E = 1.4427
		Mathematical constants.
	 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
	const MaxFloat32 = 3.40282e+38 // 2**127 * (2**24 - 1) / 2**23
		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 // 2**1023 * (2**53 - 1) / 2**52
		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 MaxInt16 = 32767
		Integer limit values.
	const MaxInt32 = 2147483647
		Integer limit values.
	const MaxInt64 = 9223372036854775807
		Integer limit values.
	const MaxInt8 = 127
		Integer limit values.
	const MaxUint16 = 65535
		Integer limit values.
	const MaxUint32 = 4294967295
		Integer limit values.
	const MaxUint64 = 18446744073709551615
		Integer limit values.
	const MaxUint8 = 255
		Integer limit values.
	 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
	const MinInt16 = -32768
		Integer limit values.
	const MinInt32 = -2147483648
		Integer limit values.
	const MinInt64 = -9223372036854775808
		Integer limit values.
	const MinInt8 = -128
		Integer limit values.
	 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
	const Phi = 1.61803 // https://oeis.org/A001622
		Mathematical constants.
	const Pi = 3.14159 // https://oeis.org/A000796
		Mathematical constants.
	 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
	const SmallestNonzeroFloat32 = 1.4013e-45 // 1 / 2**(127 - 1 + 23)
		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 // 1 / 2**(1023 - 1 + 52)
		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.
	 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
	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.
	 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

The pages are generated with Golds v0.1.6. (GOOS=darwin GOARCH=amd64)
Golds is a Go 101 project and 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.