math32: maze.io/x/math32

## package math32

`import "maze.io/x/math32"`

### 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.