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 এর চেয়ে ছোট ভেক্টরের রাখার মতো কোনো দিক নেই, তাই ফলাফল অসংজ্ঞায়িত। উদাহরণ: [3,4,0] -> [0.6,0.8,0]
Parameters
- inputs: VectorDto
  যে 3D ভেক্টরটি নর্মালাইজ করতে হবে
Returns number[]
একক ভেক্টর, অথবা শূন্য-দৈর্ঘ্যের ইনপুটের জন্য অসংজ্ঞায়িত
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