math32: maze.io/x/math32 Index | Files | Directories

package math32

import "maze.io/x/math32"

Index

Package Files

abs.go acos.go asin.go atan.go bits.go cbrt.go compare.go complex.go copysign.go cos.go dim.go erf.go exp.go exp1m.go floor.go frexp.go gamma.go hypot.go j.go ldexp.go log.go logb.go mod.go modf.go nextafter.go pow.go remainder.go sin.go sincos.go sqrt.go tan.go unsafe.go y.go

Constants

const (
    E   = math.E
    Pi  = math.Pi
    Phi = math.Phi

    Sqrt2   = math.Sqrt2
    SqrtE   = math.SqrtE
    SqrtPi  = math.SqrtPi
    SqrtPhi = math.SqrtPhi

    Ln2    = math.Ln2
    Log2E  = 1 / Ln2
    Ln10   = math.Ln10
    Log10E = 1 / Ln10
)

Mathematical constants.

const (
    MaxFloat32             = 3.40282346638528859811704183484516925440e+38  // 2**127 * (2**24 - 1) / 2**23
    SmallestNonzeroFloat32 = 1.401298464324817070923729583289916131280e-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.

Variables

var CosGo = cos

CosGo is the pure Go Cos function.

var SinGo = sin

SinGo is the pure Go Sin function.

var TanGo = tan

TanGo is the pure Go Tan function.

func Abs Uses

func Abs(x float32) float32

Abs returns the absolute value of x.

Special cases are:

Abs(±Inf) = +Inf
Abs(NaN) = NaN

func Acos Uses

func Acos(x float32) float32

func Acosh Uses

func Acosh(x float32) float32

func Asin Uses

func Asin(x float32) float32

func Asinh Uses

func Asinh(x float32) float32

func Atan Uses

func Atan(x float32) float32

func Atan2 Uses

func Atan2(x, y float32) float32

func Atanh Uses

func Atanh(x float32) float32

func Cbrt Uses

func Cbrt(x float32) float32

func Ceil Uses

func Ceil(x float32) float32

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 Close Uses

func Close(a, b float32) bool

Close approximates equality between a and b with 1e-6 precision.

func ComplexExp Uses

func ComplexExp(x complex64) complex64

func Copysign Uses

func Copysign(x, y float32) float32

Copysign returns a value with the magnitude of x and the sign of y.

func Cos Uses

func Cos(x float32) float32

Cos returns the cosine of the radian argument x.

Special cases are:

Cos(±Inf) = NaN
Cos(NaN) = NaN

func Cosh Uses

func Cosh(x float32) float32

func Dim Uses

func Dim(x, y float32) float32

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 Uses

func Erf(x float32) float32

func Erfc Uses

func Erfc(x float32) float32

func Exp Uses

func Exp(x float32) float32

func Exp2 Uses

func Exp2(x float32) float32

Exp2 returns 2**x, the base-2 exponential of x.

Special cases are the same as Exp.

func Expm1 Uses

func Expm1(x float32) float32

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 Uses

func Float32bits(f float32) uint32

Float32bits returns the IEEE 754 binary representation of f.

func Float32frombits Uses

func Float32frombits(b uint32) float32

Float32frombits returns the floating point number corresponding to the IEEE 754 binary representation b.

func Float64bits Uses

func Float64bits(f float64) uint64

Float64bits returns the IEEE 754 binary representation of f.

func Float64frombits Uses

func Float64frombits(b uint64) float64

Float64frombits returns the floating point number corresponding the IEEE 754 binary representation b.

func Floor Uses

func Floor(x float32) float32

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 Frexp Uses

func Frexp(f float32) (frac float32, 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 Uses

func Gamma(x float32) float32

func Hypot Uses

func Hypot(p, q float32) float32

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 Uses

func Ilogb(x float32) int

func Inf Uses

func Inf(sign int) float32

Inf returns positive infinity if sign >= 0, negative infinity if sign < 0.

func IsInf Uses

func IsInf(f float32, 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 Uses

func IsNaN(f float32) (is bool)

IsNaN reports whether f is an IEEE 754 “not-a-number” value.

func J0 Uses

func J0(x float32) float32

func J1 Uses

func J1(x float32) float32

func Jn Uses

func Jn(n int, x float32) float32

func Ldexp Uses

func Ldexp(frac float32, exp int) float32

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 Uses

func Lgamma(x float32) (lgamma float32, sign int)

func Log Uses

func Log(x float32) float32

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 Uses

func Log10(x float32) float32

func Log1p Uses

func Log1p(x float32) float32

func Log2 Uses

func Log2(x float32) float32

func Logb Uses

func Logb(x float32) float32

func Max Uses

func Max(x, y float32) float32

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

func Min Uses

func Min(x, y float32) float32

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

func Mod Uses

func Mod(x, y float32) float32

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 Uses

func Modf(f float32) (int float32, frac float32)

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 Uses

func NaN() float32

NaN returns an IEEE 754 “not-a-number” value.

func Nextafter Uses

func Nextafter(x, y float32) (r float32)

Nextafter 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 Uses

func Pow(x, y float32) float32

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 Uses

func Pow10(e int) float32

func Remainder Uses

func Remainder(x, y float32) float32

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 Signbit Uses

func Signbit(x float32) bool

Signbit returns true if x is negative or negative zero.

func Sin Uses

func Sin(x float32) float32

Sin returns the sine of the radian argument x.

Special cases are:

Sin(±0) = ±0
Sin(±Inf) = NaN
Sin(NaN) = NaN

func Sinc Uses

func Sinc(x float32) float32

Sinc is the sine cardinal function.Sinc

Sinc(x) = |     1      if x = 0
          | sin(x)/x   otherwise

func Sincos Uses

func Sincos(x float32) (sin, cos float32)

Sincos returns Sin(x), Cos(x).

Special cases are:

Sincos(±0) = ±0, 1
Sincos(±Inf) = NaN, NaN
Sincos(NaN) = NaN, NaN

func Sinh Uses

func Sinh(x float32) float32

func Sqrt Uses

func Sqrt(x float32) float32

Sqrt returns the square root of x. For more information see: https://golang.org/pkg/math/#Sqrt

func Tan Uses

func Tan(x float32) float32

Tan returns the tangent of the radian argument x.

Special cases are:

Tan(±0) = ±0
Tan(±Inf) = NaN
Tan(NaN) = NaN

func Tanh Uses

func Tanh(x float32) float32

func Tolerance Uses

func Tolerance(a, b, epsilon float32) bool

Tolerance approximates equality between a and b within (absolute) epsilon.

func Trunc Uses

func Trunc(x float32) float32

Trunc returns the integer value of x.

Special cases are:

Trunc(±0) = ±0
Trunc(±Inf) = ±Inf
Trunc(NaN) = NaN

func Y0 Uses

func Y0(x float32) float32

func Y1 Uses

func Y1(x float32) float32

func Yn Uses

func Yn(n int, x float32) float32

Directories

PathSynopsis
cmplx32

Package math32 imports 2 packages (graph). Updated 2018-12-02. Refresh now. Tools for package owners.