math #

Description

math provides commonly used mathematical functions for trigonometry, logarithms, etc.

fn abs[T](a T) T

abs returns the absolute value of a

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(x f64) f64

acosh returns the non-negative area hyperbolic cosine of x

fn alike(a f64, b f64) bool

alike checks if a and b are equal

fn angle_diff(radian_a f64, radian_b f64) f64

angle_diff calculates the difference between angles in radians

fn aprox_cos(a f64) f64

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

fn aprox_sin(a f64) f64

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

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(x f64) f64

asinh returns the area hyperbolic sine of x

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(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(x f64) f64

atanh returns the area hyperbolic tangent of x

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(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(x f64, a f64, b f64) f64

clamp returns x constrained between a and b

fn clip[T](x T, min_value T, max_value T) T

clip constrain the given value x, to lie between two further values min_value and max_value. See: https://registry.khronos.org/OpenGL-Refpages/gl4/html/clamp.xhtml Also: https://en.wikipedia.org/wiki/Clamp_(function)

fn close(actual f64, expected f64) bool

close checks if actual and expected are within 1e-14 of each other

Note: the actual and expected parameters are NOT symmetrical. If you compare against a known expected number, put it in the second argument, especially if it is 0.

fn copysign(x f64, y f64) f64

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

fn cos(a f64) f64

cos calculates cosine in radians (float64)

fn cosf(a f32) f32

cosf calculates cosine in radians (float32)

fn cosh(x f64) f64

cosh returns the hyperbolic cosine of x in radians

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

fn cot(a f64) f64

tan calculates cotangent of a number

fn count_digits(number i64) int

count_digits return the number of digits in the number passed. Number argument accepts any integer type (i8|i16|int|isize|i64) and will be cast to i64

fn cube[T](x T) T

cube returns the cube of the argument x, i.e. x * x * x

fn cubic_bezier(t f64, p []BezierPoint) BezierPoint

cubic_bezier returns a linear interpolation between the control points, specified by their X and Y coordinates in a single array of points p, and given the parameter t, varying between 0.0 and 1.0 . When t == 0.0, the output is P[0] . When t == 1.0, the output is P[3] . The points x[1],y[1] and x[2],y[2], serve as attractors.

fn cubic_bezier_a(t f64, x []f64, y []f64) BezierPoint

cubic_bezier_a returns a linear interpolation between the control points, specified by their X and Y coordinates in 2 arrays, and given the parameter t, varying between 0.0 and 1.0 . When t == 0.0, the output is x[0],y[0] . When t == 1.0, the output is x[3],y[3] . The points x[1],y[1] and x[2],y[2], serve as attractors.

fn cubic_bezier_coords(t f64, x0 f64, x1 f64, x2 f64, x3 f64, y0 f64, y1 f64, y2 f64, y3 f64) BezierPoint

cubic_bezier_coords returns a linear interpolation between the control points, specified by their X and Y coordinates, and given the parameter t, varying between 0.0 and 1.0 . When t == 0.0, the output is x0,y0 . When t == 1.0, the output is x3,y3 . The points x1,y1 and x2,y2, serve as attractors.

fn cubic_bezier_fa(t f64, x [4]f64, y [4]f64) BezierPoint

cubic_bezier_fa returns a linear interpolation between the control points, specified by their X and Y coordinates in 2 fixed arrays, and given the parameter t, varying between 0.0 and 1.0 . When t == 0.0, the output is x[0],y[0] . When t == 1.0, the output is x[3],y[3] . The points x[1],y[1] and x[2],y[2], serve as attractors.

fn degrees(radians f64) f64

degrees converts an angle in radians to a corresponding angle in degrees.

fn digits(num i64, params DigitParams) []int

You can also use it, with an explicit reverse: true parameter, (it will do a reverse of the result array internally => slower):

assert math.digits(12345, base: 10) == [5,4,3,2,1]

assert math.digits(12345, reverse: true) == [1,2,3,4,5]

fn divide_euclid[T](numer T, denom T) DivResult[T]

divide_euclid returns the Euclidean version of the result of dividing numer to denom

fn divide_floored[T](numer T, denom T) DivResult[T]

divide_floored returns the floored version of the result of dividing numer to denom

fn divide_truncated[T](numer T, denom T) DivResult[T]

divide_truncated returns the truncated version of the result of dividing numer to denom

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(a f64) f64

erf returns the error function of x.

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

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(x f64) f64

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

fn exp2(x f64) f64

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

fn expm1(x f64) f64

expm1 calculates e**x - 1 special cases are: expm1(+inf) = +inf expm1(-inf) = -1 expm1(nan) = nan

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(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(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(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 factorial(n f64) f64

factorial calculates the factorial of the provided value.

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(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 floorf(x f32) f32

floorf 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(x f64, y f64) f64

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

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(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(a_ i64, b_ i64) i64

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

fn get_high_word(f f64) u32

get_high_word returns high part of the word of f.

fn hypot(x f64, y f64) f64

hypot returns the hypotenuse of the triangle give two sides

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(sign int) f64

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

fn is_finite(f f64) bool

is_finite returns true if f is finite

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(f f64) bool

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

fn lcm(a i64, b i64) i64

lcm calculates least common (non-negative) multiple.

fn ldexp(frac f64, exp int) f64

ldexp calculates frac*(2**exp).

fn log(x f64) f64

log returns the natural logarithm of x (float64)

fn log10(x f64) f64

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

fn log1p(x f64) f64

log1p returns log(1+x).

fn log2(x f64) f64

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

fn log_b(x f64) f64

log_b returns the binary exponent of x.

fn log_factorial(n f64) f64

log_factorial calculates the log-factorial of the provided value.

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(a f64) (f64, int)

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

fn log_n(x f64, b f64) f64

log_n returns log base b of x

fn logf(x f32) f32

log returns the natural logarithm of x (float32)

fn max[T](a T, b T) T

max returns the maximum of a and b

fn maxof[T]() T

maxof returns the maximum value of the type T

fn min[T](a T, b T) T

min returns the minimum of a and b

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

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

fn minof[T]() T

minof returns the minimum value of the type T

fn mix[T](start T, end T, t T) T

mix performs a linear interpolation (LERP) mix between start and end, using t to weight between them. t should be in the closed interval [0, 1]. For t == 0, the output is x.

Note: mix is calculated in such a way, that the output will be y, when t == 1.0 . See: https://registry.khronos.org/OpenGL-Refpages/gl4/html/mix.xhtml Also: https://en.wikipedia.org/wiki/Linear_interpolation .

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(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 modulo_euclid[T](numer T, denom T) T

modulo_euclid returns the Euclidean remainder of dividing numer to denom

fn modulo_floored[T](numer T, denom T) T

modulo_floored returns the floored remainder of dividing numer to denom

fn modulo_truncated[T](numer T, denom T) T

modulo_truncated returns the truncated remainder of dividing numer to denom

fn nan() f64

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

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(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(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(x f64, y f64) f64

pow returns the base x, raised to the provided power y. (float64)

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(a f32, b f32) f32

powf returns the base a, raised to the provided power b. (float32)

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(x f64) f64

q_sqrt computes an approximation of the inverse square root (1 / √x) using a fast inverse square root algorithm. This method is often used in applications where performance is crucial, such as in computer graphics or physics simulations. (This algorithm is inspired by the famous "fast inverse square root" code used in the Quake III Arena game engine.)

fn radians(degrees f64) f64

radians converts an angle in degrees to a corresponding angle in radians.

fn remap[T](x T, a T, b T, c T, d T) T

Note: a should be != b.

math.remap(20, 1, 100, 50, 5000) == 1000

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_sig(x f64, sig_digits int) f64

Returns the rounded float, with sig_digits of precision. i.e assert round_sig(4.3239437319748394,6) == 4.323944

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(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(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(x f64) bool

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

fn signi(n f64) int

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

fn sin(a f64) f64

sin calculates sine in radians (float64)

fn sincos(x f64) (f64, f64)

sincos calculates the sine and cosine of the angle in radians

fn sinf(a f32) f32

sinf calculates sine in radians (float32)

fn sinh(x_ f64) f64

sinh calculates hyperbolic sine.

fn smootherstep[T](edge0 T, edge1 T, x T) T

smootherstep smoothly maps a value between edge0 and edge1. smootherstep is a 2nd order smoothing function, using a 5th order polynomial. The 1st and 2nd order derivatives of the smootherstep function are 0 at both edges. See also smoothstep, which is faster, but has just its gradient being 0 at both edges. See also https://en.wikipedia.org/wiki/Smoothstep

fn smoothstep[T](edge0 T, edge1 T, x T) T

smoothstep smoothly maps a value between edge0 and edge1. It returns: 0 if x is less than or equal to the left edge0, 1 if x is greater than or equal to the right edge, and smoothly interpolates, using a Hermite polynomial, between 0 and 1 otherwise. The gradient of the smoothstep function is zero at both edges. This is convenient for creating a sequence of transitions using smoothstep to interpolate each segment as an alternative to using more sophisticated or expensive interpolation techniques. smoothstep is a 1st order smoothing function, using a 3rd order polynomial. See also smootherstep, which is slower, but nicer looking. See also https://en.wikipedia.org/wiki/Smoothstep

fn sqrt(a f64) f64

sqrt calculates square-root of the provided value. (float64)

fn sqrtf(a f32) f32

sqrtf calculates square-root of the provided value. (float32)

fn sqrti(a i64) i64

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

fn square[T](x T) T

square returns the square of the argument x, i.e. x * x

fn tan(a f64) f64

tan calculates tangent of a number

fn tanf(a f32) f32

tanf calculates tangent. (float32)

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(actual f64, expected f64, tol f64) bool

tolerance checks if the difference between actual and expected numbers, is less than or equal to the tolerance value tol.

Note: the actual and expected parameters are NOT symmetrical. If you compare against a known expected number, put it in the second argument, especially if it is 0.

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(actual f64, expected f64) bool

veryclose checks if a and b are within 4e-16 of each other

Note: the actual and expected parameters are NOT symmetrical. If you compare against a known expected number, put it in the second argument, especially if it is 0.

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(f f64, lo u32) f64

with_set_low_word sets low word of f to lo

struct BezierPoint {
pub mut:
	x f64
	y f64
}

BezierPoint represents point coordinates as floating point numbers. This type is used as the output of the cubic_bezier family of functions.

struct DigitParams {
pub:
	base    int = 10
	reverse bool
}

struct DivResult[T] {
pub mut:
	quot T
	rem  T
}

DivResult[T] represents the result of an integer division (both quotient and remainder) See also https://en.wikipedia.org/wiki/Modulo