### math32

A `float32` version of Go's math package. The majority of code in this library is a thin `float32` wrapper over the results of the `math` package that comes in the standard lib.

The original code is lifted from the Go standard library which is governed by a BSD-style licence which can be found here: https://golang.org/LICENSE.

## Documentation ¶

### Constants ¶

View Source
```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.

View Source
```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 ¶

View Source
`var CosGo = cos`

CosGo is the pure Go Cos function.

View Source
`var SinGo = sin`

SinGo is the pure Go Sin function.

View Source
`var TanGo = tan`

TanGo is the pure Go Tan function.

### Functions ¶

#### func Abs ¶

`func Abs(x float32) float32`

Abs returns the absolute value of x.

Special cases are:

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

#### func Acos ¶

`func Acos(x float32) float32`

#### func Acosh ¶

`func Acosh(x float32) float32`

#### func Asin ¶

`func Asin(x float32) float32`

#### func Asinh ¶

`func Asinh(x float32) float32`

#### func Atan ¶

`func Atan(x float32) float32`

#### func Atan2 ¶

`func Atan2(x, y float32) float32`

#### func Atanh ¶

`func Atanh(x float32) float32`

#### func Cbrt ¶

`func Cbrt(x float32) float32`

#### func Ceil ¶

`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 ¶

`func Close(a, b float32) bool`

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

#### func ComplexExp ¶

`func ComplexExp(x complex64) complex64`

#### func Copysign ¶

`func Copysign(x, y float32) float32`

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

#### func Cos ¶

`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 ¶

`func Cosh(x float32) float32`

#### func Dim ¶

`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 ¶

`func Erf(x float32) float32`

#### func Erfc ¶

`func Erfc(x float32) float32`

#### func Exp ¶

`func Exp(x float32) float32`

#### func Exp2 ¶

`func Exp2(x float32) float32`

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

Special cases are the same as Exp.

#### func Expm1 ¶

`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 ¶

`func Float32bits(f float32) uint32`

Float32bits returns the IEEE 754 binary representation of f.

#### func Float32frombits ¶

`func Float32frombits(b uint32) float32`

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

#### func Float64bits ¶

`func Float64bits(f float64) uint64`

Float64bits returns the IEEE 754 binary representation of f.

#### func Float64frombits ¶

`func Float64frombits(b uint64) float64`

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

#### func Floor ¶

`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 ¶

`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 ¶

`func Gamma(x float32) float32`

#### func Hypot ¶

`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 ¶

`func Ilogb(x float32) int`

#### func Inf ¶

`func Inf(sign int) float32`

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

#### func IsInf ¶

`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 ¶

`func IsNaN(f float32) (is bool)`

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

#### func J0 ¶

`func J0(x float32) float32`

#### func J1 ¶

`func J1(x float32) float32`

#### func Jn ¶

`func Jn(n int, x float32) float32`

#### func Ldexp ¶

`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 ¶

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

#### func Log ¶

`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 ¶

`func Log10(x float32) float32`

#### func Log1p ¶

`func Log1p(x float32) float32`

#### func Log2 ¶

`func Log2(x float32) float32`

#### func Logb ¶

`func Logb(x float32) float32`

#### func Max ¶

`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 ¶

`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 ¶

`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 ¶

`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 ¶

`func NaN() float32`

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

#### func Nextafter ¶

`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 ¶

`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 ¶

`func Pow10(e int) float32`

#### func Remainder ¶

`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 ¶

`func Signbit(x float32) bool`

Signbit returns true if x is negative or negative zero.

#### func Sin ¶

`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 ¶

`func Sinc(x float32) float32`

Sinc is the sine cardinal function.Sinc

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

#### func Sincos ¶

`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 ¶

`func Sinh(x float32) float32`

#### func Sqrt ¶

`func Sqrt(x float32) float32`

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

#### func Tan ¶

`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 ¶

`func Tanh(x float32) float32`

#### func Tolerance ¶

`func Tolerance(a, b, epsilon float32) bool`

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

#### func Trunc ¶

`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 ¶

`func Y0(x float32) float32`

#### func Y1 ¶

`func Y1(x float32) float32`

#### func Yn ¶

`func Yn(n int, x float32) float32`

### Types ¶

This section is empty.

## Directories ¶

Path Synopsis