Function

array/vector

public addAll(vectors: number[][], target: number[]): number[] source

import {addAll} from '@kjerandp/linear-algebra/src/functions.js'

Component-wise addition of a set of arrays/vectors. If target is NOT specified, the first element in the set will be mutated. Target (if it has valid values) WILL be included in the sum.

Params:

Name	Type	Attribute	Description
vectors	number[][]		Array of equally length arrays/vectors (to be added)
target	number[]		optional array/vector to add into

Return:

array/vector

public addScaled(to: number[], from: number[], factor: number, target: number[]): number[] source

import {addScaled} from '@kjerandp/linear-algebra/src/functions.js'

Component-wise addition of one vector with a scaled version of another vector. If target is NOT specified, the first argument will be mutated. Target will be overwritten and NOT included in the sum.

Params:

Name	Type	Attribute	Description
to	number[]		left operand
from	number[]		right operand
factor	number		scaling factor to apply to from-vector
target	number[]		optional array/vector to store the result

Return:

array/vector

public angle(vector: number[], axis: number): number source

import {angle} from '@kjerandp/linear-algebra/src/functions.js'

Find the axis aligned angle of a 3d vector

Params:

Name	Type	Attribute	Description
vector	number[]
axis	number		which axis to measure from X=0, Y=1, Z=2 (defaults to 0)

Return:

angle in radians

public angle2(vector: number[]): number source

import {angle2} from '@kjerandp/linear-algebra/src/functions.js'

Find the axis aligned angle of a 2d vector

Params:

Name	Type	Attribute	Description
vector	number[]

Return:

angle in radians

public clamp(arg: number | number[], min: number, max: number, target: number[]): number | number[] source

import {clamp} from '@kjerandp/linear-algebra/src/functions.js'

Clamps the argument according to min and max. Arg can be either a numeric value or an array of numeric values.

Params:

Name	Type	Attribute	Description
arg	number \| number[]		value or array of values to clamp
min	number		minimum value
max	number		maximum value
target	number[]		optional array/vector to store the result

Return:

number | number[]

clamped version of arg

public clampArray(arr: number[], min: number, max: number, target: number[]): number[] source

import {clampArray} from '@kjerandp/linear-algebra/src/functions.js'

Clamps each value in array according to min and max.

Params:

Name	Type	Attribute	Description
arr	number[]		values to clamp
min	number		minimum value
max	number		maximum value
target	number[]		optional array/vector to store the result

Return:

array of clamped values

public clampValue(value: number, min: number, max: number): number source

import {clampValue} from '@kjerandp/linear-algebra/src/functions.js'

Clamps the value to min or max if value is less than min or greater than max

Params:

Name	Type	Attribute	Description
value	number		value to clamp
min	number		minimum value
max	number		maximum value

Return:

clamped value

public cross(v1: number[], v2: number[], target: number[]): number[] source

import {cross} from '@kjerandp/linear-algebra/src/functions.js'

Find the cross product between two 3d vectors

Params:

Name	Type	Attribute	Description
v1	number[]		left hand operand (3d vector)
v2	number[]		right hand operand (3d vector)
target	number[]		optional array/vector to store the resulting vector

Return:

the cross product vector (normal)

public cross2(v1: number[], v2: number[]): number source

import {cross2} from '@kjerandp/linear-algebra/src/functions.js'

Find the psudo cross product between two 2d vectors

Params:

Name	Type	Attribute	Description
v1	number[]		left hand operand (2d vector)
v2	number[]		right hand operand (2d vector)

Return:

signed area of the parallellogram defined by v1 and v2

public deg(r: number): number source

import {deg} from '@kjerandp/linear-algebra/src/functions.js'

Convert radians to degrees

Params:

Name	Type	Attribute	Description
r	number		radians

Return:

degrees

public descr(from: number[], to: number[], target: number[]): {vector: number[], sqr: number, distance: number, unit: number[]} source

import {descr} from '@kjerandp/linear-algebra/src/functions.js'

Describes relationships between two points.

Params:

Name	Type	Attribute	Description
from	number[]		start coordinates
to	number[]		end coordinates
target	number[]		optional array/vector to store the result

Return:

{vector: number[], sqr: number, distance: number, unit: number[]}

public dir(from: number[], to: number[], target: number[]): number[] source

import {dir} from '@kjerandp/linear-algebra/src/functions.js'

Get a unit vector between two points/coordinates. This function does not mutate any arguments, but a target may still be used to control the return type or to avoid creating additional arrays.

Params:

Name	Type	Attribute	Description
from	number[]		start coordinates
to	number[]		end coordinates
target	number[]		optional array/vector to store the resulting vector

Return:

unit vector between from and to

public dist(p1: number[], p2: number[]): number source

import {dist} from '@kjerandp/linear-algebra/src/functions.js'

Calculate the distance between two points/coordinates.

Params:

Name	Type	Attribute	Description
p1	number[]		point/coordinates
p2	number[]		point/coordinates

Return:

distance

public dot(v1: number[], v2: number[]): number source

import {dot} from '@kjerandp/linear-algebra/src/functions.js'

Calculate the dot product between two vectors

Params:

Name	Type	Attribute	Description
v1	number[]		left hand operand
v2	number[]		right hand operand

Return:

the dot product

public flattenList(arg: number[], flattend: number[], max: number): * source

import {flattenList} from '@kjerandp/linear-algebra/src/utils.js'

Recursivly flattens a list of arguments to a 1 dimensional array

Params:

Name	Type	Attribute	Description
arg	number[]		Arguments to be flattended
flattend	number[]		Resulting array of values
max	number		Max returned values (default is 0 for all)

Return:

public isNullVec(v: number[], epsilon: number): * source

import {isNullVec} from '@kjerandp/linear-algebra/src/functions.js'

Test if a vector is a null vector

Params:

Name	Type	Attribute	Description
v	number[]		vector to test
epsilon	number		optional epsilon value

Return:

public lerp(a: number, b: number, t: number): number source

import {lerp} from '@kjerandp/linear-algebra/src/functions.js'

Linear interpolation between two numbers

Params:

Name	Type	Attribute	Description
a	number		interpolate from
b	number		interpolate to
t	number		time 0 = a, 1 = b

Return:

the interpolated value

public mat(arr: ...number, cols: number, rowsFirst: boolean): Matrix source

import {mat} from '@kjerandp/linear-algebra/src/matrix.js'

Factory function for creating and assigning a matrix from an array. The array must be 1 dimensional, and will be split into rows and columns based on the specified cols parameter. If array length divided by cols doesn't add up to a whole number, then only floor(args.length / cols) values will be read from the input array.

Initial values are passed in row-first order by default, but can optionally be passed in columns-first by setting the rowFirst argument to false.

Params:

Name	Type	Attribute	Description
arr	...number		initial values
cols	number		number of columns to split the array into
rowsFirst	boolean		read arr in rows-first or column-first order

Return:

public mat2(args: ...number): Matrix source

import {mat2} from '@kjerandp/linear-algebra/src/matrix.js'

Factory function for creating and assigning a 2x2 matrix. Initial values are passed in row-first order.

Params:

Name	Type	Attribute	Description
args	...number		initial values

Return:

public mat3(args: ...number): Matrix source

import {mat3} from '@kjerandp/linear-algebra/src/matrix.js'

Factory function for creating and assigning a 3x3 matrix. Initial values are passed in row-first order.

Params:

Name	Type	Attribute	Description
args	...number		initial values

Return:

public mat4(args: ...number): Matrix source

import {mat4} from '@kjerandp/linear-algebra/src/matrix.js'

Factory function for creating and assigning a 4x4 matrix. Initial values are passed in row-first order.

Params:

Name	Type	Attribute	Description
args	...number		initial values

Return:

public mix(a: number[], b: number[], t: number | number[], target: number[]): number[] source

import {mix} from '@kjerandp/linear-algebra/src/functions.js'

Mix (interpolate) numbers or arrays (similar to glsl implementation). Works on both vectors and matrices, since they are both arrays.

Params:

Name	Type	Attribute	Description
a	number[]		interpolate from
b	number[]		interpolate to
t	number \| number[]		time 0 = a, 1 = b
target	number[]		optional array/vector to store the result

Return:

interpolated array/vector/matrix

public norm(vector: number[], target: number[]): number[] source

import {norm} from '@kjerandp/linear-algebra/src/functions.js'

Normalizes an array/vector

Params:

Name	Type	Attribute	Description
vector	number[]		array/vector to notmalize
target	number[]		optional array/vector to store the result

Return:

normalized array/vector

public nrad(r: number): number source

import {nrad} from '@kjerandp/linear-algebra/src/functions.js'

Normalise an angle to be between -PI to +PI

Params:

Name	Type	Attribute	Description
r	number		radians

Return:

normalised angle

public nvec(dim: number, values: Array<number>): Vector source

import {nvec} from '@kjerandp/linear-algebra/src/vector.js'

Create a vector of specific dimension and optionally set its values. If values contains only one element, the all components will be set to this value. Elements in values exceeding the specified dimension will be neglected.

Params:

Name	Type	Attribute	Description
dim	number		the number of components
values	Array<number>		optional initial values

Return:

public orth2(vector: number[], target: number[]): number[] source

import {orth2} from '@kjerandp/linear-algebra/src/functions.js'

Get a unit vector that is perpendicular to the input vector. Only for 2d vectors!

Params:

Name	Type	Attribute	Description
vector	number[]		2d vector
target	number[]		optional array/vector to store the resulting vector

Return:

normalized, perpendicular vector

public rad(d: number): number source

import {rad} from '@kjerandp/linear-algebra/src/functions.js'

Convert degrees to radians

Params:

Name	Type	Attribute	Description
d	number		degrees

Return:

radians

public round(v: number | number[], digits: number): number source

import {round} from '@kjerandp/linear-algebra/src/functions.js'

Rounds a number to the specific number of digits. Works with either a single number or an array of numbers, which means it can be used with vectors and matrices as well.

Params:

Name	Type	Attribute	Description
v	number \| number[]		value to round
digits	number		number of digits to round to

Return:

rounded value

public rowsToColumns(arr: number[], cols: number, target: number[]): * source

import {rowsToColumns} from '@kjerandp/linear-algebra/src/utils.js'

Transpose a single dimensional array, representing 2d data, from rows first to columns first.

Params:

Name	Type	Attribute	Description
arr	number[]		Array to transpose
cols	number		Number of columns in source array
target	number[]		If omitted, result will be returned as a new array

Return:

public scalar(vector: number[]): number source

import {scalar} from '@kjerandp/linear-algebra/src/functions.js'

Computes the scalar value (length) of a vector

Params:

Name	Type	Attribute	Description
vector	number[]		array/vector to compute

Return:

public scale(arr: number[], factor: number, target: number[]): number[] source

import {scale} from '@kjerandp/linear-algebra/src/functions.js'

Component-wise scaling of an array or vector

Params:

Name	Type	Attribute	Description
arr	number[]		array/vector to scale
factor	number		scaling factor
target	number[]		optional array/vector to store the result

Return:

scaled array/vector

public seq(from: number | number[], to: number | number[], steps: number, start: number, end: number): * source

import {seq} from '@kjerandp/linear-algebra/src/functions.js'

Generates a list of interpolated values between from and to, where the number of elements returned are controlled by the steps argument.

Params:

Name	Type	Attribute	Description
from	number \| number[]		value to interpolate from
to	number \| number[]		value to interpolate to
steps	number		interpolation steps
start	number		start time of interpolation [0-1]
end	number		end time of interpolation [0-1]

Return:

public seqI(steps: number): * source

import {seqI} from '@kjerandp/linear-algebra/src/functions.js'

Generates a list of interpolated values between 0 and 1, where the number of elements returned are controlled by the steps argument.

Params:

Name	Type	Attribute	Description
steps	number		interpolation steps

Return:

public smoothstep(edge0: number, edge1: number, x: number): * source

import {smoothstep} from '@kjerandp/linear-algebra/src/functions.js'

Implementation of glsl smoothstep function

Params:

Name	Type	Attribute	Description
edge0	number
edge1	number
x	number		threshold

Return:

public step(edge: number | number[], x: number | number[], target: number[]): number | number[] source

import {step} from '@kjerandp/linear-algebra/src/functions.js'

Implementation of glsl step function. Returns 0 if an edge is less than the threshold x, otherwise 1

Params:

Name	Type	Attribute	Description
edge	number \| number[]		number/array to test
x	number \| number[]		threshold(s)
target	number[]		optional array/vector to store the result (if edge is array)

Return:

number | number[]

public stepArray(edges: number[], x: number | number[], target: number[]): number[] source

import {stepArray} from '@kjerandp/linear-algebra/src/functions.js'

As glsl step function for multiple numeric values

Params:

Name	Type	Attribute	Description
edges	number[]		values to test
x	number \| number[]		threshold values
target	number[]		optional array/vector to store the result

Return:

results for each value in edges

public stepValue(edge: number, x: number): number source

import {stepValue} from '@kjerandp/linear-algebra/src/functions.js'

As glsl step function for single numeric values

Params:

Name	Type	Attribute	Description
edge	number		value to test
x	number		threshold value

Return:

returns 0 or 1

public sub(from: number[], vector: number[], target: number[]): number[] source

import {sub} from '@kjerandp/linear-algebra/src/functions.js'

Component-wise subtraction of two arrays/vectors. If target is NOT specified, the first argument will be mutated. Target will be overwritten and NOT included in the sum.

Params:

Name	Type	Attribute	Description
from	number[]		left operand
vector	number[]		right operand
target	number[]		optional array/vector to store the result

Return:

array/vector

public subAll(from: number[], vectors: number[][], target: number[]): number[] source

import {subAll} from '@kjerandp/linear-algebra/src/functions.js'

Component-wise subtraction of array/vector and all elements in vectors. If target is NOT specified, the first argument will be mutated. Target will be overwritten and NOT included in the sum.

Params:

Name	Type	Attribute	Description
from	number[]		left operand
vectors	number[][]		right operand
target	number[]		optional array/vector to store the result

Return:

array/vector

public subScaled(from: number[], vector: number[], factor: number, target: number[]): number[] source

import {subScaled} from '@kjerandp/linear-algebra/src/functions.js'

Component-wise addition of one vector with a scaled version of another vector. If target is NOT specified, the first argument will be mutated. Target will be overwritten and NOT included in the sum.

Params:

Name	Type	Attribute	Description
from	number[]		left operand
vector	number[]		right operand
factor	number		scaling factor to apply to vector that will be subtracted
target	number[]		optional array/vector to store the result

Return:

array/vector

public sumsqr(arr: number[]): number source

import {sumsqr} from '@kjerandp/linear-algebra/src/functions.js'

Computes the sum of squares

Params:

Name	Type	Attribute	Description
arr	number[]		array/vector to compute

Return:

public triple(v1: number[], v2: number[], v3: number[]): number source

import {triple} from '@kjerandp/linear-algebra/src/functions.js'

Get the triple product between three 3d vectors

Params:

Name	Type	Attribute	Description
v1	number[]		left hand operand for the dot product (3d vector)
v2	number[]		left hand operand for the cross product (3d vector)
v3	number[]		right hand operand for the cross product (3d vector)

Return:

triple product

public vec(from: number[], to: number[], target: number[]): number[] source

import {vec} from '@kjerandp/linear-algebra/src/functions.js'

Create a vector from two points. This function will NOT mutate any arguments unless 'target' is the same as 'from'.

Params:

Name	Type	Attribute	Description
from	number[]		start coordinates
to	number[]		end coordinates
target	number[]		optional array/vector to store the resulting vector

Return:

vector

public vec2(args: ...number): Vector source

import {vec2} from '@kjerandp/linear-algebra/src/vector.js'

Factory function for creating and assigning a 2d vector. If a single argument is passed, then all components will be assigned with its value. Missing initial values will be filled with zeros.

Params:

Name	Type	Attribute	Description
args	...number		initial values

Return:

public vec3(args: ...number): Vector source

import {vec3} from '@kjerandp/linear-algebra/src/vector.js'

Factory function for creating and assigning a 3d vector. If a single argument is passed, then all components will be assigned with its value. Missing initial values will be filled with zeros.

Params:

Name	Type	Attribute	Description
args	...number		initial values

Return:

public vec4(args: ...number): Vector source

import {vec4} from '@kjerandp/linear-algebra/src/vector.js'

Factory function for creating and assigning a 4d vector. If a single argument is passed, then all components will be assigned with its value. Missing initial values will be filled with zeros.

Params:

Name	Type	Attribute	Description
args	...number		initial values

Return: