vornmath

March 12, 2026 · View on GitHub

Vorn's Lua Math Library

Vornmath is (will be) a comprehensive vector and complex math library for lua. It works on lua versions 5.1 through 5.4 as well as luajit.

Installing and Using

Vornmath is a single file, pure Lua library; it does not add any symbols to global. Just put vornmath.lua somewhere convenient in your source tree and do

local vm = require('vornmath')

You don't even need to bring a license file alongside, there's one onboard!

All Vornmath functions that return objects of types that are made of tables - so anything that would return a vector, matrix, complex, or quaternion - accept out variables. The out variable has to be the same type; the object merely gets its fields filled in. The object is also returned when an outvar is provided; because there are some cases where giving varying types to a function may only sometimes result in a type where an out variable actually successfully changes its target, it is a good idea to not only pass the out variable but also assign the result to the same place:

result_vec = vm.add(left_vec, right_vec, result_vec)

For functions like atan where some parameters are optional, the outvar is still in the same position, with nil taking the place of those optional things.

result = vm.atan(angle, nil, result)

Generic and specific forms

All functions in vornmath come in two forms: one in which it is generic and accepts arguments of any types that are valid for the function, and one in which the types being passed in are already specified as part of the name. For instance, the multiplication function mul can accept a great variety of types for its inputs, so it has many signatures, some of which are:

mul
mul_number_number_nil
mul_vec3_cvec3_nil
mul_mat4_number_mat4

When passing an outvar to a specific-form function, the out variable's type is part of the signature, and so is included in the name.

The specified ones have one particular advantage: they are a little faster because they don't do additional function calls to perform dispatch into the correct function. On the other hand they do have long annoying names and cannot accept varying types.

In situations where a function has one signature that is a prefix of another, the shorter signature will include a nil:

atan_number_nil accepts a single number, and
atan_number_number accepts two.

The presence or absence of nil in the signature can be annoying to remember; it is generally a better idea to use vm.utils.bake to find the correct function.

All of these are in the vornmath object. Or would be, except...

Laziness

Functions in Vornmath do not exist prior to being named. This is mostly because there are a lot of functions, and building every single one would make the code huge: fill has over ten million signatures!

So instead, we use some objects called bakeries to describe the patterns that functions fall into and construct these functions the first time they are used. Because of this, examining the vornmath table will not actually name every function available. You will have to rely on this documentation, or examine the bakeries. Technical info about bakeries is down below.

Creating objects

to create an object, call its constructor.

local a = vm.complex() -- creates a complex number, initialized to 0+0i.
local b = vm.complex(3) -- creates a complex number, initialized to 3+0i.
local c = vm.complex(2,-5) -- creates a complex number, initialized to 2-5i.
local d = vm.complex(c) -- creates a duplicate of c.

`fill`

If you already have an object and wish to replace its contents completely, use fill. Usually, this edits the underlying object, but if the object in question is a number or otherwise immutable, it won't be able to change it and you'll instead get a fresh object anyway. to ward off bad consequences of this, only use fill on things not used elsewhere, and when you use fill, assign the result of fill to a value!

fill can be used in any way that a constructor can be used: if you have a constructor for an object, you can replace that constructor with fill and just put the object you want to fill in as the first argument.

local a = vm.complex(1,2) -- a is 1+2i
local b = vm.fill(a,3,4) -- a is now 3+4i, and b is the same object as a.

Operators

Operators exist! They use the most generic form of the function because they can't be relied upon to be called on a particular object in the chain.

Most importantly, however, due to limitations in the way lua implements ==, it is not possible to make a thing that compares non-number objects to numbers! if you expect to be comparing a number and some other type (say, because you want to see if it's 0), you will have to use vm.eq instead.

Types

`number`

vm.number() --> 0
vm.number(n) --> n
vm.number(str, [base]) --> string as number in given base (default 10)

this is Lua's built-in number type. There's not much to say about it!

The interpretation of strings as numbers comes directly from Lua.

`complex`

vm.complex() --> 0 + 0i
vm.complex(a) --> a + 0i
vm.complex(a, b) --> a + bi
vm.complex(a + bi) --> a + bi

Complex numbers, of the form a + bi. They have fields a, the real part, and b, the imaginary part. Some functions (in particular logarithms and sqrt) will behave slightly differently for complex numbers than regular numbers: these functions have some values in which no real answer is possible, and so will not work when given a number, but will when given a complex of equivalent value. In addition, complex numbers do not have a natural ordering, so < and its friends will not work even on real-valued complexes.

`quat`ernion

vm.quat() --> 0 + 0i + 0j + 0k
vm.quat(a) --> a + 0i + 0j + 0k
vm.quat(a,b,c,d) --> a + bi + cj + dk
vm.quat(a+bi) --> a + bi + 0j + 0k
vm.quat(a+bi, c+di) --> a + bi + cj + dk
vm.quat(a+bi+cj+dk) --> a + bi + cj + dk
vm.quat(vm.vec3(b, c, d), angle) --> cos(angle/2) + sin(angle/2)*(bi + cj + dk) 
vm.quat(a+bi, vm.vec3(c, d, e)) --> a + b * (ci + dj + ek)
vm.quat(vm.vec3(...), vm.vec3(...))

Higher dimensional complex numbers, of the form a + bi + cj + dk. Fields a, b, c, and d access the various components. Somehow, many things that work with complex numbers also work with quaternions! (I know, I was surprised too) However, quaternion multiplication is non-commutative: if x and y are quaternions, then x * y and y * x usually give different results.

The two vector constructor produces the shortest rotation that takes the first vector to the second.

The axis-angle, complex-axis, and two-vector constructors all expect (but neither enforce nor convert to) a unit vector; you might get unexpected results if you pass something else.

`boolean`

vm.boolean() --> false
vm.boolean(x) --> x

This is Lua's built-in boolean type. Not much to say about it either!

`vec`tors

vm.vec2() --> <0, 0>
vm.vec3(a) --> <a, a, a>
vm.cvec4(vm.vec2(a,b), vm.cvec3(c,d,e)) --> <complex(a), complex(b), c, d>
vm.bvec2() --> <false, false>
vm.vec4({a,b,c,d}) --> <a, b, c, d>

Vectors. There are actually 9 vector types: vec2, vec3, and vec4 are 2-, 3-, and 4-dimensional vectors with numbers as components; cvec2, cvec3, and cvec4 use complex numbers, and bvec2, bvec3, and bvec4 use booleans.

Vectors are indexed numerically, starting at 1.

The general constructor for a vector can take any number of scalar, vector, or matrix arguments for which the numeric type is convertible to the vector's type and which together provide enough components to completely fill the vector so long as the last component of the vector lands in the last argument.

Swizzling

In addition to numeric indices, vectors can be indexed via swizzles, strings of letters that describe a list of indices.

There are three alphabets for swizzling: xyzw (best for position), rgba (best for color), and stpq (best for parametric coordinates). They cannot be mixed.

Swizzles can be used for both reading and writing.

local v = vm.vec3(1,2,3)
v.x --> 1
v.bg --> <3,2>
v.sp = vm.vec2(4,5) --> v = <4,2,5>

This functionality can also be accessed as a function, which allows outvars. For this, the swizzle string is included as part of the name of the function.

These functions always use the xyzw alphabet.

local out = vm.vec2()
swizzleReadx(v) --> 1
out = swizzleReadyx(v, out) --> out = <2,1>
swizzleWritezy(v, vm.vec2(6,7)) --> v = <4,7,6>

`mat`rices

vm.cmat2() --> [[1+0i,0+0i], [0+0i,1+0i]]
vm.mat3(a) --> [[a,0,0], [0,a,0], [0,0,a]]
vm.mat2x3(a,b,c,d,e,f) --> [[a,b,c], [d,e,f]]
vm.mat3(vm.mat2x3(a,b,c,d,e,f)) --> [[a,b,c], [d,e,f], [0,0,1]]
vm.mat3(vm.quat(...)) --> rotation matrix
vm.mat4(vm.quat(...)) --> rotation matrix
vm.mat3x2({a,b,c,d,e,f}) --> [[a,b], [c,d], [e,f]]

Matrices. There's 18 of these! They can use numbers or complexes, can be 2 to 4 columns, and can be 2 to 4 rows. Like vectors, a letter before mat describes the type of number it stores (nothing for numbers, c for complex), and the number(s) after it describe its size: columns first, then x, then rows. mat2x4 is a matrix with two columns and four rows, filled with numbers; cmat3x2 is a matrix with three columns and two rows, filled with complex numbers. Square matrices, with the same number of rows as columns, have shorter aliases: mat4 is equivalent to mat4x4, cmat3 is equivalent to cmat3x3. When used in function signatures, always use the longer name, not the alias.

Matrices are indexed numerically by column, starting at 1; each column is a vector in its own right.

The matrix constructor will fill any blank spaces in the result with 0 except for entries on the diagonal which will receive 1.

The general constructor can take any number of scalar or vector (not matrix!) arguments which together provide enough components to completely fill the matrix so long as the last component of the matrix lands in the last argument.

The quaternion constructors produce a 3d rotation matrix; the mat4 version simply augments it with the identity so it works with the larger matrix.

Functions

Operators

The various operators can be accessed through their function names, and have their signatures included to skip dispatch, or can be used directly as operators.

`add` (`a + b`)

a + b --> a + b
vm.add(a, b[, c]) --> c = a + b

Domain: number, number => number, complex, complex => complex, quat, quat => quat

Componentwise: scalar, scalar, scalar, vector, vector, scalar, vector, vector, scalar, matrix, matrix, scalar, matrix, matrix

Addition! If applied to a vector and a scalar, or a matrix and a scalar, or two vectors of the same size, or two matrices of the same size, it operates componentwise: 3 + vec3(5, 6, 7) => vec3(8, 9, 10), for instance.

`sub` (`a - b`)

a - b --> a - b
vm.sub(a, b[, c]) --> c = a - b

Domain: number, number => number, complex, complex => complex, quat, quat => quat

Componentwise: scalar, scalar, scalar, vector, vector, scalar, vector, vector, scalar, matrix, matrix, scalar, matrix, matrix

Subtraction! Just like addition, but using the negation of the second argument.

`unm` (`-a`)

-a --> -a
vm.unm(a[, b]) --> b = -a

Domain: number => number, complex => complex, quat => quat

Componentwise: scalar, vector, matrix

Unary negation! Works on all numeric types.

`mul` (`a * b`)

a * b --> a * b
vm.mul(a, b[, c]) --> c = a * b

Domain: number, number => number, complex, complex => complex, quat, quat => quat

Componentwise: scalar, scalar, scalar, vector, vector, scalar, vector, vector, scalar, matrix, matrix, scalar

Special: vector, matrix => vector, matrix, vector => vector, matrix, matrix => matrix, quat, vec3 => vec3

Multiplication! If applied to a vector and a scalar, or a matrix and a scalar, or two vectors of the same size, it operates componentwise, just like addition.

If applied to a matrix and a vector or two matrices, it performs linear algebraic multiplication: each entry of the result takes the matching row of the left operand and the matching column of the right operand, multiplies them together component wise, and takes the sum. In order for this to work, the column count of the left operand and row count of the right operand must be the same: for matrices this means that they must follow the pattern matαxβ * matγxα = matγxβ, where the greek letters are replaced by numbers. Using a vector as the left operand acts like a row vector matαx1, and as the right operand acts like a column vector mat1xα. If you need componentwise matrix multiplication, see matrixCompMult. If you need algebraic multiplication of two vectors, see dot to get a scalar or outerProduct to get a matrix.

Multiplying a quat by a vec3 results in the vector rotated by the quat.

`div` (`a / b`)

a / b --> a / b
vm.div(a, b[, c]) --> c = a / b

Domain: number, number => number, complex, complex => complex, quat, quat => quat

Componentwise: scalar, scalar, scalar, vector, vector, scalar, vector, vector, scalar, matrix, matrix, scalar, matrix, matrix

Division! Uses the same rules as addition. For quaternions, non-commutative multiplication technically means there are two different forms of division: Vornmath uses p * (1/q), sometimes called right division.

`mod` (`a % b`)

a % b --> a % b
vm.div(a, b[, c]) --> c = a % b

Domain: number, number => number

Componentwise: scalar, scalar, scalar, vector, vector, scalar, vector, vector, scalar, matrix, matrix, scalar, matrix, matrix

Modulus! Gives the remainder of division, p/q - floor(p/q).

`pow` (`a ^ b`)

a ^ b --> a ^ b
vm.pow(a, b[, c]) --> c = a ^ b

Domain: number, number => number, complex, complex => complex, quat, quat => quat

Componentwise: scalar, scalar, scalar, vector, vector, scalar, vector, vector, scalar, matrix, matrix, scalar, matrix, matrix

Exponentiation! Some things that are illegal in real numbers will work when done in complex numbers: -1 ^ 0.5 is undefined in real numbers but complex(-1) ^ 0.5 works and gives i. pow does not work on matrices at all.

`eq` (`a == b` and `a ~= b`)

a == b --> a == b
vm.eq(a, b) --> a == b

Domain: boolean, boolean => boolean number, number => boolean, complex, complex => boolean, quat, quat => boolean, vector, vector => boolean, matrix, matrix => boolean

Equality! Works on anything; will return true if all elements are equal. For differing number types, will implicitly convert to the necessary type, so vm.eq(5, complex(5,0)) is true. If you want componentwise comparison of vectors, see equal.

WARNING: using the symbolic equals == on number and a type other than number doesn't work correctly and will always return false, due to limitations in Lua's metatable system. Instead, use eq if you really need to do that.

`tostring`

vm.tostring(a) --> a string representation of a

Domain: anything => string

Technically this isn't an operator, but it is a thing that gets a metamethod. Turns a thing into a string! The representations provided by this are not valid Lua code: they're designed to be reasonable to look at.

Trigonometric functions

All trigonometric functions act componentwise on vectors. Angles are always assumed to be in radians unless otherwise specified.

`rad`

vm.rad(angle_in_degrees[, x]) --> x = angle in radians

Domain: number => number, complex => complex, quat => quat

Componentwise: scalar, vector

Converts angle values from degrees to radians.

`deg`

vm.deg(angle_in_radians[, x]) --> x = angle in degrees

Domain: number => number, complex => complex, quat => quat

Componentwise: scalar, vector

Converts angle values from radians to degrees.

`sin`

vm.sin(phi[, x]) --> x = sin(phi)

Domain: number => number, complex => complex, quat => quat

Componentwise: scalar, vector

Computes the sine of the given angle.

`cos`

vm.cos(phi[, x]) --> x = cos(phi)

Domain: number => number, complex => complex, quat => quat

Componentwise: scalar, vector

Computes the cosine of the given angle.

`cis`

vm.cis(phi[, z]) --> z = cos(phi) + i * sin(phi)

Domain: number => complex

Componentwise: scalar, vector

Computes the cis function, $\text{cis} \theta = \cos \theta + i \sin \theta = e^{i\theta}$ ; if $z = \text{cis} \theta$ , then $|z| = 1$ and $\arg z = \theta$ .

`tan`

vm.tan(phi[, x]) --> x = tan(phi)

Domain: number => number, complex => complex, quat => quat

Componentwise: scalar, vector

Computes the tangent of the given angle.

`asin`

vm.asin(phi[, x]) --> x = asin(phi)

Domain: number => number, complex => complex, quat => quat

Componentwise: scalar, vector

Computes the inverse sine or arcsine of the given value. For real inputs, will return an angle between 0 and π.

`acos`

vm.acos(phi[, x]) --> x = acos(phi)

Domain: number => number, complex => complex, quat => quat

Componentwise: scalar, vector

Computes the inverse cosine or arccosine of the given angle. For real inputs, will return an angle between -π/2 and π/2.

`atan`

vm.atan(y[, nil, phi]) --> phi = angle
vm.atan(y, x[, phi]) --> phi = angle

Domain: number, nil => number, complex, nil => complex, quat, nil => quat, number, number => number, complex, complex => complex, quat, quat => quat

Componentwise: scalar, nil, vector, nil, scalar, scalar, vector, vector

Computes the inverse tangent or arctangent of the given value. For numbers, optionally accepts two parameters such that vm.atan(y, x) will give the correct angle across the whole circle, equivalent to atan2. the out variable is the third parameter for this function because of this. For real inputs, will return an angle between -π/2 and π/2 for the single-input version, or an angle between -π and π for the two-input version.

`sinh`

vm.sinh(x[, y]) --> y = sinh(x)

Domain: number => number, complex => complex, quat => quat

Componentwise: scalar, vector

Computes the hyperbolic sine of the given value.

`cosh`

vm.cosh(x[, y]) --> y = cosh(x)

Domain: number => number, complex => complex, quat => quat

Componentwise: scalar, vector

Computes the hyperbolic cosine of the given value.

`tanh`

vm.tanh(x[, y]) --> y = tanh(x)

Domain: number => number, complex => complex, quat => quat

Componentwise: scalar, vector

Computes the hyperbolic tangent of the given value.

`asinh`

vm.asinh(x[, y]) --> y = asinh(x)

Domain: number => number, complex => complex, quat => quat

Componentwise: scalar, vector

Computes the inverse hyperbolic sine of the given value.

`acosh`

vm.acosh(x[, y]) --> y = acosh(x)

Domain: number => number, complex => complex, quat => quat

Componentwise: scalar, vector

Computes the inverse hyperbolic cosine of the given value.

`atanh`

vm.atanh(x[, y]) --> y = atanh(x)

Domain: number => number, complex => complex, quat => quat

Componentwise: scalar, vector

Computes the inverse hyperbolic tangent of the given value.

`polarComplex`

vm.polarComplex(r, theta[, z]) --> z = r cis(theta)

Domain: number, number => complex

Componentwise: scalar, vector

Produces a complex number with a given absolute value $r$ and argument $\theta$ : $\text {polarComplex}(r, \theta) = r \text {cis}\theta = re^{i\theta}$

`polarVec2`

vm.polarVec2(r, theta[, v]) --> v = r * <sin(theta), cos(theta)>

Domain: number, number => vec2

Produces a vec2 with the given magnitude and direction.

`cylindricalVec3`

vm.cylindricalVec3(r, theta, z[, v]) --> v = <r * sin(theta), r * cos(theta), z>

Domain: number, number, number => vec3

Produces a cartesian vec3 from cylindrical coordinates.

`sphericalVec3`

vm.sphericalVec3(r, theta, phi[, v])
--> v = <r * sin(theta) * cos(phi), r * cos(theta) * cos(phi), z * sin(phi)>

Produces a cartesian vec3 from spherical coordinates.

Exponential functions

All these functions act componentwise on vectors.

`exp`

vm.exp(x[, y]) --> y = e^x

Domain: number => number, complex => complex, quat => quat

Componentwise: scalar, scalar, vector, vector

Computes the exponential function e^z.

`exp2`

vm.exp2(x[, y]) --> y = 2^x

Domain: number => number, complex => complex, quat => quat

Componentwise: scalar, vector

Computes the base-2 exponential function 2^z.

`log`

vm.log(x[, nil, y]) --> y = ln x
vm.log(x, b[, y]) --> y = log_b x

Domain: number, nil => number, complex, nil => complex, quat, nil => quat, number, number => number, complex, complex => complex, quat, quat => quat

Componentwise: scalar, nil, vector, nil, scalar, scalar, vector, vector

Computes the logarithm. For single-argument calls, this is the natural log. The second argument changes the base: vm.log(8,2) = 3 because 2^3 = 8.

`log2`

vm.log2(x[, y]) --> y = log_2 x

Domain: number => number, complex => complex, quat => quat

Componentwise: scalar, vector

Computes the base-2 logarithm.

`log10`

vm.log10(x[, y]) --> y = log_10 x

Domain: number => number, complex => complex, quat => quat

Componentwise: scalar, vector

Computes the base-10 logarithm.

`sqrt`

vm.sqrt(x[, y]) --> y = sqrt(x)

Domain: number => number, complex => complex, quat => quat

Componentwise: scalar, vector

Computes the square root. Fails if given a negative number; given a negative real complex or quat it will produce some positive multiple of $i$ . All numbers (other than zero) have two distinct candidates for their square root; this function produces the one with a positive real part.

`inversesqrt`

vm.inversesqrt(x[, y]) --> y = 1 / sqrt(x)

Domain: number => number, complex => complex, quat => quat

Componentwise: scalar, vector

Computes the inverse square root, the reciprocal of the square root.

`hypot`

vm.hypot(x, y[, z]) --> z = sqrt(|x^2| + |y^2|)

Domain: number, number => number, complex, complex => number, quat, quat => number

Componentwise: scalar, scalar, vector, vector

Gives the length of the hypotenuse of a right triangle with legs length x and y. Uses the absolute value to prevent silly results in complexes and quaternions.

Complex and Quaternion functions

All these act componentwise on vectors.

`arg`

vm.arg(a+bi[, x]) --> x = atan(b, a)

Domain: number => number, complex => number, quat => number

Componentwise: scalar, vector

Computes the argument or phase of a complex number, the angle the complex number makes with the positive real line. Also works on regular numbers and quaternions.

`conj`

vm.arg(a+bi[, z]) --> z = a-bi
vm.arg(a+bi+cj+dk[, z]) --> z = a-bi-cj-dk

Domain: number => number, complex => complex, quat => quat

Componentwise: scalar, vector

Computes the conjugate of a complex number or quaternion, which is the same number except with all the signs on the complex parts switched.

This works on matrices as well as vectors.

`axisDecompose`

vm.axisDecompose(a+bi+cj+dk[, cpx, axis]) --> ...
-- local l = sqrt(b^2 + c^2 + d^2)
-- cpx = a + li
-- axis = <b, c, d> / l

Domain: quat => complex, vec3

decomposes a quaternion into a complex number and a unit axis. These can in turn be fed back into vm.quat to reconstruct the original quaternion.

Common functions

All these act componentwise on vectors.

`abs`

vm.abs(x[, y]) --> y = |x|

Domain: number => number, complex => number, quat => number

Componentwise: scalar, vector

Returns the absolute value, the positive real number with the same magnitude as the number given.

`sqabs`

vm.sqabs(x[, y]) --> y = |x|^2

Domain: number => number, complex => number, quat => number

Componentwise: scalar, vector

Returns the square of the absolute value.

`copysign`

vm.copysign(sign, mag[, result]) --> |result| = |mag|, has same sign as sign

Domain: number, number => number

Componentwise: scalar, scalar, vector, vector

Copys the sign of sign onto mag.

`sign`

vm.sign(x, result) --> result = x/abs(x)

Domain: number => number, complex => complex, quat => quat

Componentwise: scalar, vector

Returns a value with magnitude 1 that has the same sign as x, unless x is 0, in which case returns 0. Also works on complexes and quaternions, giving values with the same argument and vector as x. Notably this means that all results of sign are unit except for when the input is 0.

`floor`

vm.floor(x[, y]) --> y <= x < y + 1; y is integer

Domain: number => number

Componentwise: scalar, vector

Computes the floor, the highest integer that is at most x.

`ceil`

vm.ceil(x[, y]) --> y - 1 < x <= y; y is integer

Domain: number => number

Componentwise: scalar, vector

Computes the ceiling, the lowest integer that is at least x.

`trunc`

vm.trunc(x[, y]) -- 0 <= y <= x < y + 1 or y - 1 < x <= y <= 0; y is integer

Domain: number => number

Componentwise: scalar, vector

Truncates a number, removing any fractional part; selects the nearest integer towards 0.

`round`

vm.round(x[, y]) -- |x - y| <= 0.5; y is integer

Domain: number => number

Componentwise: scalar, vector

Rounds a number to the nearest integer. If the fractional part of x is exactly 0.5, rounds up. This is somewhat faster than roundEven, but has a slight bias.

`roundEven`

vm.roundEven(x[, y]) -- |x - y| <= 0.5; y is integer

Domain: number => number

Componentwise: scalar, vector

Rounds a number to the nearest integer. If the fractional part of x is exactly 0.5, rounds to the nearest even number. This is somewhat slower than round, but is not biased.

`fract`

vm.fract(x[, y]) --> y = x - trunc(x)

Domain: number => number

Componentwise: scalar, vector

Gives the fractional part of x, with the same sign as x. Equivalent to the second return value of modf.

`modf`

vm.modf(x[, whole, fractional]) --> whole + fractional = x

Domain: number => number, number

Componentwise: scalar, vector

Separates a number into whole and fractional parts. Both parts have the same sign as the original number, so this works as truncating division instead of the usual flooring division.

`fmod`

vm.fmod(x, y[, remainder]) --> remainder of division

Domain: number, number => number

Componentwise: scalar, scalar, scalar, vector, vector, scalar, vector, vector

Gets the remainder of division such that the quotient takes the sign of the numerator; this is different from % where it takes the sign of the denominator.

`min`

vm.min(x, y[, result]) --> smaller of x and y

Domain: number, number => number

Componentwise: scalar, scalar, scalar, vector, vector, scalar, vector, vector

Finds the minimum of the two inputs. Unlike math.min, this only accepts two inputs!

`max`

vm.max(x, y[, result]) --> larger of x and y

Domain: number, number => number

Componentwise: scalar, scalar, scalar, vector, vector, scalar, vector, vector

Finds the maximum of the two inputs. Unlike math.max, this only accepts two inputs!

`clamp`

vm.clamp(x, lo, hi) --> min(max(x, lo), hi)

Domain: number, number, number => number

Componentwise: scalar, scalar, scalar, vector, scalar, scalar, vector, vector, vector

Finds the closest value to x that's also between lo and hi inclusive.

`mix`

vm.mix(a, b, t[, r]) --> r = (1-t)*a + t*b
vm.mix(a, b, flags[, r]) --> r[i] = b[i] if flags[i] is true, a[i] otherwise

Domain: number, number, number => number, complex, complex, complex => complex, quat, quat, quat => quat

Componentwise: scalar, scalar, scalar, vector, vector, scalar, vector, vector, vector

Linear or boolean interpolation: if t is a scalar or non-boolean vector, it will do $(1-t)a + tb$ componentwise. If instead it's a boolean vector, it will select between a and b based on truth value; this helps to avoid problems with NaNs and infinities messing with results in cases where that is possible. Also called "lerp".

`unmix`

vm.unmix(a, b, r[, t]) --> t = (r - a) / (b - a)

Domain: number, number, number => number, complex, complex, complex => complex, quat, quat, quat => quat

Componentwise: scalar, scalar, scalar, vector, vector, vector

The inverse of linear interpolation: $\text{mix}(a, b, \text{unmix}(a, b, r)) = r$ .
Also called "inverse lerp".

`geometricMix`

vm.geometricMix(a, b, t[, r]) --> r = a^(1-t) * b^t

Domain: number, number, number => number, complex, complex, complex => complex, quat, quat, quat => quat

Componentwise: scalar, scalar, scalar, vector, vector, scalar, vector, vector, vector

Geometric interpolation: $\text{geometricMix}(a,b,t) = a^{1-t}b^t$ .

For unit complexes and quaternions, this is often called "slerp". If you want to do spherical interpolation between individual vectors, use the function actually called slerp.

`geometricUnmix`

vm.geometricUnmix(a, b, x[, r]) --> r = (log(x) - log(a)) / (log(b) - log(a))

The inverse of geometric interplation: $\text{geometrixMix}(a, b, \text{geometricUnmix}(a, b, r)) = r$ .

`decay`

vm.decay(a, b, t[, r]) --> r = mix(b, a, 2^-t)

Domain: number, number, number => number, complex, complex, complex => complex, quat, quat, quat => quat

Componentwise: scalar, scalar, scalar, vector, vector, scalar, vector, vector, vector

Exponential decay: move from a toward b, slowing down exponentially; t is the number of half-lives moved.

`step`

vm.step(edge, x[, r]) --> r = 0 if x < edge, 1 otherwise

Domain: number, number => number

Componentwise: scalar, scalar, scalar, vector, vector, scalar, vector, vector

Gives 0 for x values smaller than edge and 1 for equal or larger values.

`smoothStep`

vm.smoothStep(lo, hi, x[, r]) --> cubic easing from 0 to 1 as x goes from lo to hi

Domain: number, number, number => number

Componentwise: scalar, scalar, scalar, vector, vector, scalar, vector, vector, vector

Cubic easing from lo to hi: