# math #

## Constants #

``````const (
e        = 2.71828182845904523536028747135266249775724709369995957496696763
pi       = 3.14159265358979323846264338327950288419716939937510582097494459
pi_2     = pi / 2.0
pi_4     = pi / 4.0
phi      = 1.61803398874989484820458683436563811772030917980576286213544862
tau      = 6.28318530717958647692528676655900576839433879875021164194988918
sqrt2    = 1.41421356237309504880168872420969807856967187537694807317667974
sqrt_e   = 1.64872127070012814684865078781416357165377610071014801157507931
sqrt_pi  = 1.77245385090551602729816748334114518279754945612238712821380779
sqrt_tau = 2.50662827463100050241576528481104525300698674060993831662992357
sqrt_phi = 1.27201964951406896425242246173749149171560804184009624861664038
ln2      = 0.693147180559945309417232121458176568075500134360255254120680009
log2_e   = 1.0 / ln2
ln10     = 2.30258509299404568401799145468436420760110148862877297603332790
log10_e  = 1.0 / ln10
)``````
``````const (
max_f32               = 3.40282346638528859811704183484516925440e+38
smallest_non_zero_f32 = 1.401298464324817070923729583289916131280e-45
max_f64               = 1.797693134862315708145274237317043567981e+308
smallest_non_zero_f64 = 4.940656458412465441765687928682213723651e-324
)``````

Floating-point limit values max is the largest finite value representable by the type.
smallest_non_zero is the smallest positive, non-zero value representable by the type.

``````const (
max_i8  = 127
min_i8  = -128
max_i16 = 32767
min_i16 = -32768
max_i32 = 2147483647
min_i32 = -2147483648

min_i64 = i64(-9223372036854775807 - 1)
max_i64 = i64(9223372036854775807)
max_u8  = 255
max_u16 = 65535
max_u32 = u32(4294967295)
max_u64 = u64(18446744073709551615)
)``````

Integer limit values

## fn abs #

``fn abs(x f64) f64``

Returns the absolute value.

## fn acos #

``fn acos(x f64) f64``

acos returns the arccosine, in radians, of x.

special case is: acos(x) = nan if x < -1 or x > 1

## fn acosh #

``fn acosh(x f64) f64``

## fn alike #

``fn alike(a f64, b f64) bool``

## fn aprox_cos #

``fn aprox_cos(a f64) f64``

aprox_cos returns an approximation of sin(a) made using lolremez

## fn aprox_sin #

``fn aprox_sin(a f64) f64``

aprox_sin returns an approximation of sin(a) made using lolremez

## fn asin #

``fn asin(x_ f64) f64``

asin returns the arcsine, in radians, of x.

special cases are: asin(±0) = ±0 asin(x) = nan if x < -1 or x > 1

## fn asinh #

``fn asinh(x f64) f64``

## fn atan #

``fn atan(x f64) f64``

atan returns the arctangent, in radians, of x.

special cases are: atan(±0) = ±0 atan(±inf) = ±pi/2.0

## fn atan2 #

``fn atan2(y f64, x f64) f64``

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.0 atan2(y<0, 0) = -pi/2.0 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.0 atan2(-inf, x) = -pi/2.0

## fn atanh #

``fn atanh(x f64) f64``

## fn cbrt #

``fn cbrt(a f64) f64``

cbrt returns the cube root of a.

special cases are: cbrt(±0) = ±0 cbrt(±inf) = ±inf cbrt(nan) = nan

## fn ceil #

``fn ceil(x f64) f64``

ceil returns the least integer value greater than or equal to x.

special cases are: ceil(±0) = ±0 ceil(±inf) = ±inf ceil(nan) = nan

## fn clamp #

``fn clamp(x f64, a f64, b f64) f64``

clamp returns x constrained between a and b

## fn close #

``fn close(a f64, b f64) bool``

## fn copysign #

``fn copysign(x f64, y f64) f64``

copysign returns a value with the magnitude of x and the sign of y

## fn cos #

``fn cos(x f64) f64``

## fn cosf #

``fn cosf(a f32) f32``

## fn cosh #

``fn cosh(x f64) f64``

cosh returns the hyperbolic cosine of x.

special cases are: cosh(±0) = 1 cosh(±inf) = +inf cosh(nan) = nan

## fn cot #

``fn cot(a f64) f64``

tan calculates cotangent of a number

## fn degrees #

``fn degrees(radians f64) f64``

degrees converts from radians to degrees.

## fn digits #

``fn digits(_n int, base int) []int``

digits returns an array of the digits of n in the given base.

## fn egcd #

``fn egcd(a i64, b i64) (i64, i64, i64)``

egcd returns (gcd(a, b), x, y) such that |ax + by| = gcd(a, b)

## fn erf #

``fn erf(a f64) f64``

erf returns the error function of x.

special cases are: erf(+inf) = 1 erf(-inf) = -1 erf(nan) = nan

## fn erfc #

``fn erfc(a f64) f64``

erfc returns the complementary error function of x.

special cases are: erfc(+inf) = 0 erfc(-inf) = 2 erfc(nan) = nan

## fn exp #

``fn exp(x f64) f64``

exp returns e**x, the base-e exponential of x.

special cases are: exp(+inf) = +inf exp(nan) = nan Very large values overflow to 0 or +inf.
Very small values underflow to 1.

## fn exp2 #

``fn exp2(x f64) f64``

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

special cases are the same as exp.

## fn expm1 #

``fn expm1(x f64) f64``

special cases are: expm1(+inf) = +inf expm1(-inf) = -1 expm1(nan) = nan

## fn f32_bits #

``fn f32_bits(f f32) u32``

f32_bits returns the IEEE 754 binary representation of f, with the sign bit of f and the result in the same bit position.
f32_bits(f32_from_bits(x)) == x.

## fn f32_from_bits #

``fn f32_from_bits(b u32) f32``

f32_from_bits returns the floating-point number corresponding to the IEEE 754 binary representation b, with the sign bit of b and the result in the same bit position.
f32_from_bits(f32_bits(x)) == x.

## fn f64_bits #

``fn f64_bits(f f64) u64``

f64_bits returns the IEEE 754 binary representation of f, with the sign bit of f and the result in the same bit position, and f64_bits(f64_from_bits(x)) == x.

## fn f64_from_bits #

``fn f64_from_bits(b u64) f64``

f64_from_bits returns the floating-point number corresponding to the IEEE 754 binary representation b, with the sign bit of b and the result in the same bit position.
f64_from_bits(f64_bits(x)) == x.

## fn fabs #

``fn fabs(x f64) f64``

## fn factorial #

``fn factorial(n f64) f64``

factorial calculates the factorial of the provided value.

## fn factoriali #

``fn factoriali(n int) i64``

factoriali returns 1 for n <= 0 and -1 if the result is too large for a 64 bit integer

## fn floor #

``fn floor(x f64) f64``

floor returns the greatest integer value less than or equal to x.

special cases are: floor(±0) = ±0 floor(±inf) = ±inf floor(nan) = nan

## fn fmod #

``fn fmod(x f64, y f64) f64``

fmod returns the floating-point remainder of number / denom (rounded towards zero)

## fn frexp #

``fn frexp(x f64) (f64, 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 pub fn frexp(f f64) (f64, int) { mut y := f64_bits(x) ee := int((y >> 52) & 0x7ff) // special cases if ee == 0 { if x != 0.0 { x1p64 := f64_from_bits(0x43f0000000000000) z,e_ := frexp(x * x1p64) return z,e_ - 64 } return x,0 } else if ee == 0x7ff { return x,0 } e_ := ee - 0x3fe y &= 0x800fffffffffffff y |= 0x3fe0000000000000 return f64_from_bits(y),e_

## fn gamma #

``fn gamma(a f64) f64``

gamma returns the gamma function of x.

special ifs are: gamma(+inf) = +inf gamma(+0) = +inf gamma(-0) = -inf gamma(x) = nan for integer x < 0 gamma(-inf) = nan gamma(nan) = nan

## fn gcd #

``fn gcd(a_ i64, b_ i64) i64``

gcd calculates greatest common (positive) divisor (or zero if a and b are both zero).

## fn get_high_word #

``fn get_high_word(f f64) u32``

get_high_word returns high part of the word of `f`.

## fn hypot #

``fn hypot(x f64, y f64) f64``

## fn ilog_b #

``fn ilog_b(x f64) int``

ilog_b returns the binary exponent of x as an integer.

special cases are: ilog_b(±inf) = max_i32 ilog_b(0) = min_i32 ilog_b(nan) = max_i32

## fn inf #

``fn inf(sign int) f64``

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

## fn is_finite #

``fn is_finite(f f64) bool``

## fn is_inf #

``fn is_inf(f f64, sign int) bool``

is_inf reports whether f is an infinity, according to sign.
If sign > 0, is_inf reports whether f is positive infinity.
If sign < 0, is_inf reports whether f is negative infinity.
If sign == 0, is_inf reports whether f is either infinity.

## fn is_nan #

``fn is_nan(f f64) bool``

is_nan reports whether f is an IEEE 754 ``not-a-number'' value.

## fn lcm #

``fn lcm(a i64, b i64) i64``

lcm calculates least common (non-negative) multiple.

## fn ldexp #

``fn ldexp(frac f64, exp int) f64``

## fn log #

``fn log(a f64) f64``

log returns the logarithm of x

Method : 1. Argument Reduction: find k and f such that x = 2^k * (1+f), where sqrt(2)/2 < 1+f < sqrt(2) .

1. Approximation of log(1+f).
Let s = f/(2+f) ; based on log(1+f) = log(1+s) - log(1-s) = 2s + 2/3 s3 + 2/5 s5 + ....., = 2s + sR We use a special Remez algorithm on [0,0.1716] to generate a polynomial of degree 14 to approximate R The maximum error of this polynomial approximation is bounded by 2**-58.45. In other words, 2 4 6 8 10 12 14 R(z) ~ Lg1s +Lg2s +Lg3s +Lg4s +Lg5s +Lg6s +Lg7s (the values of Lg1 to Lg7 are listed in the program) and | 2 14 | -58.45 | Lg1s +...+Lg7s - R(z) | <= 2 | | Note that 2s = f - sf = f - hfsq + shfsq, where hfsq = ff/2.
In order to guarantee error in log below 1ulp, we compute log by log(1+f) = f - s
(f - R) (if f is not too large) log(1+f) = f - (hfsq - s*(hfsq+R)). (better accuracy)

1. Finally, log(x) = kln2 + log(1+f).
= k
ln2_hi+(f-(hfsq-(s*(hfsq+R)+kln2_lo))) Here ln2 is split into two floating point number: ln2_hi + ln2_lo, where nln2_hi is always exact for |n| < 2000.

Special cases: log(x) is NaN with signal if x < 0 (including -inf) ; log(+inf) is +inf; log(0) is -inf with signal; log(NaN) is that NaN with no signal.

Accuracy: according to an error analysis, the error is always less than 1 ulp (unit in the last place).

## fn log10 #

``fn log10(x f64) f64``

log10 returns the decimal logarithm of x.
The special cases are the same as for log.

## fn log1p #

``fn log1p(x f64) f64``

## fn log2 #

``fn log2(x f64) f64``

log2 returns the binary logarithm of x.
The special cases are the same as for log.

## fn log_b #

``fn log_b(x f64) f64``

log_b returns the binary exponent of x.

special cases are: log_b(±inf) = +inf log_b(0) = -inf log_b(nan) = nan

## fn log_factorial #

``fn log_factorial(n f64) f64``

log_factorial calculates the log-factorial of the provided value.

## fn log_gamma #

``fn log_gamma(x f64) f64``

log_gamma returns the natural logarithm and sign (-1 or +1) of Gamma(x).

special ifs are: log_gamma(+inf) = +inf log_gamma(0) = +inf log_gamma(-integer) = +inf log_gamma(-inf) = -inf log_gamma(nan) = nan

## fn log_gamma_sign #

``fn log_gamma_sign(a f64) (f64, int)``

## fn log_n #

``fn log_n(x f64, b f64) f64``

## fn max #

``fn max(a f64, b f64) f64``

max returns the maximum value of the two provided.

## fn min #

``fn min(a f64, b f64) f64``

min returns the minimum value of the two provided.

## fn minmax #

``fn minmax(a f64, b f64) (f64, f64)``

minmax returns the minimum and maximum value of the two provided.

## fn mod #

``fn mod(x f64, y f64) f64``

Floating-point mod function.
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

## fn modf #

``fn modf(f f64) (f64, f64)``

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

## fn nan #

``fn nan() f64``

nan returns an IEEE 754 ``not-a-number'' value.

## fn nextafter #

``fn nextafter(x f64, y f64) f64``

nextafter returns the next representable f64 value after x towards y.

special cases are: nextafter(x, x) = x nextafter(nan, y) = nan nextafter(x, nan) = nan

## fn nextafter32 #

``fn nextafter32(x f32, y f32) f32``

nextafter32 returns the next representable f32 value after x towards y.

special cases are: nextafter32(x, x) = x nextafter32(nan, y) = nan nextafter32(x, nan) = nan

## fn normalize #

``fn normalize(x f64) (f64, int)``

normalize returns a normal number y and exponent exp satisfying x == y × 2**exp. It assumes x is finite and non-zero.

## fn pow #

``fn pow(x f64, y f64) f64``

pow returns base raised to the provided power.

todo(playXE): make this function work on JS backend, probably problem of JS codegen that it does not work.

## fn pow10 #

``fn pow10(n int) f64``

pow10 returns 10**n, the base-10 exponential of n.

special cases are: pow10(n) = 0 for n < -323 pow10(n) = +inf for n > 308

## fn powf #

``fn powf(a f32, b f32) f32``

## fn powi #

``fn powi(a i64, b i64) i64``

powi returns base raised to power (a**b) as an integer (i64)

special case: powi(a, b) = -1 for a = 0 and b < 0

## fn q_rsqrt #

``fn q_rsqrt(x f64) f64``

``fn radians(degrees f64) f64``

## fn round #

``fn round(x f64) f64``

round returns the nearest integer, rounding half away from zero.

special cases are: round(±0) = ±0 round(±inf) = ±inf round(nan) = nan

## fn round_to_even #

``fn round_to_even(x f64) f64``

round_to_even returns the nearest integer, rounding ties to even.

special cases are: round_to_even(±0) = ±0 round_to_even(±inf) = ±inf round_to_even(nan) = nan

## fn scalbn #

``fn scalbn(x f64, n_ int) f64``

scalbn scales x by FLT_RADIX raised to the power of n, returning the same as: scalbn(x,n) = x * FLT_RADIX ** n

## fn sign #

``fn sign(n f64) f64``

sign returns the corresponding sign -1.0, 1.0 of the provided number.
if n is not a number, its sign is nan too.

## fn signbit #

``fn signbit(x f64) bool``

signbit returns a value with the boolean representation of the sign for x

## fn signi #

``fn signi(n f64) int``

signi returns the corresponding sign -1.0, 1.0 of the provided number.

## fn sin #

``fn sin(x f64) f64``

## fn sincos #

``fn sincos(x f64) (f64, f64)``

## fn sinf #

``fn sinf(a f32) f32``

sinf calculates sine. (float32)

## fn sinh #

``fn sinh(x_ f64) f64``

sinh calculates hyperbolic sine.

## fn sqrt #

``fn sqrt(a f64) f64``

special cases are: sqrt(+inf) = +inf sqrt(±0) = ±0 sqrt(x < 0) = nan sqrt(nan) = nan

## fn sqrtf #

``fn sqrtf(a f32) f32``

## fn sqrti #

``fn sqrti(a i64) i64``

sqrti calculates the integer square-root of the provided value. (i64)

## fn tan #

``fn tan(a f64) f64``

tan calculates tangent of a number

## fn tanf #

``fn tanf(a f32) f32``

## fn tanh #

``fn tanh(x f64) f64``

tanh returns the hyperbolic tangent of x.

special cases are: tanh(±0) = ±0 tanh(±inf) = ±1 tanh(nan) = nan

## fn tolerance #

``fn tolerance(a f64, b f64, tol f64) bool``

## fn trunc #

``fn trunc(x f64) f64``

trunc returns the integer value of x.

special cases are: trunc(±0) = ±0 trunc(±inf) = ±inf trunc(nan) = nan

## fn veryclose #

``fn veryclose(a f64, b f64) bool``

## fn with_set_high_word #

``fn with_set_high_word(f f64, hi u32) f64``

with_set_high_word sets high word of `f` to `lo`

## fn with_set_low_word #

``fn with_set_low_word(f f64, lo u32) f64``

with_set_low_word sets low word of `f` to `lo`