Kryzeth Standard Library

StdLib.Utils.Math

Extensions to Lua's standard math library.

See:

math

@usage local math = require('kry_stdlib/stdlib/utils/math') --[[@as StdLib.Utils.Math]]

Methods49 

function Math.frexp(x: number) -> (number, integer)
 
function Math.sqrt(x: number) -> number
 
function Math.asin(x: number) -> number
 
function Math.random(m: integer, n: integer) -> integer
Overloads
function Math.random() -> number
function Math.random(m: integer) -> integer
function Math.abs(x: number) -> number
Overloads
function Math.abs(x: integer) -> integer
function Math.ldexp(m: number, e: integer) -> number
 
function Math.exp(x: number) -> number
 
function Math.pow(x: number, y: number) -> number
Parameters
xnumber

The base

ynumber

The exponent

Returns
number
function Math.tan(x: number) -> number
 
function Math.acos(x: number) -> number
 
function Math.ceil(x: number) -> integer
 
function Math.atan2(y: number, x: number) -> number
 
function Math.tanh(x: number) -> number
 
function Math.sin(x: number) -> number
 
function Math.min(x: number, ...: number) -> number
Overloads
function Math.min(x: integer, ...: integer) -> integer
function Math.deg(x: number) -> number
 
function Math.sinh(x: number) -> number
 
function Math.rad(x: number) -> number
 
function Math.cosh(x: number) -> number
 
function Math.modf(x: number) -> (integer, number)
 
function Math.cos(x: number) -> number
 
function Math.atan(y: number, x: nil | number) -> number
 
function Math.max(x: number, ...: number) -> number
Overloads
function Math.max(x: integer, ...: integer) -> integer
function Math.log(x: number, base: nil | number) -> number
 
function Math.fmod(x: number, y: number) -> number
 
function Math.floor(x: number) -> integer
 
function Math.log10(x) -> number
 
function Math.round(x: number) -> the number

Round a number.

Parameters
xnumber
Returns
thenumber

rounded number

function Math.round_to(x: number, p: nil | integer) -> rounded number

Returns the number x rounded to p decimal places.

Parameters
xnumber
pnil | integer

[opt=0] the number of decimal places to round to

Returns
roundednumber

to p decimal spaces.

function Math.floor_to(x: number, p: nil | integer) -> floored number

Returns the number floored to p decimal spaces.

Parameters
xnumber
pnil | integer

[opt=0] the number of decimal places to floor to

Returns
floorednumber

to p decimal spaces.

function Math.ceil_to(x: number, p: nil | integer) -> ceiled number

Returns the number ceiled to p decimal spaces.

Parameters
xnumber
pnil | integer

[opt=0] the number of decimal places to ceil to

Returns
ceilednumber

to p decimal spaces.

function Math.sum(...: number) -> number

Calculates the sum of a sequence of values.

Overloads
function Math.sum(...: number) -> number
function Math.sum(array: number[]) -> number
Parameters
...number

a tuple of numbers

Returns
number

the sum

function Math.arithmetic_mean(...: number) -> number

Calculates the arithmetic mean of a set of values.

Overloads
function Math.arithmetic_mean(...: number) -> number
function Math.arithmetic_mean(array: number[]) -> number
Parameters
...number

an array of numbers

Returns
number

the arithmetic mean

function Math.avg(...: number) -> number
Overloads
function Math.avg(...: number) -> number
function Math.avg(array: number[]) -> number
Parameters
...number

an array of numbers

Returns
number

the arithmetic mean

function Math.average(...: number) -> number
Overloads
function Math.average(...: number) -> number
function Math.average(array: number[]) -> number
Parameters
...number

an array of numbers

Returns
number

the arithmetic mean

function Math.geometric_mean(...: number) -> the number

Calculates the geometric mean of a set of values.

Overloads
function Math.geometric_mean(...: number) -> number
function Math.geometric_mean(array: number[]) -> number
Parameters
...number

an array of numbers

Returns
thenumber

geometric mean

function Math.harmonic_mean(...: number) -> number

Calculates the harmonic mean of a set of values.

Overloads
function Math.harmonic_mean(...: number) -> number
function Math.harmonic_mean(array: number[]) -> number
Parameters
...number

an array of numbers

Returns
number

the harmonic mean

function Math.quadratic_mean(...: number) -> number

Calculates the quadratic mean of a set of values.

Overloads
function Math.quadratic_mean(...: number) -> number
function Math.quadratic_mean(array: number[]) -> number
Parameters
...number

an array of numbers

Returns
number

the quadratic mean

function Math.generalized_mean(p: number, ...: number) -> number

Calculates the generalized mean (to a specified power) of a set of values.

Overloads
function Math.generalized_mean(...: number) -> number
function Math.generalized_mean(array: number[]) -> number
Parameters
pnumber

power

...number

an array of numbers

Returns
number

the generalized mean

function Math.weighted_mean(x: number[], w: number[]) -> number

Calculates the weighted mean of a set of values.

Parameters
xnumber[]

an array of numbers

wnumber[]

an array of number weights for each value

Returns
number

the weighted mean

function Math.midrange_mean(...: number) -> number

Calculates the midrange mean of a set of values.

Overloads
function Math.midrange_mean(...: number) -> number
function Math.midrange_mean(array: number[]) -> number
Parameters
...number

an array of numbers

Returns
number

the midrange mean

function Math.energetic_mean(...: number) -> number

Calculates the energetic mean of a set of values.

Overloads
function Math.energetic_mean(...: number) -> number
function Math.energetic_mean(array: number[]) -> number
Parameters
...number

an array of numbers

Returns
number

the energetic mean

function Math.clamp(x: number, min: nil | number, max: nil | number) -> clamped number

Returns the number x clamped between the numbers min and max.

Parameters
xnumber
minnil | number

[opt=0]

maxnil | number

[opt=1]

Returns
clampednumber

between min and max

function Math.lerp(a: number, b: number, amount: float) -> number

Linear interpolation or 2 numbers.

function Math.smooth(a: number, b: number, amount: float) -> number

Smooth.

function Math.approximately(a: number, b: number) -> boolean

Approximately the same

function Math.is_number(x: number) -> boolean

Is x a number.

function Math.is_integer(x: number) -> boolean

Is x an integer.

function Math.is_unsigned(x: number) -> boolean

Is x unsigned.

Fields35

Math.huge : number
 
Math.pi: number = 3.1415
 
Math.DEG2RAD: number = 0.01745277777777778

(( Math Constants

Math.RAD2DEG: number = 57.29746936176985
 
Math.EPSILON: number = 0.000000000000000000000000000000000000000000001401298
 
Math.MAXINT8: integer = 128
 
Math.MININT8: integer = -128
 
Math.MAXUINT8: integer = 255
 
Math.MAX_INT8: integer = 128
 
Math.MIN_INT8: integer = -128
 
Math.MAX_UINT8: integer = 255
 
Math.MAXINT16: integer = 32768
 
Math.MININT16: integer = -32768
 
Math.MAXUINT16: integer = 65535
 
Math.MAX_INT16: integer = 32768
 
Math.MIN_INT16: integer = -32768
 
Math.MAX_UINT16: integer = 65535
 
Math.MAXINT: integer = 2147483648
 
Math.MAX_INT: integer = 2147483648
 
Math.MAXINT32: integer = 2147483648
 
Math.MAX_INT32: integer = 2147483648
 
Math.MAXUINT: integer = 4294967296
 
Math.MAX_UINT: integer = 4294967296
 
Math.MAXUINT32: integer = 4294967296
 
Math.MAX_UINT32: integer = 4294967296
 
Math.MININT: integer = -2147483648
 
Math.MIN_INT: integer = -2147483648
 
Math.MININT32: integer = -2147483648
 
Math.MIN_INT32: integer = -2147483648
 
Math.MAXINT64: number = 9223372036854776000.0
 
Math.MININT64: number = -9223372036854776000.0
 
Math.MAXUINT64: number = 18446744073709552000.0
 
Math.MAX_INT64: number = 9223372036854776000.0
 
Math.MIN_INT64: number = -9223372036854776000.0
 
Math.MAX_UINT64: number = 18446744073709552000.0