Skip to content

Commit 10f5879

Browse files
VsevolodXVsevolodX
authored
Merge pull request #119 from Exabyte-io/feature/SOF-7606
2 parents 7c4059a + 05b92e4 commit 10f5879

File tree

8 files changed

+97
-42
lines changed

8 files changed

+97
-42
lines changed

‎dist/js/ArrayWithIds.d.ts

+2
Original file line numberDiff line numberDiff line change
@@ -10,7 +10,9 @@ export declare class ArrayWithIds<T> {
1010
}[]): C;
1111
toJSON(): object[];
1212
toValueWithIdArray(): ValueWithId<T>[];
13+
getElementValueById(id: number): T | undefined;
1314
getElementValueByIndex(index: number): T | undefined;
15+
getElementIdByIndex(index: number): number | undefined;
1416
getElementIdByValue(value: T): number | undefined;
1517
filterByValues(valuesToKeep: T | T[]): void;
1618
filterByIndices(indices: number | number[]): void;

‎dist/js/ArrayWithIds.js

+7
Original file line numberDiff line numberDiff line change
@@ -33,9 +33,16 @@ class ArrayWithIds {
3333
toValueWithIdArray() {
3434
return this.values.map((value, index) => ValueWithId_1.ValueWithId.fromValueAndId(value, this.ids[index]));
3535
}
36+
getElementValueById(id) {
37+
const index = this.ids.indexOf(id);
38+
return index !== -1 ? this.values[index] : undefined;
39+
}
3640
getElementValueByIndex(index) {
3741
return this.values[index];
3842
}
43+
getElementIdByIndex(index) {
44+
return this.ids[index] || undefined;
45+
}
3946
getElementIdByValue(value) {
4047
const index = this.values.findIndex((v) => Array.isArray(v) && Array.isArray(value)
4148
? v.length === value.length && v.every((val, idx) => val === value[idx])

‎dist/js/vector.d.ts

+6-5
Original file line numberDiff line numberDiff line change
@@ -9,14 +9,15 @@ export declare class Vector3D {
99
get z(): number;
1010
equals(other: number[] | Vector3DSchema | Vector3D): boolean;
1111
get norm(): number;
12+
translateByVector(vector: Vector3DSchema | Vector3D): Vector3D;
1213
}
1314
export declare class RoundedVector3D extends Vector3D {
1415
static roundPrecision: number;
1516
toJSON(skipRounding?: boolean): Vector3DSchema;
16-
get value_rounded(): Vector3DSchema;
17-
get x_rounded(): number;
18-
get y_rounded(): number;
19-
get z_rounded(): number;
17+
get valueRounded(): Vector3DSchema;
18+
get xRounded(): number;
19+
get yRounded(): number;
20+
get zRounded(): number;
2021
equals(other: Vector3DSchema | RoundedVector3D): boolean;
21-
get norm_rounded(): number;
22+
get normRounded(): number;
2223
}

‎dist/js/vector.js

+16-11
Original file line numberDiff line numberDiff line change
@@ -37,6 +37,11 @@ class Vector3D {
3737
get norm() {
3838
return math_1.math.vlen(this._value);
3939
}
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+
}
4045
}
4146
exports.Vector3D = Vector3D;
4247
Vector3D.atol = 1e-8;
@@ -47,27 +52,27 @@ class RoundedVector3D extends Vector3D {
4752
: math_1.math.roundArrayOrNumber(this.value, RoundedVector3D.roundPrecision);
4853
return [...rounded];
4954
}
50-
get value_rounded() {
55+
get valueRounded() {
5156
return this.toJSON();
5257
}
53-
get x_rounded() {
54-
return this.value_rounded[0];
58+
get xRounded() {
59+
return this.valueRounded[0];
5560
}
56-
get y_rounded() {
57-
return this.value_rounded[1];
61+
get yRounded() {
62+
return this.valueRounded[1];
5863
}
59-
get z_rounded() {
60-
return this.value_rounded[2];
64+
get zRounded() {
65+
return this.valueRounded[2];
6166
}
6267
equals(other) {
63-
const arr1 = this.value_rounded;
68+
const arr1 = this.valueRounded;
6469
const arr2 = Array.isArray(other)
65-
? new RoundedVector3D(other).value_rounded
66-
: other.value_rounded;
70+
? new RoundedVector3D(other).valueRounded
71+
: other.valueRounded;
6772
const atol = RoundedVector3D.atol || 10 ** -RoundedVector3D.roundPrecision;
6873
return math_1.math.vEqualWithTolerance(arr1, arr2, atol);
6974
}
70-
get norm_rounded() {
75+
get normRounded() {
7176
return math_1.math.roundArrayOrNumber(this.norm, RoundedVector3D.roundPrecision);
7277
}
7378
}

‎src/js/ArrayWithIds.ts

+9
Original file line numberDiff line numberDiff line change
@@ -54,10 +54,19 @@ export class ArrayWithIds<T> {
5454
);
5555
}
5656

57+
getElementValueById(id: number): T | undefined {
58+
const index = this.ids.indexOf(id);
59+
return index !== -1 ? this.values[index] : undefined;
60+
}
61+
5762
getElementValueByIndex(index: number): T | undefined {
5863
return this.values[index];
5964
}
6065

66+
getElementIdByIndex(index: number): number | undefined {
67+
return this.ids[index] || undefined;
68+
}
69+
6170
getElementIdByValue(value: T): number | undefined {
6271
const index = this.values.findIndex((v) =>
6372
Array.isArray(v) && Array.isArray(value)

‎src/js/vector.ts

+17-11
Original file line numberDiff line numberDiff line change
@@ -49,6 +49,12 @@ export class Vector3D {
4949
get norm(): number {
5050
return math.vlen(this._value);
5151
}
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+
}
5258
}
5359

5460
export class RoundedVector3D extends Vector3D {
@@ -64,32 +70,32 @@ export class RoundedVector3D extends Vector3D {
6470
return [...rounded] as Vector3DSchema;
6571
}
6672

67-
get value_rounded(): Vector3DSchema {
73+
get valueRounded(): Vector3DSchema {
6874
return this.toJSON();
6975
}
7076

71-
get x_rounded(): number {
72-
return this.value_rounded[0];
77+
get xRounded(): number {
78+
return this.valueRounded[0];
7379
}
7480

75-
get y_rounded(): number {
76-
return this.value_rounded[1];
81+
get yRounded(): number {
82+
return this.valueRounded[1];
7783
}
7884

79-
get z_rounded(): number {
80-
return this.value_rounded[2];
85+
get zRounded(): number {
86+
return this.valueRounded[2];
8187
}
8288

8389
override equals(other: Vector3DSchema | RoundedVector3D): boolean {
84-
const arr1 = this.value_rounded;
90+
const arr1 = this.valueRounded;
8591
const arr2 = Array.isArray(other)
86-
? new RoundedVector3D(other).value_rounded
87-
: other.value_rounded;
92+
? new RoundedVector3D(other).valueRounded
93+
: other.valueRounded;
8894
const atol = RoundedVector3D.atol || 10 ** -RoundedVector3D.roundPrecision;
8995
return math.vEqualWithTolerance(arr1, arr2, atol);
9096
}
9197

92-
get norm_rounded(): number {
98+
get normRounded(): number {
9399
return math.roundArrayOrNumber(this.norm, RoundedVector3D.roundPrecision) as number;
94100
}
95101
}

‎tests/js/arrayWithIds.tests.ts

+12
Original file line numberDiff line numberDiff line change
@@ -98,6 +98,18 @@ describe("ArrayWithIds Tests", () => {
9898
expect(arrayWithIds.getElementValueByIndex(OUT_OF_RANGE_INDEX)).to.equal(undefined);
9999
});
100100

101+
it("should get element value by ID", () => {
102+
const arrayWithIds = ArrayWithIds.fromObjects(OBJECTS_WITH_IDS);
103+
expect(arrayWithIds.getElementValueById(10)).to.equal("value1");
104+
expect(arrayWithIds.getElementValueById(NON_EXISTENT_ID)).to.equal(undefined);
105+
});
106+
107+
it("should get element ID by index", () => {
108+
const arrayWithIds = ArrayWithIds.fromObjects(OBJECTS_WITH_IDS);
109+
expect(arrayWithIds.getElementIdByIndex(0)).to.equal(10);
110+
expect(arrayWithIds.getElementIdByIndex(OUT_OF_RANGE_INDEX)).to.equal(undefined);
111+
});
112+
101113
it("should get element ID by value", () => {
102114
const arrayWithIds = ArrayWithIds.fromValues(FIRST_THREE_STRINGS);
103115
expect(arrayWithIds.getElementIdByValue("value3")).to.equal(2);

‎tests/js/vector.ts

+28-15
Original file line numberDiff line numberDiff line change
@@ -1,20 +1,17 @@
1+
import { Vector3DSchema } from "@mat3ra/esse/dist/js/types";
12
import { expect } from "chai";
23

3-
import { RoundedVector3D, Vector3D } from "../../src/js/vector";
4+
import { RoundedVector3D, Vector3D } from "../../src/js";
45

5-
const VECTOR_FLOAT: [number, number, number] = [1.23456789, 2.345678901, 3.456789012];
6+
const VECTOR_FLOAT: Vector3DSchema = [1.23456789, 2.345678901, 3.456789012];
67
const VECTOR_FLOAT_NORM = 4.3561172682906;
78
const FLOAT_PRECISION = 1e-8;
89

9-
const VECTOR_FLOAT_DIFFERENT_WITHIN_TOL: [number, number, number] = [
10-
1.23456789999, 2.345678901, 3.456789012,
11-
];
12-
const VECTOR_FLOAT_DIFFERENT_OUTSIDE_TOL: [number, number, number] = [
13-
1.2345699999, 2.345678901, 3.456789012,
14-
];
10+
const VECTOR_FLOAT_DIFFERENT_WITHIN_TOL: Vector3DSchema = [1.23456789999, 2.345678901, 3.456789012];
11+
const VECTOR_FLOAT_DIFFERENT_OUTSIDE_TOL: Vector3DSchema = [1.2345699999, 2.345678901, 3.456789012];
1512

16-
const VECTOR_FLOAT_ROUNDED_4: [number, number, number] = [1.2346, 2.3457, 3.4568];
17-
const VECTOR_FLOAT_ROUNDED_3: [number, number, number] = [1.235, 2.346, 3.457];
13+
const VECTOR_FLOAT_ROUNDED_4: Vector3DSchema = [1.2346, 2.3457, 3.4568];
14+
const VECTOR_FLOAT_ROUNDED_3: Vector3DSchema = [1.235, 2.346, 3.457];
1815

1916
describe("Vector3D", () => {
2017
it("should do init and value access", () => {
@@ -44,6 +41,14 @@ describe("Vector3D", () => {
4441
const vector = new Vector3D(VECTOR_FLOAT);
4542
expect(Math.abs(vector.norm - VECTOR_FLOAT_NORM)).to.be.lessThan(FLOAT_PRECISION);
4643
});
44+
45+
it("should translate vector", () => {
46+
const vector = new Vector3D(VECTOR_FLOAT);
47+
const translationVector3D = new Vector3D([1, 1, 1]);
48+
const expectedTranslation = [2.23456789, 3.345678901, 4.456789012];
49+
vector.translateByVector(translationVector3D);
50+
expect(vector.value).to.deep.equal(expectedTranslation);
51+
});
4752
});
4853

4954
describe("RoundedVector3D", () => {
@@ -57,18 +62,18 @@ describe("RoundedVector3D", () => {
5762
const vector = new RoundedVector3D(VECTOR_FLOAT);
5863

5964
expect(vector.toJSON()).to.deep.equal(VECTOR_FLOAT_ROUNDED_4);
60-
expect(vector.value_rounded).to.deep.equal(VECTOR_FLOAT_ROUNDED_4);
61-
expect(vector.x_rounded).to.be.deep.equal(VECTOR_FLOAT_ROUNDED_4[0]);
62-
expect(vector.y_rounded).to.be.deep.equal(VECTOR_FLOAT_ROUNDED_4[1]);
63-
expect(vector.z_rounded).to.be.deep.equal(VECTOR_FLOAT_ROUNDED_4[2]);
65+
expect(vector.valueRounded).to.deep.equal(VECTOR_FLOAT_ROUNDED_4);
66+
expect(vector.xRounded).to.be.deep.equal(VECTOR_FLOAT_ROUNDED_4[0]);
67+
expect(vector.yRounded).to.be.deep.equal(VECTOR_FLOAT_ROUNDED_4[1]);
68+
expect(vector.zRounded).to.be.deep.equal(VECTOR_FLOAT_ROUNDED_4[2]);
6469
});
6570

6671
it("should do serialization with precision 3", () => {
6772
RoundedVector3D.roundPrecision = 3;
6873
const vector = new RoundedVector3D(VECTOR_FLOAT);
6974

7075
expect(vector.toJSON()).to.deep.equal(VECTOR_FLOAT_ROUNDED_3);
71-
expect(vector.value_rounded).to.deep.equal(VECTOR_FLOAT_ROUNDED_3);
76+
expect(vector.valueRounded).to.deep.equal(VECTOR_FLOAT_ROUNDED_3);
7277
});
7378

7479
it("should do equality changes with precision", () => {
@@ -83,4 +88,12 @@ describe("RoundedVector3D", () => {
8388
expect(vector.equals(VECTOR_FLOAT_ROUNDED_4)).to.equal(true);
8489
expect(vector.equals(VECTOR_FLOAT_ROUNDED_3)).to.equal(true);
8590
});
91+
it("should extract rounded norm", () => {
92+
RoundedVector3D.roundPrecision = 4;
93+
const vector = new RoundedVector3D(VECTOR_FLOAT);
94+
expect(vector.normRounded).to.be.deep.equal(4.3561);
95+
96+
RoundedVector3D.roundPrecision = 3;
97+
expect(vector.normRounded).to.be.deep.equal(4.356);
98+
});
8699
});

0 commit comments

Comments
 (0)