Class Vector

Vector maths on plain number arrays. A vector is an array of numbers; in 3D it is [x, y, z] with Y pointing up, the same shape as a point, so the two can be passed to each other's methods. Every method returns a new array or a number and never changes its inputs. Angles are in degrees.

Index

Constructors

constructor

new Vector(math: MathBitByBit, geometryHelper: GeometryHelper): Bit.Vector
Parameters
- math: MathBitByBit
- geometryHelper: GeometryHelper
Returns Bit.Vector
- Defined in bitbybit-docs.d.ts:64915

angles

angleBetween

angleBetween(inputs: TwoVectorsDto): number
Measures the angle between two vectors in degrees, always between 0 and 180.

The direction of turning is not considered; use signedAngleBetween for that. Example: [1,0,0] and [0,1,0] -> 90
Parameters
- inputs: TwoVectorsDto
  The two vectors
Returns number
Angle in degrees
Example
```
const angle = bitbybit.vector.angleBetween({ first: [1, 0, 0], second: [0, 1, 0] });
```
- Defined in bitbybit-docs.d.ts:64988

angleBetweenNormalized2d

angleBetweenNormalized2d(inputs: TwoVectorsDto): number
Measures the signed angle from the first 2D vector to the second, in degrees from -180 to 180.

Only the first two entries of each vector are used; a positive angle turns counter-clockwise. Example: [1,0] to [0,1] -> 90, [0,1] to [1,0] -> -90
Parameters
- inputs: TwoVectorsDto
  The two 2D vectors
Returns number
Signed angle in degrees
Example
```
const angle = bitbybit.vector.angleBetweenNormalized2d({ first: [1, 0], second: [0, 1] });
```
- Defined in bitbybit-docs.d.ts:65005

positiveAngleBetween

positiveAngleBetween(inputs: TwoVectorsReferenceDto): number
Measures the angle from the first vector to the second, turning around a reference direction, in degrees from 0 to 360.

The turn is counter-clockwise when the reference vector points toward you. Example: [1,0,0] to [0,0,-1] around [0,1,0] -> 90
Parameters
- inputs: TwoVectorsReferenceDto
  The two vectors and the reference direction to turn around
Returns number
Angle in degrees from 0 to 360
Example
```
const angle = bitbybit.vector.positiveAngleBetween({ first: [1, 0, 0], second: [0, 0, -1], reference: [0, 1, 0] });
```
- Defined in bitbybit-docs.d.ts:65022

signedAngleBetween

signedAngleBetween(inputs: TwoVectorsReferenceDto): number
Measures the angle from the first vector to the second, turning around a reference direction, in degrees from 0 to 360.

The turn is counter-clockwise when the reference vector points toward you: a clockwise turn of 30 degrees reads as 330. Example: [1,0,0] to [0,0,-1] around [0,1,0] -> 90
Parameters
- inputs: TwoVectorsReferenceDto
  The two vectors and the reference direction to turn around
Returns number
Angle in degrees from 0 to 360
Example
```
const angle = bitbybit.vector.signedAngleBetween({ first: [1, 0, 0], second: [0, 0, -1], reference: [0, 1, 0] });
```
- Defined in bitbybit-docs.d.ts:65395

base

cross

cross(inputs: TwoVectorsDto): number[]
Computes the cross product of two 3D vectors: a vector at right angles to both.

Its direction follows the right-hand rule and its length is the area of the parallelogram the two vectors span. Example: [1,0,0] x [0,1,0] -> [0,0,1]
Parameters
- inputs: TwoVectorsDto
  The two 3D vectors
Returns number[]
The vector perpendicular to both
Example
```
const normal = bitbybit.vector.cross({ first: [1, 0, 0], second: [0, 1, 0] });
```
- Defined in bitbybit-docs.d.ts:65085

div

div(inputs: VectorScalarDto): number[]
Divides every entry of a vector by one number.

Example: [10,20,30] / 2 -> [5,10,15]
Parameters
- inputs: VectorScalarDto
  The vector and the number to divide by
Returns number[]
The divided vector
Example
```
const half = bitbybit.vector.div({ vector: [10, 20, 30], scalar: 2 });
```
- Defined in bitbybit-docs.d.ts:65131

domain

domain(inputs: VectorDto): number
Subtracts the first value of a vector from its last, which for a sorted list is its range.

Example: [1,3,5,9] -> 8
Parameters
- inputs: VectorDto
  The vector
Returns number
Last value minus first value
Example
```
const span = bitbybit.vector.domain({ vector: [1, 3, 5, 9] });
```
- Defined in bitbybit-docs.d.ts:65146

dot

dot(inputs: TwoVectorsDto): number
Computes the dot product of two vectors: the sum of the products of matching entries.

It is 0 for vectors at right angles and, for unit vectors, the cosine of the angle between them. Example: [1,2,3] and [4,5,6] -> 32
Parameters
- inputs: TwoVectorsDto
  The two vectors
Returns number
The dot product
Example
```
const projection = bitbybit.vector.dot({ first: [1, 2, 3], second: [4, 5, 6] });
```
- Defined in bitbybit-docs.d.ts:65163

mul

mul(inputs: VectorScalarDto): number[]
Multiplies every entry of a vector by one number.

Example: [2,3,4] x 5 -> [10,15,20]
Parameters
- inputs: VectorScalarDto
  The vector and the number to multiply by
Returns number[]
The scaled vector
Example
```
const scaled = bitbybit.vector.mul({ vector: [2, 3, 4], scalar: 5 });
```
- Defined in bitbybit-docs.d.ts:65254

neg

neg(inputs: VectorDto): number[]
Flips the sign of every entry, so the vector points the opposite way.

Example: [5,-3,2] -> [-5,3,-2]
Parameters
- inputs: VectorDto
  The vector to flip
Returns number[]
The negated vector
Example
```
const opposite = bitbybit.vector.neg({ vector: [5, -3, 2] });
```
- Defined in bitbybit-docs.d.ts:65269

normSquared

normSquared(inputs: VectorDto): number
Computes the squared length of a vector, which avoids the square root when only comparing lengths.

Example: [3,4,0] -> 25
Parameters
- inputs: VectorDto
  The vector
Returns number
The squared length
Example
```
const n2 = bitbybit.vector.normSquared({ vector: [3, 4, 0] });
```
- Defined in bitbybit-docs.d.ts:65285

norm

norm(inputs: VectorDto): number
Computes the length of a vector.

Example: [3,4,0] -> 5, [1,0,0] -> 1
Parameters
- inputs: VectorDto
  The vector
Returns number
The length in model units
Example
```
const len = bitbybit.vector.norm({ vector: [3, 4, 0] });
```
- Defined in bitbybit-docs.d.ts:65300

normalized

normalized(inputs: VectorDto): number[]
Scales a 3D vector to length 1 while keeping its direction.

A vector shorter than 1e-8 has no direction to keep, so the result is undefined. Example: [3,4,0] -> [0.6,0.8,0]
Parameters
- inputs: VectorDto
  The 3D vector to normalize
Returns number[]
The unit vector, or undefined for a zero-length input
Example
```
const direction = bitbybit.vector.normalized({ vector: [3, 4, 0] });
```
- Defined in bitbybit-docs.d.ts:65316

onRay

onRay(inputs: RayPointDto): number[]
Finds the point at a given distance from a start point along a direction.

The direction is used as given, so a direction of length 2 travels twice the distance. Example: start [0,0,0], direction [1,0,0], distance 5 -> [5,0,0]
Parameters
- inputs: RayPointDto
  The start point, the direction and the distance
Returns number[]
The point on the ray
Example
```
const ahead = bitbybit.vector.onRay({ point: [0, 0, 0], vector: [1, 0, 0], distance: 5 });
```
- Defined in bitbybit-docs.d.ts:65332

sub

sub(inputs: TwoVectorsDto): number[]
Subtracts the second vector from the first, entry by entry.

Example: [10,20,30] - [1,2,3] -> [9,18,27]
Parameters
- inputs: TwoVectorsDto
  The vector to subtract from and the vector to subtract
Returns number[]
The vector of differences
Example
```
const diff = bitbybit.vector.sub({ first: [10, 20, 30], second: [1, 2, 3] });
```
- Defined in bitbybit-docs.d.ts:65459

sum

sum(inputs: VectorDto): number
Adds up all values of a vector into one number.

Example: [1,2,3,4] -> 10
Parameters
- inputs: VectorDto
  The vector to add up
Returns number
The total
Example
```
const total = bitbybit.vector.sum({ vector: [1, 2, 3, 4] });
```
- Defined in bitbybit-docs.d.ts:65474

lengthSq

lengthSq(inputs: Vector3Dto): number
Computes the squared length of a 3D vector, which avoids the square root when only comparing lengths.

Example: [3,4,0] -> 25
Parameters
- inputs: Vector3Dto
  The 3D vector
Returns number
The squared length
Example
```
const l2 = bitbybit.vector.lengthSq({ vector: [3, 4, 0] });
```
- Defined in bitbybit-docs.d.ts:65490

length

length(inputs: Vector3Dto): number
Computes the length of a 3D vector.

Example: [3,4,0] -> 5
Parameters
- inputs: Vector3Dto
  The 3D vector
Returns number
The length in model units
Example
```
const len = bitbybit.vector.length({ vector: [3, 4, 0] });
```
- Defined in bitbybit-docs.d.ts:65505

create

vectorXYZ

vectorXYZ(inputs: VectorXYZDto): Vector3
Builds a 3D vector from its x, y and z values.

Example: x=1, y=2, z=3 -> [1,2,3]
Parameters
- inputs: VectorXYZDto
  The three values
Returns Vector3
The vector [x, y, z]
Example
```
const up = bitbybit.vector.vectorXYZ({ x: 0, y: 1, z: 0 });
```
- Defined in bitbybit-docs.d.ts:65347

vectorXY

vectorXY(inputs: VectorXYDto): Vector2
Builds a 2D vector from its x and y values.

Example: x=3, y=4 -> [3,4]
Parameters
- inputs: VectorXYDto
  The two values
Returns Vector2
The vector [x, y]
Example
```
const right = bitbybit.vector.vectorXY({ x: 1, y: 0 });
```
- Defined in bitbybit-docs.d.ts:65362

range

range(inputs: RangeMaxDto): number[]
Lists the whole numbers from 0 up to, but not including, max.

Example: max=5 -> [0,1,2,3,4]
Parameters
- inputs: RangeMaxDto
  The end of the range, which is left out
Returns number[]
The numbers from 0 to max - 1
Example
```
const indices = bitbybit.vector.range({ max: 5 });
```
- Defined in bitbybit-docs.d.ts:65377

span

span(inputs: SpanDto): number[]
Lists the numbers from min to max, stepping by step; max is included when a step lands on it.

Example: min=0, max=10, step=2 -> [0,2,4,6,8,10]
Parameters
- inputs: SpanDto
  The start, the end and the step
Returns number[]
The numbers in the span
Example
```
const values = bitbybit.vector.span({ min: 0, max: 10, step: 2.5 });
```
- Defined in bitbybit-docs.d.ts:65411

spanEaseItems

spanEaseItems(inputs: SpanEaseItemsDto): number[]
Lists nrItems numbers from min to max spaced by an easing curve, so they bunch up at one end or both.

With intervals on, the result holds the gaps between neighbors instead of the values themselves. Example: min=0, max=100, nrItems=5, ease='easeInQuad' -> [0, 6.25, 25, 56.25, 100]
Parameters
- inputs: SpanEaseItemsDto
  The start, the end, the number of items, the easing and whether to return the gaps
Returns number[]
The eased numbers, or the gaps between them
Example
```
const eased = bitbybit.vector.spanEaseItems({ min: 0, max: 100, nrItems: 5, ease: Bit.Inputs.Math.easeEnum.easeInQuad, intervals: false });
```
- Defined in bitbybit-docs.d.ts:65429

spanLinearItems

spanLinearItems(inputs: SpanLinearItemsDto): number[]
Lists nrItems evenly spaced numbers from min to max, both included.

Example: min=0, max=10, nrItems=5 -> [0, 2.5, 5, 7.5, 10]
Parameters
- inputs: SpanLinearItemsDto
  The start, the end and the number of items
Returns number[]
The evenly spaced numbers
Example
```
const values = bitbybit.vector.spanLinearItems({ min: 0, max: 10, nrItems: 5 });
```
- Defined in bitbybit-docs.d.ts:65444

parseNumbers

parseNumbers(inputs: VectorStringDto): number[]
Turns a list of number strings into numbers.

A string that is not a number becomes NaN. Example: ['1', '2.5', '3'] -> [1, 2.5, 3]
Parameters
- inputs: VectorStringDto
  The strings to parse
Returns number[]
The numbers
Example
```
const numbers = bitbybit.vector.parseNumbers({ vector: ["1", "2.5", "-3"] });
```
- Defined in bitbybit-docs.d.ts:65521

distance

distSquared

distSquared(inputs: TwoVectorsDto): number
Computes the squared distance between two vectors, which avoids the square root when only comparing distances.

Example: [0,0,0] to [3,4,0] -> 25
Parameters
- inputs: TwoVectorsDto
  The two vectors
Returns number
The squared distance
Example
```
const d2 = bitbybit.vector.distSquared({ first: [0, 0, 0], second: [3, 4, 0] });
```
- Defined in bitbybit-docs.d.ts:65101

dist

dist(inputs: TwoVectorsDto): number
Computes the straight-line distance between two vectors.

Example: [0,0,0] to [3,4,0] -> 5
Parameters
- inputs: TwoVectorsDto
  The two vectors
Returns number
The distance in model units
Example
```
const distance = bitbybit.vector.dist({ first: [0, 0, 0], second: [3, 4, 0] });
```
- Defined in bitbybit-docs.d.ts:65116

lerp

lerp(inputs: FractionTwoVectorsDto): number[]
Blends two vectors linearly by a fraction.

fraction is the share of first: 1 gives first, 0 gives second, 0.5 the midpoint. Example: [0,0,0] and [10,10,10] at 0.5 -> [5,5,5]
Parameters
- inputs: FractionTwoVectorsDto
  The two vectors and the fraction of the first
Returns number[]
The blended vector
Example
```
const mid = bitbybit.vector.lerp({ first: [0, 0, 0], second: [10, 10, 10], fraction: 0.5 });
```
- Defined in bitbybit-docs.d.ts:65209

extract

max

max(inputs: VectorDto): number
Finds the largest value in a vector.

Example: [3, 7, 2, 9, 1] -> 9
Parameters
- inputs: VectorDto
  The vector
Returns number
The largest entry
Example
```
const largest = bitbybit.vector.max({ vector: [3, 7, 2, 9, 1] });
```
- Defined in bitbybit-docs.d.ts:65224

min

min(inputs: VectorDto): number
Finds the smallest value in a vector.

Example: [3, 7, 2, 9, 1] -> 1
Parameters
- inputs: VectorDto
  The vector
Returns number
The smallest entry
Example
```
const smallest = bitbybit.vector.min({ vector: [3, 7, 2, 9, 1] });
```
- Defined in bitbybit-docs.d.ts:65239

remove

removeAllDuplicateVectors

removeAllDuplicateVectors(inputs: RemoveAllDuplicateVectorsDto): number[][]
Removes every repeated vector from a list, keeping the first occurrence of each.

Two vectors count as the same when every entry differs by less than tolerance. Example: [[1,2,3], [4,5,6], [1,2,3], [7,8,9]] -> [[1,2,3], [4,5,6], [7,8,9]]
Parameters
- inputs: RemoveAllDuplicateVectorsDto
  Vectors to filter and the tolerance
Returns number[][]
The vectors without repeats, in their original order
Example
```
const unique = bitbybit.vector.removeAllDuplicateVectors({
    vectors: [[1, 2, 3], [4, 5, 6], [1, 2, 3]],
    tolerance: 1e-7,
});
```
- Defined in bitbybit-docs.d.ts:64934

removeConsecutiveDuplicateVectors

removeConsecutiveDuplicateVectors(
inputs: RemoveConsecutiveDuplicateVectorsDto,
): number[][]
Removes a vector when it repeats the one right before it; the same vector further away is kept.

With checkFirstAndLast on, a last vector that repeats the first is dropped too, which closes a loop of points cleanly. Entries within tolerance of each other count as equal. Example: [[1,2], [1,2], [3,4], [1,2]] -> [[1,2], [3,4], [1,2]]
Parameters
- inputs: RemoveConsecutiveDuplicateVectorsDto
  Vectors to filter, whether to compare the first and last, and the tolerance
Returns number[][]
The vectors without consecutive repeats
Example
```
const cleaned = bitbybit.vector.removeConsecutiveDuplicateVectors({
    vectors: [[0, 0], [0, 0], [1, 1], [0, 0]],
    checkFirstAndLast: true,
    tolerance: 1e-7,
});
```
- Defined in bitbybit-docs.d.ts:64956

sum

addAll

addAll(inputs: VectorsDto): number[]
Adds a list of vectors together entry by entry into one vector.

The result has as many entries as the first vector. Example: [[1,2,3], [4,5,6], [7,8,9]] -> [12,15,18]
Parameters
- inputs: VectorsDto
  Vectors to add
Returns number[]
The vector of sums
Example
```
const total = bitbybit.vector.addAll({ vectors: [[1, 2, 3], [4, 5, 6], [7, 8, 9]] });
```
- Defined in bitbybit-docs.d.ts:65038

add

add(inputs: TwoVectorsDto): number[]
Adds two vectors entry by entry.

Example: [1,2,3] + [4,5,6] -> [5,7,9]
Parameters
- inputs: TwoVectorsDto
  The two vectors to add
Returns number[]
The vector of sums
Example
```
const sum = bitbybit.vector.add({ first: [1, 2, 3], second: [4, 5, 6] });
```
- Defined in bitbybit-docs.d.ts:65053

all

all(inputs: VectorBoolDto): boolean
Tells whether every value in a list of booleans is true.

Example: [true, true, true] -> true, [true, false, true] -> false
Parameters
- inputs: VectorBoolDto
  The booleans to check
Returns boolean
True when no entry is false
Example
```
const allTrue = bitbybit.vector.all({ vector: [true, true, false] });
```
- Defined in bitbybit-docs.d.ts:65068

validate

vectorsTheSame

vectorsTheSame(inputs: VectorsTheSameDto): boolean
Tells whether two vectors are the same within a tolerance, entry by entry.

Vectors of different length are never the same. Example: [1,2,3] and [1.0001,2.0001,3.0001] with tolerance 0.001 -> true
Parameters
- inputs: VectorsTheSameDto
  The two vectors and the tolerance
Returns boolean
True when every entry differs by less than the tolerance
Example
```
const same = bitbybit.vector.vectorsTheSame({ vec1: [1, 2, 3], vec2: [1, 2, 3.0000001], tolerance: 1e-6 });
```
- Defined in bitbybit-docs.d.ts:64972

finite

finite(inputs: VectorDto): boolean[]
Marks which entries of a vector are finite numbers.

Example: [1, 2, Infinity, 3] -> [true, true, false, true]
Parameters
- inputs: VectorDto
  The vector to check
Returns boolean[]
One boolean per entry, true when it is finite
Example
```
const flags = bitbybit.vector.finite({ vector: [1, Infinity, 3] });
```
- Defined in bitbybit-docs.d.ts:65178

isZero

isZero(inputs: VectorDto): boolean
Tells whether a vector has no length, that is, every entry is exactly 0.

Example: [0,0,0] -> true, [0,0,0.001] -> false
Parameters
- inputs: VectorDto
  The vector to check
Returns boolean
True when the length is 0
Example
```
const zero = bitbybit.vector.isZero({ vector: [0, 0, 0] });
```
- Defined in bitbybit-docs.d.ts:65193

Class Vector

Index

Constructors

angles

base

create

distance

extract

remove

sum

validate

Constructors

constructor

Parameters

Returns Bit.Vector

angles

angleBetween

Parameters

Returns number

Example

angleBetweenNormalized2d

Parameters

Returns number

Example

positiveAngleBetween

Parameters

Returns number

Example

signedAngleBetween

Parameters

Returns number

Example

base

cross

Parameters

Returns number[]

Example

div

Parameters

Returns number[]

Example

domain

Parameters

Returns number

Example

dot

Parameters

Returns number

Example

mul

Parameters

Returns number[]

Example

neg

Parameters

Returns number[]

Example

normSquared

Parameters

Returns number

Example

norm

Parameters

Returns number

Example

normalized

Parameters

Returns number[]

Example

onRay

Parameters

Returns number[]

Example

sub

Parameters

Returns number[]

Example

sum

Parameters

Returns number