math32

package module
Version: v1.10.1 Latest Latest

Go to latest
Published: Nov 15, 2021 License: BSD-2-Clause

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 ¶

Overview ¶

Package math32 provides basic constants and mathematical functions for float32 types.

At its core, it's mostly just a wrapper in form of float32(math.XXX). This applies to the following functions:

```Acos
Acosh
Asin
Asinh
Atan
Atan2
Atanh
Cbrt
Cos
Cosh
Erfc
Gamma
J0
J1
Jn
Log10
Log1p
Log2
Logb
Pow10
Sin
Sinh
Tan
Y0
Y1
```

Everything else is a float32 implementation. Implementation schedule is sporadic an uncertain. But eventually all functions will be replaced

Constants ¶

View Source
```const (
E   = float32(2.71828182845904523536028747135266249775724709369995957496696763) // http://oeis.org/A001113
Pi  = float32(3.14159265358979323846264338327950288419716939937510582097494459) // http://oeis.org/A000796
Phi = float32(1.61803398874989484820458683436563811772030917980576286213544862) // http://oeis.org/A001622

Sqrt2   = float32(1.41421356237309504880168872420969807856967187537694807317667974) // http://oeis.org/A002193
SqrtE   = float32(1.64872127070012814684865078781416357165377610071014801157507931) // http://oeis.org/A019774
SqrtPi  = float32(1.77245385090551602729816748334114518279754945612238712821380779) // http://oeis.org/A002161
SqrtPhi = float32(1.27201964951406896425242246173749149171560804184009624861664038) // http://oeis.org/A139339

Ln2    = float32(0.693147180559945309417232121458176568075500134360255254120680009) // http://oeis.org/A002162
Log2E  = float32(1 / Ln2)
Ln10   = float32(2.30258509299404568401799145468436420760110148862877297603332790) // http://oeis.org/A002392
Log10E = float32(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.

View Source
```const (
MaxInt8   = 1<<7 - 1
MinInt8   = -1 << 7
MaxInt16  = 1<<15 - 1
MinInt16  = -1 << 15
MaxInt32  = 1<<31 - 1
MinInt32  = -1 << 31
MaxInt64  = 1<<63 - 1
MinInt64  = -1 << 63
MaxUint8  = 1<<8 - 1
MaxUint16 = 1<<16 - 1
MaxUint32 = 1<<32 - 1
MaxUint64 = 1<<64 - 1
)```

Integer limit values.

Variables ¶

This section is empty.

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`

Acos returns the arccosine, in radians, of x.

Special case is:

```Acos(x) = NaN if x < -1 or x > 1
```

func Acosh ¶

`func Acosh(x float32) float32`

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 ¶

`func Asin(x float32) float32`

func Asinh ¶

`func Asinh(x float32) float32`

Asinh returns the inverse hyperbolic sine of x.

Special cases are:

```Asinh(±0) = ±0
Asinh(±Inf) = ±Inf
Asinh(NaN) = NaN
```

func Atan ¶

`func Atan(x float32) float32`

func Atan2 ¶

`func Atan2(y, x float32) float32`

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 ¶

`func Atanh(x float32) float32`

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 ¶

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

`func Copysign(x, y float32) float32`

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 Round ¶ added in v1.10.1

`func Round(value float32) float32`

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

func Tan ¶

`func Tan(x float32) float32`

func Tanh ¶

`func Tanh(x float32) float32`

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.