math32

package module

v1.10.1 Latest Latest Go to latest Published: Nov 15, 2021 License: BSD-2-Clause Imports: 3 Imported by: 181

Details

Valid go.mod file

The Go module system was introduced in Go 1.11 and is the official dependency management solution for Go.
Redistributable license

Redistributable licenses place minimal restrictions on how software can be used, modified, and redistributed.
Tagged version

Modules with tagged versions give importers more predictable builds.
Stable version

When a project reaches major version v1 it is considered stable.
Learn more about best practices

Repository

github.com/chewxy/math32

Links

Open Source Insights

README ¶

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

Index ¶

Constants
func Abs(x float32) float32
func Acos(x float32) float32
func Acosh(x float32) float32
func Asin(x float32) float32
func Asinh(x float32) float32
func Atan(x float32) float32
func Atan2(y, x float32) float32
func Atanh(x float32) float32
func Cbrt(x float32) float32
func Ceil(x float32) float32
func Copysign(x, y float32) float32
func Cos(x float32) float32
func Cosh(x float32) float32
func Dim(x, y float32) float32
func Erf(x float32) float32
func Erfc(x float32) float32
func Exp(x float32) float32
func Exp2(x float32) float32
func Expm1(x float32) float32
func Float32bits(f float32) uint32
func Float32frombits(b uint32) float32
func Float64bits(f float64) uint64
func Float64frombits(b uint64) float64
func Floor(x float32) float32
func Frexp(f float32) (frac float32, exp int)
func Gamma(x float32) float32
func Hypot(p, q float32) float32
func Ilogb(x float32) int
func Inf(sign int) float32
func IsInf(f float32, sign int) bool
func IsNaN(f float32) (is bool)
func J0(x float32) float32
func J1(x float32) float32
func Jn(n int, x float32) float32
func Ldexp(frac float32, exp int) float32
func Lgamma(x float32) (lgamma float32, sign int)
func Log(x float32) float32
func Log10(x float32) float32
func Log1p(x float32) float32
func Log2(x float32) float32
func Logb(x float32) float32
func Max(x, y float32) float32
func Min(x, y float32) float32
func Mod(x, y float32) float32
func Modf(f float32) (int float32, frac float32)
func NaN() float32
func Nextafter(x, y float32) (r float32)
func Pow(x, y float32) float32
func Pow10(e int) float32
func Remainder(x, y float32) float32
func Round(value float32) float32
func Signbit(x float32) bool
func Sin(x float32) float32
func Sincos(x float32) (sin, cos float32)
func Sinh(x float32) float32
func Sqrt(x float32) float32
func Tan(x float32) float32
func Tanh(x float32) float32
func Trunc(x float32) float32
func Y0(x float32) float32
func Y1(x float32) float32
func Yn(n int, x float32) float32

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.

Source Files ¶

View all Source files

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL