"index" | @equinor/videx-linear-algebra

Index

Interfaces

VectorLike

Functions

add

add<T>(a: T, b: VectorLike, target?: T): T

- Defined in index.ts:49
a + b

Component-wise addition of two n-dimensional vectors. Target is used to store the results.

example

add([1, 2], [3, 4], new Array(2)); // Returns: [4, 6]

Type parameters
- T: VectorLike
Parameters
- a: T
  
  Left operand
- b: VectorLike
  
  Right operand
- Default value target: T = a
  
  Target for storing the results (Default: a)
Returns T

Resulting vector

addAll

addAll<T>(vectors: T[], target?: T): T

- Defined in index.ts:68
v1 + ... + vM

Component-wise addition of M n-dimensional vectors. Target is used to store the results.

example

addAll([ [1, 2], [3, 4], [5, 6] ], new Array(2)); // Returns: [9, 12]

Type parameters
- T: VectorLike
Parameters
- vectors: T[]
  
  Array of vectors with length n.
- Default value target: T = vectors[0]
  
  Target for storing the results (Default: vectors[0])
Returns T

Resulting vector

clamp

clamp<T>(a: T, min?: number, max?: number, target?: T): T

- Defined in index.ts:297
Clamp all values of a vector

example

clamp([0, 1, 2, 3], 1, 2, new Array(4)); // Returns: [1, 1, 2, 2]

Type parameters
- T: VectorLike
Parameters
- a: T
  
  Values to clamp
- Default value min: number = 0
  
  Minimum value (Default: 0)
- Default value max: number = 1
  
  Maximum value (Default: 1)
- Default value target: T = a
  
  Target for storing the results (Default: a)
Returns T

Vector with clamped values

copy

copy<T>(source: VectorLike, target: T): T

- Defined in index.ts:29
Copy the values of one vector to another without creating a new object.

example

copy([3, 4], [2, 2]); // Returns: [3, 4]

Type parameters
- T: VectorLike
Parameters
- source: VectorLike
  
  Source vector
- target: T
  
  Target vector
Returns T

Target vector as a copy of source

cross

cross<T>(a: T, b: VectorLike, target?: T): T

- Defined in index.ts:261
a × b

Find cross product of vectors. Only defined for 3d vectors.

example

cross([1, 0, 0], [0, 1, 0]); // Returns: [0, 0, 1]

Type parameters
- T: VectorLike
Parameters
- a: T
  
  Left operand (3d vector)
- b: VectorLike
  
  Right operand (3d vector)
- Default value target: T = a
  
  Target for storing the results (Default: a)
Returns T

Cross product of vectors

dir

dir<T>(a: T, b: VectorLike, target?: T): T

- Defined in index.ts:207
Get the vector going from b to a.

example

dir([2, 1], [3, 0], new Array(2)); // Returns: [1, -1]

Type parameters
- T: VectorLike
Parameters
- a: T
  
  Start coordinates
- b: VectorLike
  
  End coordinates
- Default value target: T = a
  
  Target for storing the results (Default: a)
Returns T

Vector going from a to b

dist

dist(a: VectorLike, b: VectorLike): number

- Defined in index.ts:223
Calculate the distance between two coordinates.

example

dist([1, 2], [4, 6]); // Returns: 5

Parameters
- a: VectorLike
  
  Start coordinates
- b: VectorLike
  
  End coordinates
Returns number

Distance between coordinates

dot

dot(a: VectorLike, b: VectorLike): number

- Defined in index.ts:241
Calculate the dot product between two vectors.

example

dist([1, 2], [3, 4]); // Returns: 11

Parameters
- a: VectorLike
  
  Left operand
- b: VectorLike
  
  Right operand
Returns number

Dot product

fill

fill<T>(value: number, target: T): T

- Defined in index.ts:192
Fill an array/vector with given value.

example

fill(1, new Array(3)); // Returns: [1, 1, 1]

Type parameters
- T: VectorLike
Parameters
- value: number
  
  Value to fill
- target: T
  
  Target for storing the results
Returns T

Filled vector

flatten

flatten(vectors: VectorLike[]): number[]

- Defined in index.ts:405
Flatten a collection of vectors to a single array.

example

flatten([ [1, 2], [3, 4], [5, 6] ]); // Returns [1, 2, 3, 4, 5, 6]

Parameters
- vectors: VectorLike[]
  
  Array of vectors
Returns number[]

Single array with all values

isZeroVector

isZeroVector(a: VectorLike, epsilon?: number): boolean

- Defined in index.ts:368
Returns true if all elements of a vector is zero, otherwise returns false.

example

isZeroVector([0, 0.000023, 0], 0.001); // Returns: true

Parameters
- a: VectorLike
  
  Target vector
- Default value epsilon: number = 0
  
  Accepted deviation from 0.00 (Default: 0)
Returns boolean

Is target zero vector?

magnitude

magnitude(a: VectorLike): number

- Defined in index.ts:162
Computes the magnitude of a vector.

example

magnitude([3, 4]); // Returns: 5

Parameters
- a: VectorLike
  
  Target vector
Returns number

Magnitude of vector

mix

mix<T>(a: T, b: VectorLike, t: number, target?: T): T

- Defined in index.ts:333
Mix (interpolate) vectors (similar to glsl implementation).

example

mix([1, 3], [3, 5], 0.5, new Array(2)); // Returns: [2, 4]

Type parameters
- T: VectorLike
Parameters
- a: T
  
  Vector to interpolate from
- b: VectorLike
  
  Vector to interpolate to
- t: number
  
  Interpolation parameter, 0 = a and 1 = b
- Default value target: T = a
  
  Target for storing the results (Default: a)
Returns T

The interpolated vector

modify

modify<T>(a: T, modifier: function, target?: T): T

- Defined in index.ts:352
Modify each component of a vector with given function.

example

modify([1.12, 1.55], Math.round, new Array(2)); // Returns: [1, 2]

Type parameters
- T: VectorLike
Parameters
- a: T
  
  Vector to modify
- modifier: function
  
  Function used to modify component
  - - (val: number, index: number): number
    - Parameters
      - val: number
      - index: number
      Returns number
- Default value target: T = a
  
  Target for storing the results (Default: a)
Returns T

Vector with modified values

normalize

normalize<T>(a: T, target?: T): T

- Defined in index.ts:177
Normalizes a vector

example

magnitude([0, 10, 0], new Array(3)); // Returns: [0, 1, 0]

Type parameters
- T: VectorLike
Parameters
- a: T
  
  Vector to normalize
- Default value target: T = a
  
  Target for storing the results (Default: a)
Returns T

Normalized vector

reshape

reshape(array: number[], dimensions: number): number[][]

- Defined in index.ts:424
Reshapes an array of values to a collection of vectors with given dimensions.

example

reshape([1, 2, 3, 4, 5, 6], 3); // Returns [ [1, 2, 3], [4, 5, 6] ]

Parameters
- array: number[]
  
  Single array with all values
- dimensions: number
  
  Dimensions per vector
Returns number[][]

Array of vectors with given dimensions

reverse

reverse<T>(vector: T): T

- Defined in index.ts:384
Reverses the components of a vector with an performance of O(n/2).

example

reverse([1, 2, 3]); // Returns: [3, 2, 1]

Type parameters
- T: VectorLike
Parameters
- vector: T
  
  The vector to reverse
Returns T

Reversed vector

scale

scale<T>(a: T, factor: number, target?: T): T

- Defined in index.ts:131
Component-wise scaling of vector.

example

scale([1, 2, 3], 2, new Array(3)); // Returns: [2, 4, 6]

Type parameters
- T: VectorLike
Parameters
- a: T
  
  Vector to scale
- factor: number
  
  Scaling factor
- Default value target: T = a
  
  Target for storing the results (Default: a)
Returns T

Resulting vector

step

step<T>(edges: T, x: number, target?: T): T

- Defined in index.ts:315
GLSL step for all values of a vector

example

step([0, 1, 2, 3], 1.5, new Array(4)); // Returns: [1, 1, 0, 0]

Type parameters
- T: VectorLike
Parameters
- edges: T
  
  Edges of the step function
- x: number
  
  Value used to generate the step function
- Default value target: T = edges
  
  Target for storing the results (Default: edges)
Returns T

results for each value in edges

sub

sub<T>(a: T, b: VectorLike, target?: T): T

- Defined in index.ts:91
a - b

Component-wise subtraction of two n-dimensional vectors. Target is used to store the results.

example

sub([4, 3], [2, 1], new Array(2)); // Returns: [2, 2]

Type parameters
- T: VectorLike
Parameters
- a: T
  
  Left operand
- b: VectorLike
  
  Right operand
- Default value target: T = a
  
  Target for storing the results (Default: a)
Returns T

Resulting vector

subAll

subAll<T>(a: T, vectors: VectorLike[], target?: T): T

- Defined in index.ts:111
v1 - ... - vM

Component-wise subtraction of M n-dimensional vectors from a. Target is used to store the results.

example

subAll([9, 9], [ [2, 3], [0, 2] ], new Array(2)); // Returns: [7, 4]

Type parameters
- T: VectorLike
Parameters
- a: T
  
  Vector with length n.
- vectors: VectorLike[]
  
  Array of vectors with length n.
- Default value target: T = a
  
  Target for storing the results (Default: a)
Returns T

Resulting vector

sumsqr

sumsqr(a: VectorLike): number

- Defined in index.ts:146
Computes the sum of squares

example

sumsqr([1, 2, 3]); // Returns: 14

Parameters
- a: VectorLike
  
  Target vector
Returns number

Sum of squares

triple

triple(a: VectorLike, b: VectorLike, c: VectorLike): number

- Defined in index.ts:282
a ∙ b × c

Find triple product between three vectors. Only defined for 3d vectors.

example

triple([1, 0, 0], [0, 1, 0], [0, 0, 1]); // Returns: 1

Parameters
- a: VectorLike
  
  Left operand for dot product (3d vector)
- b: VectorLike
  
  Left operand for cross product (3d vector)
- c: VectorLike
  
  Right operand for cross product (3d vector)
Returns number

Triple product of vectors

Index

Interfaces

Functions

Functions

add

Type parameters

T: VectorLike

Parameters

a: T

b: VectorLike

Default value target: T = a

Returns T

addAll

Type parameters

T: VectorLike

Parameters

vectors: T[]

Default value target: T = vectors[0]

Returns T

clamp

Type parameters

T: VectorLike

Parameters

a: T

Default value min: number = 0

Default value max: number = 1

Default value target: T = a

Returns T

copy

Type parameters

T: VectorLike

Parameters

source: VectorLike

target: T

Returns T

cross

Type parameters

T: VectorLike

Parameters

a: T

b: VectorLike

Default value target: T = a

Returns T

dir

Type parameters

T: VectorLike

Parameters

a: T

b: VectorLike

Default value target: T = a

Returns T

dist

Parameters

a: VectorLike

b: VectorLike

Returns number

dot

Parameters

a: VectorLike

b: VectorLike

Returns number

fill

Type parameters

T: VectorLike

Parameters

value: number

target: T

Returns T

flatten

Parameters

vectors: VectorLike[]

Returns number[]

isZeroVector

Parameters

a: VectorLike

Default value epsilon: number = 0

Returns boolean

magnitude

Parameters

a: VectorLike