update: vector adjustments + tests

VsevolodX · VsevolodX · commit 71f6ae048233 · 2025-04-25T21:39:37.000-07:00
diff --git a/dist/js/vector.d.ts b/dist/js/vector.d.ts
@@ -9,14 +9,15 @@ export declare class Vector3D {
     get z(): number;
     equals(other: number[] | Vector3DSchema | Vector3D): boolean;
     get norm(): number;
+    translateByVector(vector: Vector3DSchema | Vector3D): Vector3D;
 }
 export declare class RoundedVector3D extends Vector3D {
     static roundPrecision: number;
     toJSON(skipRounding?: boolean): Vector3DSchema;
-    get value_rounded(): Vector3DSchema;
-    get x_rounded(): number;
-    get y_rounded(): number;
-    get z_rounded(): number;
+    get valueRounded(): Vector3DSchema;
+    get xRounded(): number;
+    get yRounded(): number;
+    get zRounded(): number;
     equals(other: Vector3DSchema | RoundedVector3D): boolean;
-    get norm_rounded(): number;
+    get normRounded(): number;
 }
diff --git a/dist/js/vector.js b/dist/js/vector.js
@@ -37,6 +37,11 @@ class Vector3D {
     get norm() {
         return math_1.math.vlen(this._value);
     }
+    translateByVector(vector) {
+        const arrayOfNumbers = vector instanceof Vector3D ? vector.value : vector;
+        this._value = this._value.map((v, i) => v + arrayOfNumbers[i]);
+        return this;
+    }
 }
 exports.Vector3D = Vector3D;
 Vector3D.atol = 1e-8;
@@ -47,27 +52,27 @@ class RoundedVector3D extends Vector3D {
             : math_1.math.roundArrayOrNumber(this.value, RoundedVector3D.roundPrecision);
         return [...rounded];
     }
-    get value_rounded() {
+    get valueRounded() {
         return this.toJSON();
     }
-    get x_rounded() {
-        return this.value_rounded[0];
+    get xRounded() {
+        return this.valueRounded[0];
     }
-    get y_rounded() {
-        return this.value_rounded[1];
+    get yRounded() {
+        return this.valueRounded[1];
     }
-    get z_rounded() {
-        return this.value_rounded[2];
+    get zRounded() {
+        return this.valueRounded[2];
     }
     equals(other) {
-        const arr1 = this.value_rounded;
+        const arr1 = this.valueRounded;
         const arr2 = Array.isArray(other)
-            ? new RoundedVector3D(other).value_rounded
-            : other.value_rounded;
+            ? new RoundedVector3D(other).valueRounded
+            : other.valueRounded;
         const atol = RoundedVector3D.atol || 10 ** -RoundedVector3D.roundPrecision;
         return math_1.math.vEqualWithTolerance(arr1, arr2, atol);
     }
-    get norm_rounded() {
+    get normRounded() {
         return math_1.math.roundArrayOrNumber(this.norm, RoundedVector3D.roundPrecision);
     }
 }
diff --git a/src/js/vector.ts b/src/js/vector.ts
@@ -49,6 +49,12 @@ export class Vector3D {
     get norm(): number {
         return math.vlen(this._value);
     }
+
+    translateByVector(vector: Vector3DSchema | Vector3D): Vector3D {
+        const arrayOfNumbers = vector instanceof Vector3D ? vector.value : vector;
+        this._value = this._value.map((v, i) => v + arrayOfNumbers[i]) as Vector3DSchema;
+        return this;
+    }
 }
 
 export class RoundedVector3D extends Vector3D {
@@ -64,32 +70,32 @@ export class RoundedVector3D extends Vector3D {
         return [...rounded] as Vector3DSchema;
     }
 
-    get value_rounded(): Vector3DSchema {
+    get valueRounded(): Vector3DSchema {
         return this.toJSON();
     }
 
-    get x_rounded(): number {
-        return this.value_rounded[0];
+    get xRounded(): number {
+        return this.valueRounded[0];
     }
 
-    get y_rounded(): number {
-        return this.value_rounded[1];
+    get yRounded(): number {
+        return this.valueRounded[1];
     }
 
-    get z_rounded(): number {
-        return this.value_rounded[2];
+    get zRounded(): number {
+        return this.valueRounded[2];
     }
 
     override equals(other: Vector3DSchema | RoundedVector3D): boolean {
-        const arr1 = this.value_rounded;
+        const arr1 = this.valueRounded;
         const arr2 = Array.isArray(other)
-            ? new RoundedVector3D(other).value_rounded
-            : other.value_rounded;
+            ? new RoundedVector3D(other).valueRounded
+            : other.valueRounded;
         const atol = RoundedVector3D.atol || 10 ** -RoundedVector3D.roundPrecision;
         return math.vEqualWithTolerance(arr1, arr2, atol);
     }
 
-    get norm_rounded(): number {
+    get normRounded(): number {
         return math.roundArrayOrNumber(this.norm, RoundedVector3D.roundPrecision) as number;
     }
 }
diff --git a/tests/js/vector.ts b/tests/js/vector.ts
@@ -44,6 +44,14 @@ describe("Vector3D", () => {
         const vector = new Vector3D(VECTOR_FLOAT);
         expect(Math.abs(vector.norm - VECTOR_FLOAT_NORM)).to.be.lessThan(FLOAT_PRECISION);
     });
+
+    it("should translate vector", () => {
+        const vector = new Vector3D(VECTOR_FLOAT);
+        const translationVector3D = new Vector3D([1, 1, 1]);
+        const expectedTranslation = [2.23456789, 3.345678901, 4.456789012];
+        vector.translateByVector(translationVector3D);
+        expect(vector.value).to.deep.equal(expectedTranslation);
+    });
 });
 
 describe("RoundedVector3D", () => {
@@ -57,18 +65,18 @@ describe("RoundedVector3D", () => {
         const vector = new RoundedVector3D(VECTOR_FLOAT);
 
         expect(vector.toJSON()).to.deep.equal(VECTOR_FLOAT_ROUNDED_4);
-        expect(vector.value_rounded).to.deep.equal(VECTOR_FLOAT_ROUNDED_4);
-        expect(vector.x_rounded).to.be.deep.equal(VECTOR_FLOAT_ROUNDED_4[0]);
-        expect(vector.y_rounded).to.be.deep.equal(VECTOR_FLOAT_ROUNDED_4[1]);
-        expect(vector.z_rounded).to.be.deep.equal(VECTOR_FLOAT_ROUNDED_4[2]);
+        expect(vector.valueRounded).to.deep.equal(VECTOR_FLOAT_ROUNDED_4);
+        expect(vector.xRounded).to.be.deep.equal(VECTOR_FLOAT_ROUNDED_4[0]);
+        expect(vector.yRounded).to.be.deep.equal(VECTOR_FLOAT_ROUNDED_4[1]);
+        expect(vector.zRounded).to.be.deep.equal(VECTOR_FLOAT_ROUNDED_4[2]);
     });
 
     it("should do serialization with precision 3", () => {
         RoundedVector3D.roundPrecision = 3;
         const vector = new RoundedVector3D(VECTOR_FLOAT);
 
         expect(vector.toJSON()).to.deep.equal(VECTOR_FLOAT_ROUNDED_3);
-        expect(vector.value_rounded).to.deep.equal(VECTOR_FLOAT_ROUNDED_3);
+        expect(vector.valueRounded).to.deep.equal(VECTOR_FLOAT_ROUNDED_3);
     });
 
     it("should do equality changes with precision", () => {
@@ -83,4 +91,12 @@ describe("RoundedVector3D", () => {
         expect(vector.equals(VECTOR_FLOAT_ROUNDED_4)).to.equal(true);
         expect(vector.equals(VECTOR_FLOAT_ROUNDED_3)).to.equal(true);
     });
+    it("should extract rounded norm", () => {
+        RoundedVector3D.roundPrecision = 4;
+        const vector = new RoundedVector3D(VECTOR_FLOAT);
+        expect(vector.normRounded).to.be.deep.equal(4.3561);
+
+        RoundedVector3D.roundPrecision = 3;
+        expect(vector.normRounded).to.be.deep.equal(4.356);
+    });
 });

Original file line number	Diff line number	Diff line change
`@@ -37,6 +37,11 @@ class Vector3D {`
`37`	`37`	`get norm() {`
`38`	`38`	`return math_1.math.vlen(this._value);`
`39`	`39`	`}`
	`40`	`+ translateByVector(vector) {`
	`41`	`+ const arrayOfNumbers = vector instanceof Vector3D ? vector.value : vector;`
	`42`	`+ this._value = this._value.map((v, i) => v + arrayOfNumbers[i]);`
	`43`	`+ return this;`
	`44`	`+ }`
`40`	`45`	`}`
`41`	`46`	`exports.Vector3D = Vector3D;`
`42`	`47`	`Vector3D.atol = 1e-8;`
`@@ -47,27 +52,27 @@ class RoundedVector3D extends Vector3D {`
`47`	`52`	`: math_1.math.roundArrayOrNumber(this.value, RoundedVector3D.roundPrecision);`
`48`	`53`	`return [...rounded];`
`49`	`54`	`}`
`50`		`- get value_rounded() {`
	`55`	`+ get valueRounded() {`
`51`	`56`	`return this.toJSON();`
`52`	`57`	`}`
`53`		`- get x_rounded() {`
`54`		`- return this.value_rounded[0];`
	`58`	`+ get xRounded() {`
	`59`	`+ return this.valueRounded[0];`
`55`	`60`	`}`
`56`		`- get y_rounded() {`
`57`		`- return this.value_rounded[1];`
	`61`	`+ get yRounded() {`
	`62`	`+ return this.valueRounded[1];`
`58`	`63`	`}`
`59`		`- get z_rounded() {`
`60`		`- return this.value_rounded[2];`
	`64`	`+ get zRounded() {`
	`65`	`+ return this.valueRounded[2];`
`61`	`66`	`}`
`62`	`67`	`equals(other) {`
`63`		`- const arr1 = this.value_rounded;`
	`68`	`+ const arr1 = this.valueRounded;`
`64`	`69`	`const arr2 = Array.isArray(other)`
`65`		`- ? new RoundedVector3D(other).value_rounded`
`66`		`- : other.value_rounded;`
	`70`	`+ ? new RoundedVector3D(other).valueRounded`
	`71`	`+ : other.valueRounded;`
`67`	`72`	`const atol = RoundedVector3D.atol \|\| 10 ** -RoundedVector3D.roundPrecision;`
`68`	`73`	`return math_1.math.vEqualWithTolerance(arr1, arr2, atol);`
`69`	`74`	`}`
`70`		`- get norm_rounded() {`
	`75`	`+ get normRounded() {`
`71`	`76`	`return math_1.math.roundArrayOrNumber(this.norm, RoundedVector3D.roundPrecision);`
`72`	`77`	`}`
`73`	`78`	`}`
Original file line number	Diff line number	Diff line change
`@@ -49,6 +49,12 @@ export class Vector3D {`
`49`	`49`	`get norm(): number {`
`50`	`50`	`return math.vlen(this._value);`
`51`	`51`	`}`
	`52`	`+`
	`53`	`+ translateByVector(vector: Vector3DSchema \| Vector3D): Vector3D {`
	`54`	`+ const arrayOfNumbers = vector instanceof Vector3D ? vector.value : vector;`
	`55`	`+ this._value = this._value.map((v, i) => v + arrayOfNumbers[i]) as Vector3DSchema;`
	`56`	`+ return this;`
	`57`	`+ }`
`52`	`58`	`}`
`53`	`59`
`54`	`60`	`export class RoundedVector3D extends Vector3D {`
`@@ -64,32 +70,32 @@ export class RoundedVector3D extends Vector3D {`
`64`	`70`	`return [...rounded] as Vector3DSchema;`
`65`	`71`	`}`
`66`	`72`
`67`		`- get value_rounded(): Vector3DSchema {`
	`73`	`+ get valueRounded(): Vector3DSchema {`
`68`	`74`	`return this.toJSON();`
`69`	`75`	`}`
`70`	`76`
`71`		`- get x_rounded(): number {`
`72`		`- return this.value_rounded[0];`
	`77`	`+ get xRounded(): number {`
	`78`	`+ return this.valueRounded[0];`
`73`	`79`	`}`
`74`	`80`
`75`		`- get y_rounded(): number {`
`76`		`- return this.value_rounded[1];`
	`81`	`+ get yRounded(): number {`
	`82`	`+ return this.valueRounded[1];`
`77`	`83`	`}`
`78`	`84`
`79`		`- get z_rounded(): number {`
`80`		`- return this.value_rounded[2];`
	`85`	`+ get zRounded(): number {`
	`86`	`+ return this.valueRounded[2];`
`81`	`87`	`}`
`82`	`88`
`83`	`89`	`override equals(other: Vector3DSchema \| RoundedVector3D): boolean {`
`84`		`- const arr1 = this.value_rounded;`
	`90`	`+ const arr1 = this.valueRounded;`
`85`	`91`	`const arr2 = Array.isArray(other)`
`86`		`- ? new RoundedVector3D(other).value_rounded`
`87`		`- : other.value_rounded;`
	`92`	`+ ? new RoundedVector3D(other).valueRounded`
	`93`	`+ : other.valueRounded;`
`88`	`94`	`const atol = RoundedVector3D.atol \|\| 10 ** -RoundedVector3D.roundPrecision;`
`89`	`95`	`return math.vEqualWithTolerance(arr1, arr2, atol);`
`90`	`96`	`}`
`91`	`97`
`92`		`- get norm_rounded(): number {`
	`98`	`+ get normRounded(): number {`
`93`	`99`	`return math.roundArrayOrNumber(this.norm, RoundedVector3D.roundPrecision) as number;`
`94`	`100`	`}`
`95`	`101`	`}`