Class Vector

Matemáticas vectoriales sobre listas de números simples. Un vector es una lista de números; en 3D es [x, y, z] con Y apuntando hacia arriba, la misma forma que un punto, así que ambos pueden pasarse a los métodos del otro. Cada método devuelve una lista nueva o un número y nunca cambia sus entradas. Los ángulos están en grados.

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:57305

angles

angleBetween

angleBetween(inputs: TwoVectorsDto): number
Mide el ángulo entre dos vectores en grados, siempre entre 0 y 180.

El sentido de giro no se tiene en cuenta; usa signedAngleBetween para eso. Ejemplo: [1,0,0] y [0,1,0] -> 90
Parameters
- inputs: TwoVectorsDto
  Los dos vectores
Returns number
Ángulo en grados
Example
```
const angle = bitbybit.vector.angleBetween({ first: [1, 0, 0], second: [0, 1, 0] });
```
- Defined in bitbybit-docs.d.ts:57378

angleBetweenNormalized2d

angleBetweenNormalized2d(inputs: TwoVectorsDto): number
Mide el ángulo con signo del primer vector 2D al segundo, en grados de -180 a 180.

Solo se usan las dos primeras entradas de cada vector; un ángulo positivo gira en sentido antihorario. Ejemplo: [1,0] a [0,1] -> 90, [0,1] a [1,0] -> -90
Parameters
- inputs: TwoVectorsDto
  Los dos vectores 2D
Returns number
Ángulo con signo en grados
Example
```
const angle = bitbybit.vector.angleBetweenNormalized2d({ first: [1, 0], second: [0, 1] });
```
- Defined in bitbybit-docs.d.ts:57395

positiveAngleBetween

positiveAngleBetween(inputs: TwoVectorsReferenceDto): number
Mide el ángulo del primer vector al segundo, girando alrededor de una dirección de referencia, en grados de 0 a 360.

El giro es antihorario cuando el vector de referencia apunta hacia ti. Ejemplo: [1,0,0] a [0,0,-1] alrededor de [0,1,0] -> 90
Parameters
- inputs: TwoVectorsReferenceDto
  Los dos vectores y la dirección de referencia en torno a la que girar
Returns number
Ángulo en grados de 0 a 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:57412

signedAngleBetween

signedAngleBetween(inputs: TwoVectorsReferenceDto): number
Mide el ángulo del primer vector al segundo, girando alrededor de una dirección de referencia, en grados de 0 a 360.

El giro es antihorario cuando el vector de referencia apunta hacia ti: un giro horario de 30 grados se lee como 330. Ejemplo: [1,0,0] a [0,0,-1] alrededor de [0,1,0] -> 90
Parameters
- inputs: TwoVectorsReferenceDto
  Los dos vectores y la dirección de referencia en torno a la que girar
Returns number
Ángulo en grados de 0 a 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:57785

base

cross

cross(inputs: TwoVectorsDto): number[]
Calcula el producto vectorial de dos vectores 3D: un vector perpendicular a ambos.

Su dirección sigue la regla de la mano derecha y su longitud es el área del paralelogramo que abarcan los dos vectores. Ejemplo: [1,0,0] x [0,1,0] -> [0,0,1]
Parameters
- inputs: TwoVectorsDto
  Los dos vectores 3D
Returns number[]
El vector perpendicular a ambos
Example
```
const normal = bitbybit.vector.cross({ first: [1, 0, 0], second: [0, 1, 0] });
```
- Defined in bitbybit-docs.d.ts:57475

div

div(inputs: VectorScalarDto): number[]
Divide cada entrada de un vector entre un número.

Ejemplo: [10,20,30] / 2 -> [5,10,15]
Parameters
- inputs: VectorScalarDto
  El vector y el número por el que dividir
Returns number[]
El vector dividido
Example
```
const half = bitbybit.vector.div({ vector: [10, 20, 30], scalar: 2 });
```
- Defined in bitbybit-docs.d.ts:57521

domain

domain(inputs: VectorDto): number
Resta el primer valor de un vector de su último, lo que para una lista ordenada es su rango.

Ejemplo: [1,3,5,9] -> 8
Parameters
- inputs: VectorDto
  El vector
Returns number
El último valor menos el primero
Example
```
const span = bitbybit.vector.domain({ vector: [1, 3, 5, 9] });
```
- Defined in bitbybit-docs.d.ts:57536

dot

dot(inputs: TwoVectorsDto): number
Calcula el producto escalar de dos vectores: la suma de los productos de las entradas correspondientes.

Es 0 para vectores perpendiculares y, para vectores unitarios, el coseno del ángulo entre ellos. Ejemplo: [1,2,3] y [4,5,6] -> 32
Parameters
- inputs: TwoVectorsDto
  Los dos vectores
Returns number
El producto escalar
Example
```
const projection = bitbybit.vector.dot({ first: [1, 2, 3], second: [4, 5, 6] });
```
- Defined in bitbybit-docs.d.ts:57553

mul

mul(inputs: VectorScalarDto): number[]
Multiplica cada entrada de un vector por un número.

Ejemplo: [2,3,4] x 5 -> [10,15,20]
Parameters
- inputs: VectorScalarDto
  El vector y el número por el que multiplicar
Returns number[]
El vector escalado
Example
```
const scaled = bitbybit.vector.mul({ vector: [2, 3, 4], scalar: 5 });
```
- Defined in bitbybit-docs.d.ts:57644

neg

neg(inputs: VectorDto): number[]
Invierte el signo de cada entrada, de modo que el vector apunta en sentido contrario.

Ejemplo: [5,-3,2] -> [-5,3,-2]
Parameters
- inputs: VectorDto
  El vector que invertir
Returns number[]
El vector negado
Example
```
const opposite = bitbybit.vector.neg({ vector: [5, -3, 2] });
```
- Defined in bitbybit-docs.d.ts:57659

normSquared

normSquared(inputs: VectorDto): number
Calcula la longitud al cuadrado de un vector, lo que evita la raíz cuadrada cuando solo se comparan longitudes.

Ejemplo: [3,4,0] -> 25
Parameters
- inputs: VectorDto
  El vector
Returns number
La longitud al cuadrado
Example
```
const n2 = bitbybit.vector.normSquared({ vector: [3, 4, 0] });
```
- Defined in bitbybit-docs.d.ts:57675

norm

norm(inputs: VectorDto): number
Calcula la longitud de un vector.

Ejemplo: [3,4,0] -> 5, [1,0,0] -> 1
Parameters
- inputs: VectorDto
  El vector
Returns number
La longitud en unidades del modelo
Example
```
const len = bitbybit.vector.norm({ vector: [3, 4, 0] });
```
- Defined in bitbybit-docs.d.ts:57690

normalized

normalized(inputs: VectorDto): number[]
Escala un vector 3D a longitud 1 conservando su dirección.

Un vector más corto que 1e-8 no tiene dirección que conservar, así que el resultado es undefined. Ejemplo: [3,4,0] -> [0.6,0.8,0]
Parameters
- inputs: VectorDto
  El vector 3D que normalizar
Returns number[]
El vector unitario, o undefined para una entrada de longitud cero
Example
```
const direction = bitbybit.vector.normalized({ vector: [3, 4, 0] });
```
- Defined in bitbybit-docs.d.ts:57706

onRay

onRay(inputs: RayPointDto): number[]
Encuentra el punto a una distancia dada de un punto inicial a lo largo de una dirección.

La dirección se usa tal como se da, así que una dirección de longitud 2 recorre el doble de distancia. Ejemplo: inicio [0,0,0], dirección [1,0,0], distancia 5 -> [5,0,0]
Parameters
- inputs: RayPointDto
  El punto inicial, la dirección y la distancia
Returns number[]
El punto en el rayo
Example
```
const ahead = bitbybit.vector.onRay({ point: [0, 0, 0], vector: [1, 0, 0], distance: 5 });
```
- Defined in bitbybit-docs.d.ts:57722

sub

sub(inputs: TwoVectorsDto): number[]
Resta el segundo vector del primero, entrada por entrada.

Ejemplo: [10,20,30] - [1,2,3] -> [9,18,27]
Parameters
- inputs: TwoVectorsDto
  El vector del que restar y el vector que restar
Returns number[]
El vector de las diferencias
Example
```
const diff = bitbybit.vector.sub({ first: [10, 20, 30], second: [1, 2, 3] });
```
- Defined in bitbybit-docs.d.ts:57849

sum

sum(inputs: VectorDto): number
Suma todos los valores de un vector en un solo número.

Ejemplo: [1,2,3,4] -> 10
Parameters
- inputs: VectorDto
  El vector que sumar
Returns number
El total
Example
```
const total = bitbybit.vector.sum({ vector: [1, 2, 3, 4] });
```
- Defined in bitbybit-docs.d.ts:57864

lengthSq

lengthSq(inputs: Vector3Dto): number
Calcula la longitud al cuadrado de un vector 3D, lo que evita la raíz cuadrada cuando solo se comparan longitudes.

Ejemplo: [3,4,0] -> 25
Parameters
- inputs: Vector3Dto
  El vector 3D
Returns number
La longitud al cuadrado
Example
```
const l2 = bitbybit.vector.lengthSq({ vector: [3, 4, 0] });
```
- Defined in bitbybit-docs.d.ts:57880

length

length(inputs: Vector3Dto): number
Calcula la longitud de un vector 3D.

Ejemplo: [3,4,0] -> 5
Parameters
- inputs: Vector3Dto
  El vector 3D
Returns number
La longitud en unidades del modelo
Example
```
const len = bitbybit.vector.length({ vector: [3, 4, 0] });
```
- Defined in bitbybit-docs.d.ts:57895

create

vectorXYZ

vectorXYZ(inputs: VectorXYZDto): Vector3
Construye un vector 3D a partir de sus valores x, y y z.

Ejemplo: x=1, y=2, z=3 -> [1,2,3]
Parameters
- inputs: VectorXYZDto
  Los tres valores
Returns Vector3
El vector [x, y, z]
Example
```
const up = bitbybit.vector.vectorXYZ({ x: 0, y: 1, z: 0 });
```
- Defined in bitbybit-docs.d.ts:57737

vectorXY

vectorXY(inputs: VectorXYDto): Vector2
Construye un vector 2D a partir de sus valores x e y.

Ejemplo: x=3, y=4 -> [3,4]
Parameters
- inputs: VectorXYDto
  Los dos valores
Returns Vector2
El vector [x, y]
Example
```
const right = bitbybit.vector.vectorXY({ x: 1, y: 0 });
```
- Defined in bitbybit-docs.d.ts:57752

range

range(inputs: RangeMaxDto): number[]
Lista los números enteros desde 0 hasta max, sin incluirlo.

Ejemplo: max=5 -> [0,1,2,3,4]
Parameters
- inputs: RangeMaxDto
  El final del rango, que se excluye
Returns number[]
Los números de 0 a max - 1
Example
```
const indices = bitbybit.vector.range({ max: 5 });
```
- Defined in bitbybit-docs.d.ts:57767

span

span(inputs: SpanDto): number[]
Lista los números de min a max, avanzando en pasos de step; max se incluye cuando un paso cae sobre él.

Ejemplo: min=0, max=10, step=2 -> [0,2,4,6,8,10]
Parameters
- inputs: SpanDto
  El inicio, el final y el paso
Returns number[]
Los números del intervalo
Example
```
const values = bitbybit.vector.span({ min: 0, max: 10, step: 2.5 });
```
- Defined in bitbybit-docs.d.ts:57801

spanEaseItems

spanEaseItems(inputs: SpanEaseItemsDto): number[]
Lista nrItems números de min a max espaciados según una curva de suavizado, de modo que se agrupan en un extremo o en ambos.

Con intervals activado, el resultado contiene los huecos entre vecinos en lugar de los valores mismos. Ejemplo: min=0, max=100, nrItems=5, ease='easeInQuad' -> [0, 6.25, 25, 56.25, 100]
Parameters
- inputs: SpanEaseItemsDto
  El inicio, el final, el número de elementos, el suavizado y si devolver los huecos
Returns number[]
Los números suavizados, o los huecos entre ellos
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:57819

spanLinearItems

spanLinearItems(inputs: SpanLinearItemsDto): number[]
Lista nrItems números espaciados uniformemente de min a max, ambos incluidos.

Ejemplo: min=0, max=10, nrItems=5 -> [0, 2.5, 5, 7.5, 10]
Parameters
- inputs: SpanLinearItemsDto
  El inicio, el final y el número de elementos
Returns number[]
Los números espaciados uniformemente
Example
```
const values = bitbybit.vector.spanLinearItems({ min: 0, max: 10, nrItems: 5 });
```
- Defined in bitbybit-docs.d.ts:57834

parseNumbers

parseNumbers(inputs: VectorStringDto): number[]
Convierte una lista de cadenas numéricas en números.

Una cadena que no es un número se convierte en NaN. Ejemplo: ['1', '2.5', '3'] -> [1, 2.5, 3]
Parameters
- inputs: VectorStringDto
  Las cadenas que analizar
Returns number[]
Los números
Example
```
const numbers = bitbybit.vector.parseNumbers({ vector: ["1", "2.5", "-3"] });
```
- Defined in bitbybit-docs.d.ts:57911

distance

distSquared

distSquared(inputs: TwoVectorsDto): number
Calcula la distancia al cuadrado entre dos vectores, lo que evita la raíz cuadrada cuando solo se comparan distancias.

Ejemplo: [0,0,0] a [3,4,0] -> 25
Parameters
- inputs: TwoVectorsDto
  Los dos vectores
Returns number
La distancia al cuadrado
Example
```
const d2 = bitbybit.vector.distSquared({ first: [0, 0, 0], second: [3, 4, 0] });
```
- Defined in bitbybit-docs.d.ts:57491

dist

dist(inputs: TwoVectorsDto): number
Calcula la distancia en línea recta entre dos vectores.

Ejemplo: [0,0,0] a [3,4,0] -> 5
Parameters
- inputs: TwoVectorsDto
  Los dos vectores
Returns number
La distancia en unidades del modelo
Example
```
const distance = bitbybit.vector.dist({ first: [0, 0, 0], second: [3, 4, 0] });
```
- Defined in bitbybit-docs.d.ts:57506

lerp

lerp(inputs: FractionTwoVectorsDto): number[]
Interpola dos vectores linealmente según una fracción.

fraction es la parte de first: 1 da first, 0 da second, 0.5 el punto medio. Ejemplo: [0,0,0] y [10,10,10] en 0.5 -> [5,5,5]
Parameters
- inputs: FractionTwoVectorsDto
  Los dos vectores y la fracción del primero
Returns number[]
El vector mezclado
Example
```
const mid = bitbybit.vector.lerp({ first: [0, 0, 0], second: [10, 10, 10], fraction: 0.5 });
```
- Defined in bitbybit-docs.d.ts:57599

extract

max

max(inputs: VectorDto): number
Encuentra el valor más grande de un vector.

Ejemplo: [3, 7, 2, 9, 1] -> 9
Parameters
- inputs: VectorDto
  El vector
Returns number
La entrada mayor
Example
```
const largest = bitbybit.vector.max({ vector: [3, 7, 2, 9, 1] });
```
- Defined in bitbybit-docs.d.ts:57614

min

min(inputs: VectorDto): number
Encuentra el valor más pequeño de un vector.

Ejemplo: [3, 7, 2, 9, 1] -> 1
Parameters
- inputs: VectorDto
  El vector
Returns number
La entrada menor
Example
```
const smallest = bitbybit.vector.min({ vector: [3, 7, 2, 9, 1] });
```
- Defined in bitbybit-docs.d.ts:57629

remove

removeAllDuplicateVectors

removeAllDuplicateVectors(inputs: RemoveAllDuplicateVectorsDto): number[][]
Elimina todos los vectores repetidos de una lista, conservando la primera aparición de cada uno.

Dos vectores cuentan como el mismo cuando cada entrada difiere en menos de tolerance. Ejemplo: [[1,2,3], [4,5,6], [1,2,3], [7,8,9]] -> [[1,2,3], [4,5,6], [7,8,9]]
Parameters
- inputs: RemoveAllDuplicateVectorsDto
  Los vectores que filtrar y la tolerancia
Returns number[][]
Los vectores sin repeticiones, en su orden original
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:57324

removeConsecutiveDuplicateVectors

removeConsecutiveDuplicateVectors(
inputs: RemoveConsecutiveDuplicateVectorsDto,
): number[][]
Elimina un vector cuando repite el que está justo antes; el mismo vector más lejos se conserva.

Con checkFirstAndLast activado, un último vector que repite el primero también se descarta, lo que cierra limpiamente un bucle de puntos. Las entradas dentro de tolerance entre sí cuentan como iguales. Ejemplo: [[1,2], [1,2], [3,4], [1,2]] -> [[1,2], [3,4], [1,2]]
Parameters
- inputs: RemoveConsecutiveDuplicateVectorsDto
  Los vectores que filtrar, si comparar el primero con el último, y la tolerancia
Returns number[][]
Los vectores sin repeticiones consecutivas
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:57346

sum

addAll

addAll(inputs: VectorsDto): number[]
Suma una lista de vectores entrada por entrada en un solo vector.

El resultado tiene tantas entradas como el primer vector. Ejemplo: [[1,2,3], [4,5,6], [7,8,9]] -> [12,15,18]
Parameters
- inputs: VectorsDto
  Los vectores que sumar
Returns number[]
El vector de las sumas
Example
```
const total = bitbybit.vector.addAll({ vectors: [[1, 2, 3], [4, 5, 6], [7, 8, 9]] });
```
- Defined in bitbybit-docs.d.ts:57428

add

add(inputs: TwoVectorsDto): number[]
Suma dos vectores entrada por entrada.

Ejemplo: [1,2,3] + [4,5,6] -> [5,7,9]
Parameters
- inputs: TwoVectorsDto
  Los dos vectores que sumar
Returns number[]
El vector de las sumas
Example
```
const sum = bitbybit.vector.add({ first: [1, 2, 3], second: [4, 5, 6] });
```
- Defined in bitbybit-docs.d.ts:57443

all

all(inputs: VectorBoolDto): boolean
Indica si todos los valores de una lista de booleanos son true.

Ejemplo: [true, true, true] -> true, [true, false, true] -> false
Parameters
- inputs: VectorBoolDto
  Los booleanos que comprobar
Returns boolean
True cuando ninguna entrada es false
Example
```
const allTrue = bitbybit.vector.all({ vector: [true, true, false] });
```
- Defined in bitbybit-docs.d.ts:57458

validate

vectorsTheSame

vectorsTheSame(inputs: VectorsTheSameDto): boolean
Indica si dos vectores son el mismo dentro de una tolerancia, entrada por entrada.

Vectores de distinta longitud nunca son el mismo. Ejemplo: [1,2,3] y [1.0001,2.0001,3.0001] con tolerancia 0.001 -> true
Parameters
- inputs: VectorsTheSameDto
  Los dos vectores y la tolerancia
Returns boolean
True cuando cada entrada difiere en menos de la tolerancia
Example
```
const same = bitbybit.vector.vectorsTheSame({ vec1: [1, 2, 3], vec2: [1, 2, 3.0000001], tolerance: 1e-6 });
```
- Defined in bitbybit-docs.d.ts:57362

finite

finite(inputs: VectorDto): boolean[]
Marca qué entradas de un vector son números finitos.

Ejemplo: [1, 2, Infinity, 3] -> [true, true, false, true]
Parameters
- inputs: VectorDto
  El vector que comprobar
Returns boolean[]
Un booleano por entrada, true cuando es finita
Example
```
const flags = bitbybit.vector.finite({ vector: [1, Infinity, 3] });
```
- Defined in bitbybit-docs.d.ts:57568

isZero

isZero(inputs: VectorDto): boolean
Indica si un vector no tiene longitud, es decir, todas sus entradas son exactamente 0.

Ejemplo: [0,0,0] -> true, [0,0,0.001] -> false
Parameters
- inputs: VectorDto
  El vector que comprobar
Returns boolean
True cuando la longitud es 0
Example
```
const zero = bitbybit.vector.isZero({ vector: [0, 0, 0] });
```
- Defined in bitbybit-docs.d.ts:57583

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