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
true जब कोई प्रविष्टि false न हो
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
true जब लंबाई 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