Class Vector

基于普通数值数组的向量数学。向量是一个数值数组；在 3D 中它是 [x, y, z]，Y 指向上方，与点的形式相同，因此两者可以互相传给对方的方法。每个方法都返回新数组或数值，从不更改其输入。角度以度为单位。

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
测量两个向量之间的夹角，以度为单位，始终在 0 到 180 之间。

不考虑转动方向；需要时使用 signedAngleBetween。示例：[1,0,0] 和 [0,1,0] -> 90
Parameters
- inputs: TwoVectorsDto
  两个向量
Returns number
以度为单位的角度
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
测量从第一个 2D 向量到第二个的带符号夹角，以度为单位，从 -180 到 180.

只使用每个向量的前两个分量；正角度为逆时针转动。示例：[1,0] 到 [0,1] -> 90，[0,1] 到 [1,0] -> -90
Parameters
- inputs: TwoVectorsDto
  两个 2D 向量
Returns number
以度为单位的带符号角度
Example
```
const angle = bitbybit.vector.angleBetweenNormalized2d({ first: [1, 0], second: [0, 1] });
```
- Defined in bitbybit-docs.d.ts:57395

positiveAngleBetween

positiveAngleBetween(inputs: TwoVectorsReferenceDto): number
测量从第一个向量到第二个向量绕参考方向转动的角度，以度为单位，从 0 到 360。

当参考向量指向你时，转动为逆时针。示例：[1,0,0] 到 [0,0,-1] 绕 [0,1,0] -> 90
Parameters
- inputs: TwoVectorsReferenceDto
  两个向量和作为旋转轴的参考方向
Returns number
0 到 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
测量从第一个向量到第二个向量绕参考方向转动的角度，以度为单位，从 0 到 360。

当参考向量指向你时，转动为逆时针：顺时针转动 30 度读作 330。示例：[1,0,0] 到 [0,0,-1] 绕 [0,1,0] -> 90
Parameters
- inputs: TwoVectorsReferenceDto
  两个向量和作为旋转轴的参考方向
Returns number
0 到 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[]
计算两个 3D 向量的叉积：一个与两者都垂直的向量。

其方向遵循右手定则，其长度是两个向量所张成的平行四边形的面积。示例：[1,0,0] x [0,1,0] -> [0,0,1]
Parameters
- inputs: TwoVectorsDto
  两个 3D 向量
Returns number[]
同时垂直于两者的向量
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[]
将向量的每个分量除以一个数。

示例：[10,20,30] / 2 -> [5,10,15]
Parameters
- inputs: VectorScalarDto
  向量和作为除数的数值
Returns number[]
相除后的向量
Example
```
const half = bitbybit.vector.div({ vector: [10, 20, 30], scalar: 2 });
```
- Defined in bitbybit-docs.d.ts:57521

domain

domain(inputs: VectorDto): number
用向量的最后一个值减去第一个值，对于已排序的列表这就是它的范围。

示例：[1,3,5,9] -> 8
Parameters
- inputs: VectorDto
  向量
Returns number
最后一个值减去第一个值
Example
```
const span = bitbybit.vector.domain({ vector: [1, 3, 5, 9] });
```
- Defined in bitbybit-docs.d.ts:57536

dot

dot(inputs: TwoVectorsDto): number
计算两个向量的点积：对应分量乘积之和。

对于相互垂直的向量它为 0，对于单位向量它是两者夹角的余弦。示例：[1,2,3] 和 [4,5,6] -> 32
Parameters
- inputs: TwoVectorsDto
  两个向量
Returns number
点积
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[]
将向量的每个分量乘以一个数。

示例：[2,3,4] x 5 -> [10,15,20]
Parameters
- inputs: VectorScalarDto
  向量和作为乘数的数值
Returns number[]
缩放后的向量
Example
```
const scaled = bitbybit.vector.mul({ vector: [2, 3, 4], scalar: 5 });
```
- Defined in bitbybit-docs.d.ts:57644

neg

neg(inputs: VectorDto): number[]
翻转每个分量的符号，使向量指向相反方向。

示例：[5,-3,2] -> [-5,3,-2]
Parameters
- inputs: VectorDto
  要反转的向量
Returns number[]
取反后的向量
Example
```
const opposite = bitbybit.vector.neg({ vector: [5, -3, 2] });
```
- Defined in bitbybit-docs.d.ts:57659

normSquared

normSquared(inputs: VectorDto): number
计算向量长度的平方，在只需比较长度时可避免开平方根。

示例：[3,4,0] -> 25
Parameters
- inputs: VectorDto
  向量
Returns number
长度的平方
Example
```
const n2 = bitbybit.vector.normSquared({ vector: [3, 4, 0] });
```
- Defined in bitbybit-docs.d.ts:57675

norm

norm(inputs: VectorDto): number
计算向量的长度。

示例：[3,4,0] -> 5，[1,0,0] -> 1
Parameters
- inputs: VectorDto
  向量
Returns number
以模型单位表示的长度
Example
```
const len = bitbybit.vector.norm({ vector: [3, 4, 0] });
```
- Defined in bitbybit-docs.d.ts:57690

normalized

normalized(inputs: VectorDto): number[]
将 3D 向量缩放到长度 1，同时保持其方向。

短于 1e-8 的向量没有可保持的方向，因此结果为 undefined。示例：[3,4,0] -> [0.6,0.8,0]
Parameters
- inputs: VectorDto
  要归一化的 3D 向量
Returns number[]
单位向量，输入长度为零时为 undefined
Example
```
const direction = bitbybit.vector.normalized({ vector: [3, 4, 0] });
```
- Defined in bitbybit-docs.d.ts:57706

onRay

onRay(inputs: RayPointDto): number[]
找出从起点沿某方向给定距离处的点。

方向按原样使用，因此长度为 2 的方向会走两倍的距离。示例：起点 [0,0,0]，方向 [1,0,0]，距离 5 -> [5,0,0]
Parameters
- inputs: RayPointDto
  起点、方向和距离
Returns number[]
射线上的点
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[]
逐分量用第一个向量减去第二个向量。

示例：[10,20,30] - [1,2,3] -> [9,18,27]
Parameters
- inputs: TwoVectorsDto
  被减向量和要减去的向量
Returns number[]
各项之差组成的向量
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
将向量的所有值加成一个数。

示例：[1,2,3,4] -> 10
Parameters
- inputs: VectorDto
  要求和的向量
Returns number
总和
Example
```
const total = bitbybit.vector.sum({ vector: [1, 2, 3, 4] });
```
- Defined in bitbybit-docs.d.ts:57864

lengthSq

lengthSq(inputs: Vector3Dto): number
计算 3D 向量长度的平方，在只需比较长度时可避免开平方根。

示例：[3,4,0] -> 25
Parameters
- inputs: Vector3Dto
  3D 向量
Returns number
长度的平方
Example
```
const l2 = bitbybit.vector.lengthSq({ vector: [3, 4, 0] });
```
- Defined in bitbybit-docs.d.ts:57880

length

length(inputs: Vector3Dto): number
计算 3D 向量的长度。

示例：[3,4,0] -> 5
Parameters
- inputs: Vector3Dto
  3D 向量
Returns number
以模型单位表示的长度
Example
```
const len = bitbybit.vector.length({ vector: [3, 4, 0] });
```
- Defined in bitbybit-docs.d.ts:57895

create

vectorXYZ

vectorXYZ(inputs: VectorXYZDto): Vector3
由 x、y 和 z 值构建 3D 向量。

示例：x=1, y=2, z=3 -> [1,2,3]
Parameters
- inputs: VectorXYZDto
  三个值
Returns Vector3
向量 [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
由 x 和 y 值构建 2D 向量。

示例：x=3, y=4 -> [3,4]
Parameters
- inputs: VectorXYDto
  两个值
Returns Vector2
向量 [x, y]
Example
```
const right = bitbybit.vector.vectorXY({ x: 1, y: 0 });
```
- Defined in bitbybit-docs.d.ts:57752

range

range(inputs: RangeMaxDto): number[]
列出从 0 到 max（不含）的整数。

示例：max=5 -> [0,1,2,3,4]
Parameters
- inputs: RangeMaxDto
  范围的终点，不包含在结果中
Returns number[]
从 0 到 max - 1 的数值
Example
```
const indices = bitbybit.vector.range({ max: 5 });
```
- Defined in bitbybit-docs.d.ts:57767

span

span(inputs: SpanDto): number[]
列出从 min 到 max 以 step 为步长的数值；当某一步恰好落在 max 上时包含它。

示例：min=0, max=10, step=2 -> [0,2,4,6,8,10]
Parameters
- inputs: SpanDto
  起点、终点和步长
Returns number[]
区间内的数值
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[]
列出从 min 到 max 按缓动曲线分布的 nrItems 个数值，使它们向一端或两端聚集。

打开 intervals 时，结果包含相邻数值之间的间隔而不是数值本身。示例：min=0, max=100, nrItems=5, ease='easeInQuad' -> [0, 6.25, 25, 56.25, 100]
Parameters
- inputs: SpanEaseItemsDto
  起点、终点、项数、缓动方式以及是否返回间隔
Returns number[]
缓动后的数值，或它们之间的间隔
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[]
列出从 min 到 max 均匀分布的 nrItems 个数值，两端都包含。

示例：min=0, max=10, nrItems=5 -> [0, 2.5, 5, 7.5, 10]
Parameters
- inputs: SpanLinearItemsDto
  起点、终点和项数
Returns number[]
等间距的数值
Example
```
const values = bitbybit.vector.spanLinearItems({ min: 0, max: 10, nrItems: 5 });
```
- Defined in bitbybit-docs.d.ts:57834

parseNumbers

parseNumbers(inputs: VectorStringDto): number[]
将数字字符串列表转成数值。

不是数字的字符串变成 NaN。示例：['1', '2.5', '3'] -> [1, 2.5, 3]
Parameters
- inputs: VectorStringDto
  要解析的字符串
Returns number[]
数值
Example
```
const numbers = bitbybit.vector.parseNumbers({ vector: ["1", "2.5", "-3"] });
```
- Defined in bitbybit-docs.d.ts:57911

distance

distSquared

distSquared(inputs: TwoVectorsDto): number
计算两个向量之间距离的平方，在只需比较距离时可避免开平方根。

示例：[0,0,0] 到 [3,4,0] -> 25
Parameters
- inputs: TwoVectorsDto
  两个向量
Returns number
距离的平方
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
计算两个向量之间的直线距离。

示例：[0,0,0] 到 [3,4,0] -> 5
Parameters
- inputs: TwoVectorsDto
  两个向量
Returns number
以模型单位表示的距离
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[]
按分数线性混合两个向量。

fraction 是 first 所占的份额：1 给出 first，0 给出 second，0.5 给出中点。示例：[0,0,0] 和 [10,10,10]，取 0.5 -> [5,5,5]
Parameters
- inputs: FractionTwoVectorsDto
  两个向量和第一个向量所占的比例
Returns number[]
混合后的向量
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
找出向量中的最大值。

示例：[3, 7, 2, 9, 1] -> 9
Parameters
- inputs: VectorDto
  向量
Returns number
最大的一项
Example
```
const largest = bitbybit.vector.max({ vector: [3, 7, 2, 9, 1] });
```
- Defined in bitbybit-docs.d.ts:57614

min

min(inputs: VectorDto): number
找出向量中的最小值。

示例：[3, 7, 2, 9, 1] -> 1
Parameters
- inputs: VectorDto
  向量
Returns number
最小的一项
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[][]
从列表中移除每个重复的向量，保留各自的第一次出现。

当每个分量的差都小于 tolerance 时，两个向量算作相同。示例：[[1,2,3], [4,5,6], [1,2,3], [7,8,9]] -> [[1,2,3], [4,5,6], [7,8,9]]
Parameters
- inputs: RemoveAllDuplicateVectorsDto
  要过滤的向量和容差
Returns number[][]
去除重复后的向量，保持原有顺序
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[][]
当一个向量与紧邻其前的向量重复时将其移除；距离更远的相同向量则保留。

打开 checkFirstAndLast 时，与第一个重复的最后一个向量也会被丢弃，这能干净地闭合一圈点。相互之间在 tolerance 以内的分量算作相等。示例：[[1,2], [1,2], [3,4], [1,2]] -> [[1,2], [3,4], [1,2]]
Parameters
- inputs: RemoveConsecutiveDuplicateVectorsDto
  要过滤的向量、是否比较首尾两项，以及容差
Returns number[][]
去除连续重复后的向量
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[]
将一列向量逐分量相加为一个向量。

结果的分量数与第一个向量相同。示例：[[1,2,3], [4,5,6], [7,8,9]] -> [12,15,18]
Parameters
- inputs: VectorsDto
  要相加的向量
Returns number[]
各项之和组成的向量
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[]
逐分量相加两个向量。

示例：[1,2,3] + [4,5,6] -> [5,7,9]
Parameters
- inputs: TwoVectorsDto
  要相加的两个向量
Returns number[]
各项之和组成的向量
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
判断布尔值列表中的每个值是否都为 true。

示例：[true, true, true] -> true，[true, false, true] -> false
Parameters
- inputs: VectorBoolDto
  要检查的布尔值
Returns boolean
当没有任何一项为 false 时为 true
Example
```
const allTrue = bitbybit.vector.all({ vector: [true, true, false] });
```
- Defined in bitbybit-docs.d.ts:57458

validate

vectorsTheSame

vectorsTheSame(inputs: VectorsTheSameDto): boolean
逐分量判断两个向量在容差内是否相同。

长度不同的向量永远不相同。示例：[1,2,3] 和 [1.0001,2.0001,3.0001]，容差 0.001 -> true
Parameters
- inputs: VectorsTheSameDto
  两个向量和容差
Returns boolean
当每一项的差都小于容差时为 true
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[]
标记向量的哪些分量是有限数。

示例：[1, 2, Infinity, 3] -> [true, true, false, true]
Parameters
- inputs: VectorDto
  要检查的向量
Returns boolean[]
每一项一个布尔值，为有限数时为 true
Example
```
const flags = bitbybit.vector.finite({ vector: [1, Infinity, 3] });
```
- Defined in bitbybit-docs.d.ts:57568

isZero

isZero(inputs: VectorDto): boolean
判断向量是否没有长度，即每个分量都恰好为 0。

示例：[0,0,0] -> true，[0,0,0.001] -> false
Parameters
- inputs: VectorDto
  要检查的向量
Returns boolean
当长度为 0 时为 true
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