Class Vector

Matemática vetorial sobre arrays de números simples. Um vetor é um array de números; em 3D é [x, y, z] com Y a apontar para cima, a mesma forma que um ponto, pelo que os dois podem ser passados aos métodos um do outro. Cada método devolve um novo array ou um número e nunca altera as suas entradas. Os ângulos estão em graus.

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
Mede o ângulo entre dois vetores em graus, sempre entre 0 e 180.

O sentido da rotação não é considerado; use signedAngleBetween para isso. Exemplo: [1,0,0] e [0,1,0] -> 90
Parameters
- inputs: TwoVectorsDto
  Os dois vetores
Returns number
Ângulo em graus
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
Mede o ângulo com sinal do primeiro vetor 2D para o segundo, em graus de -180 a 180.

Só as duas primeiras entradas de cada vetor são usadas; um ângulo positivo roda no sentido anti-horário. Exemplo: [1,0] para [0,1] -> 90, [0,1] para [1,0] -> -90
Parameters
- inputs: TwoVectorsDto
  Os dois vetores 2D
Returns number
Ângulo com sinal em graus
Example
```
const angle = bitbybit.vector.angleBetweenNormalized2d({ first: [1, 0], second: [0, 1] });
```
- Defined in bitbybit-docs.d.ts:57395

positiveAngleBetween

positiveAngleBetween(inputs: TwoVectorsReferenceDto): number
Mede o ângulo do primeiro vetor para o segundo, rodando em torno de uma direção de referência, em graus de 0 a 360.

A rotação é no sentido anti-horário quando o vetor de referência aponta para si. Exemplo: [1,0,0] para [0,0,-1] em torno de [0,1,0] -> 90
Parameters
- inputs: TwoVectorsReferenceDto
  Os dois vetores e a direção de referência em torno da qual rodar
Returns number
Ângulo em graus 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
Mede o ângulo do primeiro vetor para o segundo, rodando em torno de uma direção de referência, em graus de 0 a 360.

A rotação é no sentido anti-horário quando o vetor de referência aponta para si: uma rotação no sentido horário de 30 graus lê-se como 330. Exemplo: [1,0,0] para [0,0,-1] em torno de [0,1,0] -> 90
Parameters
- inputs: TwoVectorsReferenceDto
  Os dois vetores e a direção de referência em torno da qual rodar
Returns number
Ângulo em graus 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 o produto externo de dois vetores 3D: um vetor perpendicular a ambos.

A sua direção segue a regra da mão direita e o seu comprimento é a área do paralelogramo que os dois vetores definem. Exemplo: [1,0,0] x [0,1,0] -> [0,0,1]
Parameters
- inputs: TwoVectorsDto
  Os dois vetores 3D
Returns number[]
O vetor 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 um vetor por um número.

Exemplo: [10,20,30] / 2 -> [5,10,15]
Parameters
- inputs: VectorScalarDto
  O vetor e o número pelo qual dividir
Returns number[]
O vetor 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
Subtrai o primeiro valor de um vetor ao seu último, o que para uma lista ordenada é a sua amplitude.

Exemplo: [1,3,5,9] -> 8
Parameters
- inputs: VectorDto
  O vetor
Returns number
Último valor menos o primeiro valor
Example
```
const span = bitbybit.vector.domain({ vector: [1, 3, 5, 9] });
```
- Defined in bitbybit-docs.d.ts:57536

dot

dot(inputs: TwoVectorsDto): number
Calcula o produto interno de dois vetores: a soma dos produtos das entradas correspondentes.

É 0 para vetores perpendiculares e, para vetores unitários, o cosseno do ângulo entre eles. Exemplo: [1,2,3] e [4,5,6] -> 32
Parameters
- inputs: TwoVectorsDto
  Os dois vetores
Returns number
O produto 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 um vetor por um número.

Exemplo: [2,3,4] x 5 -> [10,15,20]
Parameters
- inputs: VectorScalarDto
  O vetor e o número pelo qual multiplicar
Returns number[]
O vetor 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[]
Inverte o sinal de cada entrada, de modo que o vetor aponta no sentido oposto.

Exemplo: [5,-3,2] -> [-5,3,-2]
Parameters
- inputs: VectorDto
  O vetor a inverter
Returns number[]
O vetor negado
Example
```
const opposite = bitbybit.vector.neg({ vector: [5, -3, 2] });
```
- Defined in bitbybit-docs.d.ts:57659

normSquared

normSquared(inputs: VectorDto): number
Calcula o comprimento ao quadrado de um vetor, o que evita a raiz quadrada quando só se comparam comprimentos.

Exemplo: [3,4,0] -> 25
Parameters
- inputs: VectorDto
  O vetor
Returns number
O comprimento ao quadrado
Example
```
const n2 = bitbybit.vector.normSquared({ vector: [3, 4, 0] });
```
- Defined in bitbybit-docs.d.ts:57675

norm

norm(inputs: VectorDto): number
Calcula o comprimento de um vetor.

Exemplo: [3,4,0] -> 5, [1,0,0] -> 1
Parameters
- inputs: VectorDto
  O vetor
Returns number
O comprimento em unidades do modelo
Example
```
const len = bitbybit.vector.norm({ vector: [3, 4, 0] });
```
- Defined in bitbybit-docs.d.ts:57690

normalized

normalized(inputs: VectorDto): number[]
Escala um vetor 3D para comprimento 1 mantendo a sua direção.

Um vetor mais curto do que 1e-8 não tem direção a manter, por isso o resultado é undefined. Exemplo: [3,4,0] -> [0.6,0.8,0]
Parameters
- inputs: VectorDto
  O vetor 3D a normalizar
Returns number[]
O vetor unitário, ou undefined para uma entrada de comprimento zero
Example
```
const direction = bitbybit.vector.normalized({ vector: [3, 4, 0] });
```
- Defined in bitbybit-docs.d.ts:57706

onRay

onRay(inputs: RayPointDto): number[]
Encontra o ponto a uma dada distância de um ponto de partida ao longo de uma direção.

A direção é usada tal como é dada, por isso uma direção de comprimento 2 percorre o dobro da distância. Exemplo: início [0,0,0], direção [1,0,0], distância 5 -> [5,0,0]
Parameters
- inputs: RayPointDto
  O ponto inicial, a direção e a distância
Returns number[]
O ponto no raio
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[]
Subtrai o segundo vetor ao primeiro, entrada a entrada.

Exemplo: [10,20,30] - [1,2,3] -> [9,18,27]
Parameters
- inputs: TwoVectorsDto
  O vetor do qual subtrair e o vetor a subtrair
Returns number[]
O vetor das diferenças
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
Soma todos os valores de um vetor num só número.

Exemplo: [1,2,3,4] -> 10
Parameters
- inputs: VectorDto
  O vetor a somar
Returns number
O 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 o comprimento ao quadrado de um vetor 3D, o que evita a raiz quadrada quando só se comparam comprimentos.

Exemplo: [3,4,0] -> 25
Parameters
- inputs: Vector3Dto
  O vetor 3D
Returns number
O comprimento ao quadrado
Example
```
const l2 = bitbybit.vector.lengthSq({ vector: [3, 4, 0] });
```
- Defined in bitbybit-docs.d.ts:57880

length

length(inputs: Vector3Dto): number
Calcula o comprimento de um vetor 3D.

Exemplo: [3,4,0] -> 5
Parameters
- inputs: Vector3Dto
  O vetor 3D
Returns number
O comprimento em unidades do modelo
Example
```
const len = bitbybit.vector.length({ vector: [3, 4, 0] });
```
- Defined in bitbybit-docs.d.ts:57895

create

vectorXYZ

vectorXYZ(inputs: VectorXYZDto): Vector3
Constrói um vetor 3D a partir dos seus valores x, y e z.

Exemplo: x=1, y=2, z=3 -> [1,2,3]
Parameters
- inputs: VectorXYZDto
  Os três valores
Returns Vector3
O vetor [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
Constrói um vetor 2D a partir dos seus valores x e y.

Exemplo: x=3, y=4 -> [3,4]
Parameters
- inputs: VectorXYDto
  Os dois valores
Returns Vector2
O vetor [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 os números inteiros de 0 até, mas não incluindo, max.

Exemplo: max=5 -> [0,1,2,3,4]
Parameters
- inputs: RangeMaxDto
  O fim do intervalo, que fica de fora
Returns number[]
Os 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 os números de min a max, avançando step de cada vez; max é incluído quando um passo cai exatamente nele.

Exemplo: min=0, max=10, step=2 -> [0,2,4,6,8,10]
Parameters
- inputs: SpanDto
  O início, o fim e o passo
Returns number[]
Os números no 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 espaçados por uma curva de suavização, de modo que se concentram numa extremidade ou em ambas.

Com intervals ligado, o resultado contém os intervalos entre vizinhos em vez dos próprios valores. Exemplo: min=0, max=100, nrItems=5, ease='easeInQuad' -> [0, 6.25, 25, 56.25, 100]
Parameters
- inputs: SpanEaseItemsDto
  O início, o fim, o número de itens, a suavização e se deve devolver os intervalos
Returns number[]
Os números suavizados, ou os intervalos entre eles
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 uniformemente espaçados de min a max, ambos incluídos.

Exemplo: min=0, max=10, nrItems=5 -> [0, 2.5, 5, 7.5, 10]
Parameters
- inputs: SpanLinearItemsDto
  O início, o fim e o número de itens
Returns number[]
Os números igualmente espaçados
Example
```
const values = bitbybit.vector.spanLinearItems({ min: 0, max: 10, nrItems: 5 });
```
- Defined in bitbybit-docs.d.ts:57834

parseNumbers

parseNumbers(inputs: VectorStringDto): number[]
Transforma uma lista de strings numéricas em números.

Uma string que não seja um número torna-se NaN. Exemplo: ['1', '2.5', '3'] -> [1, 2.5, 3]
Parameters
- inputs: VectorStringDto
  As strings a analisar
Returns number[]
Os 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 a distância ao quadrado entre dois vetores, o que evita a raiz quadrada quando só se comparam distâncias.

Exemplo: [0,0,0] para [3,4,0] -> 25
Parameters
- inputs: TwoVectorsDto
  Os dois vetores
Returns number
A distância ao quadrado
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 a distância em linha reta entre dois vetores.

Exemplo: [0,0,0] para [3,4,0] -> 5
Parameters
- inputs: TwoVectorsDto
  Os dois vetores
Returns number
A distância em unidades do 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 linearmente dois vetores por uma fração.

fraction é a parte de first: 1 dá first, 0 dá second, 0.5 o ponto médio. Exemplo: [0,0,0] e [10,10,10] a 0.5 -> [5,5,5]
Parameters
- inputs: FractionTwoVectorsDto
  Os dois vetores e a fração do primeiro
Returns number[]
O vetor interpolado
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
Encontra o maior valor num vetor.

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

min

min(inputs: VectorDto): number
Encontra o menor valor num vetor.

Exemplo: [3, 7, 2, 9, 1] -> 1
Parameters
- inputs: VectorDto
  O vetor
Returns number
A menor entrada
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[][]
Remove todos os vetores repetidos de uma lista, mantendo a primeira ocorrência de cada um.

Dois vetores contam como o mesmo quando todas as entradas diferem menos do que tolerance. Exemplo: [[1,2,3], [4,5,6], [1,2,3], [7,8,9]] -> [[1,2,3], [4,5,6], [7,8,9]]
Parameters
- inputs: RemoveAllDuplicateVectorsDto
  Vetores a filtrar e a tolerância
Returns number[][]
Os vetores sem repetições, pela sua ordem 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[][]
Remove um vetor quando repete o imediatamente anterior; o mesmo vetor mais adiante é mantido.

Com checkFirstAndLast ligado, um último vetor que repita o primeiro também é descartado, o que fecha um laço de pontos de forma limpa. Entradas dentro de tolerance umas das outras contam como iguais. Exemplo: [[1,2], [1,2], [3,4], [1,2]] -> [[1,2], [3,4], [1,2]]
Parameters
- inputs: RemoveConsecutiveDuplicateVectorsDto
  Vetores a filtrar, se deve comparar o primeiro com o último, e a tolerância
Returns number[][]
Os vetores sem repetições 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[]
Soma uma lista de vetores entrada a entrada num só vetor.

O resultado tem tantas entradas quantas o primeiro vetor. Exemplo: [[1,2,3], [4,5,6], [7,8,9]] -> [12,15,18]
Parameters
- inputs: VectorsDto
  Vetores a somar
Returns number[]
O vetor das somas
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[]
Soma dois vetores entrada a entrada.

Exemplo: [1,2,3] + [4,5,6] -> [5,7,9]
Parameters
- inputs: TwoVectorsDto
  Os dois vetores a somar
Returns number[]
O vetor das somas
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 se todos os valores numa lista de booleanos são verdadeiros.

Exemplo: [true, true, true] -> true, [true, false, true] -> false
Parameters
- inputs: VectorBoolDto
  Os booleanos a verificar
Returns boolean
True quando nenhuma entrada é 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 se dois vetores são o mesmo dentro de uma tolerância, entrada a entrada.

Vetores de comprimento diferente nunca são o mesmo. Exemplo: [1,2,3] e [1.0001,2.0001,3.0001] com tolerância 0.001 -> true
Parameters
- inputs: VectorsTheSameDto
  Os dois vetores e a tolerância
Returns boolean
True quando cada entrada difere em menos do que a tolerância
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 quais entradas de um vetor são números finitos.

Exemplo: [1, 2, Infinity, 3] -> [true, true, false, true]
Parameters
- inputs: VectorDto
  O vetor a verificar
Returns boolean[]
Um booleano por entrada, true quando é finita
Example
```
const flags = bitbybit.vector.finite({ vector: [1, Infinity, 3] });
```
- Defined in bitbybit-docs.d.ts:57568

isZero

isZero(inputs: VectorDto): boolean
Indica se um vetor não tem comprimento, isto é, se todas as entradas são exatamente 0.

Exemplo: [0,0,0] -> true, [0,0,0.001] -> false
Parameters
- inputs: VectorDto
  O vetor a verificar
Returns boolean
True quando o comprimento é 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