Klasse Vector

Vektorrechnung auf einfachen Zahlen-Arrays. Ein Vektor ist ein Array von Zahlen; in 3D ist er [x, y, z] mit Y nach oben, in derselben Gestalt wie ein Punkt, sodass beide an die Methoden des jeweils anderen übergeben werden können. Jede Methode gibt ein neues Array oder eine Zahl zurück und ändert nie ihre Eingaben. Winkel sind in Grad.

Index

Konstruktoren

constructor

new Vector(math: MathBitByBit, geometryHelper: GeometryHelper): Bit.Vector
Parameter
- math: MathBitByBit
- geometryHelper: GeometryHelper
Rückgabewert Bit.Vector
- Definiert in bitbybit-docs.d.ts:57305

angles

angleBetween

angleBetween(inputs: TwoVectorsDto): number
Misst den Winkel zwischen zwei Vektoren in Grad, immer zwischen 0 und 180.

Die Drehrichtung wird nicht berücksichtigt; verwenden Sie dafür signedAngleBetween. Beispiel: [1,0,0] und [0,1,0] -> 90
Parameter
- inputs: TwoVectorsDto
  Die beiden Vektoren
Rückgabewert number
Winkel in Grad
Example
```
const angle = bitbybit.vector.angleBetween({ first: [1, 0, 0], second: [0, 1, 0] });
```
- Definiert in bitbybit-docs.d.ts:57378

angleBetweenNormalized2d

angleBetweenNormalized2d(inputs: TwoVectorsDto): number
Misst den vorzeichenbehafteten Winkel vom ersten 2D-Vektor zum zweiten, in Grad von -180 bis 180.

Nur die ersten beiden Einträge jedes Vektors werden verwendet; ein positiver Winkel dreht gegen den Uhrzeigersinn. Beispiel: [1,0] nach [0,1] -> 90, [0,1] nach [1,0] -> -90
Parameter
- inputs: TwoVectorsDto
  Die beiden 2D-Vektoren
Rückgabewert number
Vorzeichenbehafteter Winkel in Grad
Example
```
const angle = bitbybit.vector.angleBetweenNormalized2d({ first: [1, 0], second: [0, 1] });
```
- Definiert in bitbybit-docs.d.ts:57395

positiveAngleBetween

positiveAngleBetween(inputs: TwoVectorsReferenceDto): number
Misst den Winkel vom ersten Vektor zum zweiten, drehend um eine Bezugsrichtung, in Grad von 0 bis 360.

Die Drehung ist gegen den Uhrzeigersinn, wenn der Bezugsvektor auf Sie zeigt. Beispiel: [1,0,0] nach [0,0,-1] um [0,1,0] -> 90
Parameter
- inputs: TwoVectorsReferenceDto
  Die beiden Vektoren und die Referenzrichtung, um die gedreht wird
Rückgabewert number
Winkel in Grad von 0 bis 360
Example
```
const angle = bitbybit.vector.positiveAngleBetween({ first: [1, 0, 0], second: [0, 0, -1], reference: [0, 1, 0] });
```
- Definiert in bitbybit-docs.d.ts:57412

signedAngleBetween

signedAngleBetween(inputs: TwoVectorsReferenceDto): number
Misst den Winkel vom ersten Vektor zum zweiten, drehend um eine Bezugsrichtung, in Grad von 0 bis 360.

Die Drehung ist gegen den Uhrzeigersinn, wenn der Bezugsvektor auf Sie zeigt: eine Drehung im Uhrzeigersinn um 30 Grad wird als 330 gelesen. Beispiel: [1,0,0] nach [0,0,-1] um [0,1,0] -> 90
Parameter
- inputs: TwoVectorsReferenceDto
  Die beiden Vektoren und die Referenzrichtung, um die gedreht wird
Rückgabewert number
Winkel in Grad von 0 bis 360
Example
```
const angle = bitbybit.vector.signedAngleBetween({ first: [1, 0, 0], second: [0, 0, -1], reference: [0, 1, 0] });
```
- Definiert in bitbybit-docs.d.ts:57785

base

cross

cross(inputs: TwoVectorsDto): number[]
Berechnet das Kreuzprodukt zweier 3D-Vektoren: einen Vektor im rechten Winkel zu beiden.

Seine Richtung folgt der Rechte-Hand-Regel und seine Länge ist der Flächeninhalt des Parallelogramms, das die beiden Vektoren aufspannen. Beispiel: [1,0,0] x [0,1,0] -> [0,0,1]
Parameter
- inputs: TwoVectorsDto
  Die beiden 3D-Vektoren
Rückgabewert number[]
Der Vektor senkrecht zu beiden
Example
```
const normal = bitbybit.vector.cross({ first: [1, 0, 0], second: [0, 1, 0] });
```
- Definiert in bitbybit-docs.d.ts:57475

div

div(inputs: VectorScalarDto): number[]
Teilt jeden Eintrag eines Vektors durch eine Zahl.

Beispiel: [10,20,30] / 2 -> [5,10,15]
Parameter
- inputs: VectorScalarDto
  Der Vektor und die Zahl, durch die dividiert wird
Rückgabewert number[]
Der dividierte Vektor
Example
```
const half = bitbybit.vector.div({ vector: [10, 20, 30], scalar: 2 });
```
- Definiert in bitbybit-docs.d.ts:57521

domain

domain(inputs: VectorDto): number
Zieht den ersten Wert eines Vektors von seinem letzten ab, was bei einer sortierten Liste ihre Spanne ist.

Beispiel: [1,3,5,9] -> 8
Parameter
- inputs: VectorDto
  Der Vektor
Rückgabewert number
Letzter Wert minus erster Wert
Example
```
const span = bitbybit.vector.domain({ vector: [1, 3, 5, 9] });
```
- Definiert in bitbybit-docs.d.ts:57536

dot

dot(inputs: TwoVectorsDto): number
Berechnet das Skalarprodukt zweier Vektoren: die Summe der Produkte zusammengehöriger Einträge.

Es ist 0 für Vektoren im rechten Winkel und, für Einheitsvektoren, der Kosinus des Winkels zwischen ihnen. Beispiel: [1,2,3] und [4,5,6] -> 32
Parameter
- inputs: TwoVectorsDto
  Die beiden Vektoren
Rückgabewert number
Das Skalarprodukt
Example
```
const projection = bitbybit.vector.dot({ first: [1, 2, 3], second: [4, 5, 6] });
```
- Definiert in bitbybit-docs.d.ts:57553

mul

mul(inputs: VectorScalarDto): number[]
Multipliziert jeden Eintrag eines Vektors mit einer Zahl.

Beispiel: [2,3,4] x 5 -> [10,15,20]
Parameter
- inputs: VectorScalarDto
  Der Vektor und die Zahl, mit der multipliziert wird
Rückgabewert number[]
Der skalierte Vektor
Example
```
const scaled = bitbybit.vector.mul({ vector: [2, 3, 4], scalar: 5 });
```
- Definiert in bitbybit-docs.d.ts:57644

neg

neg(inputs: VectorDto): number[]
Kehrt das Vorzeichen jedes Eintrags um, sodass der Vektor in die entgegengesetzte Richtung zeigt.

Beispiel: [5,-3,2] -> [-5,3,-2]
Parameter
- inputs: VectorDto
  Der umzukehrende Vektor
Rückgabewert number[]
Der negierte Vektor
Example
```
const opposite = bitbybit.vector.neg({ vector: [5, -3, 2] });
```
- Definiert in bitbybit-docs.d.ts:57659

normSquared

normSquared(inputs: VectorDto): number
Berechnet die quadrierte Länge eines Vektors, was die Quadratwurzel vermeidet, wenn nur Längen verglichen werden.

Beispiel: [3,4,0] -> 25
Parameter
- inputs: VectorDto
  Der Vektor
Rückgabewert number
Die quadrierte Länge
Example
```
const n2 = bitbybit.vector.normSquared({ vector: [3, 4, 0] });
```
- Definiert in bitbybit-docs.d.ts:57675

norm

norm(inputs: VectorDto): number
Berechnet die Länge eines Vektors.

Beispiel: [3,4,0] -> 5, [1,0,0] -> 1
Parameter
- inputs: VectorDto
  Der Vektor
Rückgabewert number
Die Länge in Modelleinheiten
Example
```
const len = bitbybit.vector.norm({ vector: [3, 4, 0] });
```
- Definiert in bitbybit-docs.d.ts:57690

normalized

normalized(inputs: VectorDto): number[]
Skaliert einen 3D-Vektor auf die Länge 1 und behält dabei seine Richtung.

Ein Vektor, der kürzer als 1e-8 ist, hat keine Richtung, die behalten werden könnte, daher ist das Ergebnis undefined. Beispiel: [3,4,0] -> [0.6,0.8,0]
Parameter
- inputs: VectorDto
  Der zu normierende 3D-Vektor
Rückgabewert number[]
Der Einheitsvektor oder undefined bei einer Eingabe mit Länge null
Example
```
const direction = bitbybit.vector.normalized({ vector: [3, 4, 0] });
```
- Definiert in bitbybit-docs.d.ts:57706

onRay

onRay(inputs: RayPointDto): number[]
Ermittelt den Punkt in einem gegebenen Abstand von einem Startpunkt entlang einer Richtung.

Die Richtung wird so verwendet, wie sie gegeben ist, daher legt eine Richtung der Länge 2 den doppelten Abstand zurück. Beispiel: Start [0,0,0], Richtung [1,0,0], Abstand 5 -> [5,0,0]
Parameter
- inputs: RayPointDto
  Der Startpunkt, die Richtung und der Abstand
Rückgabewert number[]
Der Punkt auf dem Strahl
Example
```
const ahead = bitbybit.vector.onRay({ point: [0, 0, 0], vector: [1, 0, 0], distance: 5 });
```
- Definiert in bitbybit-docs.d.ts:57722

sub

sub(inputs: TwoVectorsDto): number[]
Zieht den zweiten Vektor vom ersten ab, Eintrag für Eintrag.

Beispiel: [10,20,30] - [1,2,3] -> [9,18,27]
Parameter
- inputs: TwoVectorsDto
  Der Vektor, von dem subtrahiert wird, und der Vektor, der subtrahiert wird
Rückgabewert number[]
Der Vektor der Differenzen
Example
```
const diff = bitbybit.vector.sub({ first: [10, 20, 30], second: [1, 2, 3] });
```
- Definiert in bitbybit-docs.d.ts:57849

sum

sum(inputs: VectorDto): number
Addiert alle Werte eines Vektors zu einer Zahl.

Beispiel: [1,2,3,4] -> 10
Parameter
- inputs: VectorDto
  Der aufzusummierende Vektor
Rückgabewert number
Die Summe
Example
```
const total = bitbybit.vector.sum({ vector: [1, 2, 3, 4] });
```
- Definiert in bitbybit-docs.d.ts:57864

lengthSq

lengthSq(inputs: Vector3Dto): number
Berechnet die quadrierte Länge eines 3D-Vektors, was die Quadratwurzel vermeidet, wenn nur Längen verglichen werden.

Beispiel: [3,4,0] -> 25
Parameter
- inputs: Vector3Dto
  Der 3D-Vektor
Rückgabewert number
Die quadrierte Länge
Example
```
const l2 = bitbybit.vector.lengthSq({ vector: [3, 4, 0] });
```
- Definiert in bitbybit-docs.d.ts:57880

length

length(inputs: Vector3Dto): number
Berechnet die Länge eines 3D-Vektors.

Beispiel: [3,4,0] -> 5
Parameter
- inputs: Vector3Dto
  Der 3D-Vektor
Rückgabewert number
Die Länge in Modelleinheiten
Example
```
const len = bitbybit.vector.length({ vector: [3, 4, 0] });
```
- Definiert in bitbybit-docs.d.ts:57895

create

vectorXYZ

vectorXYZ(inputs: VectorXYZDto): Vector3
Erzeugt einen 3D-Vektor aus seinen x-, y- und z-Werten.

Beispiel: x=1, y=2, z=3 -> [1,2,3]
Parameter
- inputs: VectorXYZDto
  Die drei Werte
Rückgabewert Vector3
Der Vektor [x, y, z]
Example
```
const up = bitbybit.vector.vectorXYZ({ x: 0, y: 1, z: 0 });
```
- Definiert in bitbybit-docs.d.ts:57737

vectorXY

vectorXY(inputs: VectorXYDto): Vector2
Erzeugt einen 2D-Vektor aus seinen x- und y-Werten.

Beispiel: x=3, y=4 -> [3,4]
Parameter
- inputs: VectorXYDto
  Die beiden Werte
Rückgabewert Vector2
Der Vektor [x, y]
Example
```
const right = bitbybit.vector.vectorXY({ x: 1, y: 0 });
```
- Definiert in bitbybit-docs.d.ts:57752

range

range(inputs: RangeMaxDto): number[]
Listet die ganzen Zahlen von 0 bis, aber ohne, max auf.

Beispiel: max=5 -> [0,1,2,3,4]
Parameter
- inputs: RangeMaxDto
  Das Ende des Bereichs, das ausgelassen wird
Rückgabewert number[]
Die Zahlen von 0 bis max - 1
Example
```
const indices = bitbybit.vector.range({ max: 5 });
```
- Definiert in bitbybit-docs.d.ts:57767

span

span(inputs: SpanDto): number[]
Listet die Zahlen von min bis max in Schritten von step auf; max ist enthalten, wenn ein Schritt darauf landet.

Beispiel: min=0, max=10, step=2 -> [0,2,4,6,8,10]
Parameter
- inputs: SpanDto
  Der Anfang, das Ende und die Schrittweite
Rückgabewert number[]
Die Zahlen in der Spanne
Example
```
const values = bitbybit.vector.span({ min: 0, max: 10, step: 2.5 });
```
- Definiert in bitbybit-docs.d.ts:57801

spanEaseItems

spanEaseItems(inputs: SpanEaseItemsDto): number[]
Listet nrItems Zahlen von min bis max auf, verteilt nach einer Easing-Kurve, sodass sie sich an einem Ende oder an beiden drängen.

Mit intervals an enthält das Ergebnis die Lücken zwischen Nachbarn statt der Werte selbst. Beispiel: min=0, max=100, nrItems=5, ease='easeInQuad' -> [0, 6.25, 25, 56.25, 100]
Parameter
- inputs: SpanEaseItemsDto
  Der Anfang, das Ende, die Anzahl der Elemente, das Easing und ob die Lücken zurückgegeben werden
Rückgabewert number[]
Die abgeflachten Zahlen oder die Lücken zwischen ihnen
Example
```
const eased = bitbybit.vector.spanEaseItems({ min: 0, max: 100, nrItems: 5, ease: Bit.Inputs.Math.easeEnum.easeInQuad, intervals: false });
```
- Definiert in bitbybit-docs.d.ts:57819

spanLinearItems

spanLinearItems(inputs: SpanLinearItemsDto): number[]
Listet nrItems gleichmäßig verteilte Zahlen von min bis max auf, beide enthalten.

Beispiel: min=0, max=10, nrItems=5 -> [0, 2.5, 5, 7.5, 10]
Parameter
- inputs: SpanLinearItemsDto
  Der Anfang, das Ende und die Anzahl der Elemente
Rückgabewert number[]
Die gleichmäßig verteilten Zahlen
Example
```
const values = bitbybit.vector.spanLinearItems({ min: 0, max: 10, nrItems: 5 });
```
- Definiert in bitbybit-docs.d.ts:57834

parseNumbers

parseNumbers(inputs: VectorStringDto): number[]
Verwandelt eine Liste von Zahlen-Zeichenketten in Zahlen.

Eine Zeichenkette, die keine Zahl ist, wird zu NaN. Beispiel: ['1', '2.5', '3'] -> [1, 2.5, 3]
Parameter
- inputs: VectorStringDto
  Die zu parsenden Zeichenketten
Rückgabewert number[]
Die Zahlen
Example
```
const numbers = bitbybit.vector.parseNumbers({ vector: ["1", "2.5", "-3"] });
```
- Definiert in bitbybit-docs.d.ts:57911

distance

distSquared

distSquared(inputs: TwoVectorsDto): number
Berechnet den quadrierten Abstand zwischen zwei Vektoren, was die Quadratwurzel vermeidet, wenn nur Abstände verglichen werden.

Beispiel: [0,0,0] nach [3,4,0] -> 25
Parameter
- inputs: TwoVectorsDto
  Die beiden Vektoren
Rückgabewert number
Der quadrierte Abstand
Example
```
const d2 = bitbybit.vector.distSquared({ first: [0, 0, 0], second: [3, 4, 0] });
```
- Definiert in bitbybit-docs.d.ts:57491

dist

dist(inputs: TwoVectorsDto): number
Berechnet den geradlinigen Abstand zwischen zwei Vektoren.

Beispiel: [0,0,0] nach [3,4,0] -> 5
Parameter
- inputs: TwoVectorsDto
  Die beiden Vektoren
Rückgabewert number
Der Abstand in Modelleinheiten
Example
```
const distance = bitbybit.vector.dist({ first: [0, 0, 0], second: [3, 4, 0] });
```
- Definiert in bitbybit-docs.d.ts:57506

lerp

lerp(inputs: FractionTwoVectorsDto): number[]
Blendet zwei Vektoren linear um einen Anteil über.

fraction ist der Anteil von first: 1 ergibt first, 0 ergibt second, 0.5 den Mittelpunkt. Beispiel: [0,0,0] und [10,10,10] bei 0.5 -> [5,5,5]
Parameter
- inputs: FractionTwoVectorsDto
  Die beiden Vektoren und der Anteil des ersten
Rückgabewert number[]
Der gemischte Vektor
Example
```
const mid = bitbybit.vector.lerp({ first: [0, 0, 0], second: [10, 10, 10], fraction: 0.5 });
```
- Definiert in bitbybit-docs.d.ts:57599

extract

max

max(inputs: VectorDto): number
Ermittelt den größten Wert in einem Vektor.

Beispiel: [3, 7, 2, 9, 1] -> 9
Parameter
- inputs: VectorDto
  Der Vektor
Rückgabewert number
Der größte Eintrag
Example
```
const largest = bitbybit.vector.max({ vector: [3, 7, 2, 9, 1] });
```
- Definiert in bitbybit-docs.d.ts:57614

min

min(inputs: VectorDto): number
Ermittelt den kleinsten Wert in einem Vektor.

Beispiel: [3, 7, 2, 9, 1] -> 1
Parameter
- inputs: VectorDto
  Der Vektor
Rückgabewert number
Der kleinste Eintrag
Example
```
const smallest = bitbybit.vector.min({ vector: [3, 7, 2, 9, 1] });
```
- Definiert in bitbybit-docs.d.ts:57629

remove

removeAllDuplicateVectors

removeAllDuplicateVectors(inputs: RemoveAllDuplicateVectorsDto): number[][]
Entfernt jeden wiederholten Vektor aus einer Liste und behält das erste Vorkommen jedes Vektors.

Zwei Vektoren gelten als gleich, wenn sich jeder Eintrag um weniger als tolerance unterscheidet. Beispiel: [[1,2,3], [4,5,6], [1,2,3], [7,8,9]] -> [[1,2,3], [4,5,6], [7,8,9]]
Parameter
- inputs: RemoveAllDuplicateVectorsDto
  Die zu filternden Vektoren und die Toleranz
Rückgabewert number[][]
Die Vektoren ohne Wiederholungen, in ihrer ursprünglichen Reihenfolge
Example
```
const unique = bitbybit.vector.removeAllDuplicateVectors({
    vectors: [[1, 2, 3], [4, 5, 6], [1, 2, 3]],
    tolerance: 1e-7,
});
```
- Definiert in bitbybit-docs.d.ts:57324

removeConsecutiveDuplicateVectors

removeConsecutiveDuplicateVectors(
inputs: RemoveConsecutiveDuplicateVectorsDto,
): number[][]
Entfernt einen Vektor, wenn er den direkt davor wiederholt; derselbe Vektor weiter entfernt wird behalten.

Mit checkFirstAndLast an wird auch ein letzter Vektor verworfen, der den ersten wiederholt, was eine Punktschleife sauber schließt. Einträge innerhalb von tolerance zueinander gelten als gleich. Beispiel: [[1,2], [1,2], [3,4], [1,2]] -> [[1,2], [3,4], [1,2]]
Parameter
- inputs: RemoveConsecutiveDuplicateVectorsDto
  Die zu filternden Vektoren, ob der erste und der letzte verglichen werden, und die Toleranz
Rückgabewert number[][]
Die Vektoren ohne aufeinanderfolgende Wiederholungen
Example
```
const cleaned = bitbybit.vector.removeConsecutiveDuplicateVectors({
    vectors: [[0, 0], [0, 0], [1, 1], [0, 0]],
    checkFirstAndLast: true,
    tolerance: 1e-7,
});
```
- Definiert in bitbybit-docs.d.ts:57346

sum

addAll

addAll(inputs: VectorsDto): number[]
Addiert eine Liste von Vektoren Eintrag für Eintrag zu einem Vektor.

Das Ergebnis hat so viele Einträge wie der erste Vektor. Beispiel: [[1,2,3], [4,5,6], [7,8,9]] -> [12,15,18]
Parameter
- inputs: VectorsDto
  Die zu addierenden Vektoren
Rückgabewert number[]
Der Vektor der Summen
Example
```
const total = bitbybit.vector.addAll({ vectors: [[1, 2, 3], [4, 5, 6], [7, 8, 9]] });
```
- Definiert in bitbybit-docs.d.ts:57428

add

add(inputs: TwoVectorsDto): number[]
Addiert zwei Vektoren Eintrag für Eintrag.

Beispiel: [1,2,3] + [4,5,6] -> [5,7,9]
Parameter
- inputs: TwoVectorsDto
  Die beiden zu addierenden Vektoren
Rückgabewert number[]
Der Vektor der Summen
Example
```
const sum = bitbybit.vector.add({ first: [1, 2, 3], second: [4, 5, 6] });
```
- Definiert in bitbybit-docs.d.ts:57443

all

all(inputs: VectorBoolDto): boolean
Sagt, ob jeder Wert in einer Liste boolescher Werte true ist.

Beispiel: [true, true, true] -> true, [true, false, true] -> false
Parameter
- inputs: VectorBoolDto
  Die zu prüfenden booleschen Werte
Rückgabewert boolean
True, wenn kein Eintrag false ist
Example
```
const allTrue = bitbybit.vector.all({ vector: [true, true, false] });
```
- Definiert in bitbybit-docs.d.ts:57458

validate

vectorsTheSame

vectorsTheSame(inputs: VectorsTheSameDto): boolean
Sagt, ob zwei Vektoren innerhalb einer Toleranz gleich sind, Eintrag für Eintrag.

Vektoren unterschiedlicher Länge sind nie gleich. Beispiel: [1,2,3] und [1.0001,2.0001,3.0001] mit Toleranz 0.001 -> true
Parameter
- inputs: VectorsTheSameDto
  Die beiden Vektoren und die Toleranz
Rückgabewert boolean
True, wenn sich jeder Eintrag um weniger als die Toleranz unterscheidet
Example
```
const same = bitbybit.vector.vectorsTheSame({ vec1: [1, 2, 3], vec2: [1, 2, 3.0000001], tolerance: 1e-6 });
```
- Definiert in bitbybit-docs.d.ts:57362

finite

finite(inputs: VectorDto): boolean[]
Markiert, welche Einträge eines Vektors endliche Zahlen sind.

Beispiel: [1, 2, Infinity, 3] -> [true, true, false, true]
Parameter
- inputs: VectorDto
  Der zu prüfende Vektor
Rückgabewert boolean[]
Ein boolescher Wert pro Eintrag, true wenn er endlich ist
Example
```
const flags = bitbybit.vector.finite({ vector: [1, Infinity, 3] });
```
- Definiert in bitbybit-docs.d.ts:57568

isZero

isZero(inputs: VectorDto): boolean
Sagt, ob ein Vektor keine Länge hat, das heißt, jeder Eintrag ist genau 0.

Beispiel: [0,0,0] -> true, [0,0,0.001] -> false
Parameter
- inputs: VectorDto
  Der zu prüfende Vektor
Rückgabewert boolean
True, wenn die Länge 0 ist
Example
```
const zero = bitbybit.vector.isZero({ vector: [0, 0, 0] });
```
- Definiert in bitbybit-docs.d.ts:57583

Klasse Vector

Index

Konstruktoren

angles

base

create

distance

extract

remove

sum

validate

Konstruktoren

constructor

Parameter

Rückgabewert Bit.Vector

angles

angleBetween

Parameter

Rückgabewert number

Example

angleBetweenNormalized2d

Parameter

Rückgabewert number

Example

positiveAngleBetween

Parameter

Rückgabewert number

Example

signedAngleBetween

Parameter

Rückgabewert number

Example

base

cross

Parameter

Rückgabewert number[]

Example

div

Parameter

Rückgabewert number[]

Example

domain

Parameter

Rückgabewert number

Example

dot

Parameter

Rückgabewert number

Example

mul

Parameter

Rückgabewert number[]

Example

neg

Parameter

Rückgabewert number[]

Example

normSquared

Parameter

Rückgabewert number

Example

norm

Parameter

Rückgabewert number

Example

normalized

Parameter

Rückgabewert number[]

Example

onRay

Parameter

Rückgabewert number[]

Example

sub

Parameter

Rückgabewert number[]

Example

sum

Parameter

Rückgabewert number