molecular-ts

1
import { NumericVector } from '../src/vector/types';
2
import { createVector, toVector } from '../src/vector';
3

4
describe.each([
5
  ...dataProviderForAbs(),
6
] as Array<[NumericVector, number]>)(
7
  'Vector abs test',
8
  (input: NumericVector, expected: number) => {
9
    it('', () => {
10
      expect(toVector(input).abs).toEqual(expected);
11
    });
12
  },
13
);
14

15
function dataProviderForAbs(): Array<unknown> {
16
  return [
17
    [[0], 0],
18
    [[0, 0], 0],
19
    [[0, 0, 0], 0],
20
    [[1], 1],
21
    [[4, 3], 5],
22
  ];
23
}
24

25
describe.each([
26
  ...dataProviderForAdd(),
27
] as Array<[NumericVector, NumericVector, NumericVector]>)(
28
  'Vector add test',
29
  (lhs: NumericVector, rhs: NumericVector, expected: NumericVector) => {
30
    it('', () => {
31
      expect(toVector(lhs).clone().add(rhs)).toEqual(expected);
32
      expect(toVector(rhs).clone().add(lhs)).toEqual(expected);
33
      expect(toVector(lhs).clone().add(lhs)).toEqual(toVector(lhs).clone().mul(2));
34
    });
35
  },
36
);
37

38
function dataProviderForAdd(): Array<unknown> {
39
  return [
40
    [[], [], []],
41
    [[0], [0], [0]],
42
    [[2], [2], [4]],
43
    [[0, 0], [0, 0], [0, 0]],
44
    [[0, 0, 0], [0, 0, 0], [0, 0, 0]],
45
    [[1, 2, 3], [1, 2, 3], [2, 4, 6]],
46
    [[1, 2, 3], [1, 2, 3], [2, 4, 6]],
47
    [[], [], toVector([])],
48
    [[0], [0], toVector([0])],
49
    [[2], [2], toVector([4])],
50
    [[0, 0], [0, 0], toVector([0, 0])],
51
    [[0, 0, 0], [0, 0, 0], toVector([0, 0, 0])],
52
    [[1, 2, 3], [1, 2, 3], toVector([2, 4, 6])],
53
    [[1, 2, 3], [1, 2, 3], toVector([2, 4, 6])],
54
  ];
55
}
56

57
describe.each([
58
  ...dataProviderForSub(),
59
] as Array<[NumericVector, NumericVector, NumericVector]>)(
60
  'Vector sub test',
61
  (lhs: NumericVector, rhs: NumericVector, expected: NumericVector) => {
62
    it('', () => {
63
      expect(toVector(lhs).clone().sub(rhs)).toEqual(expected);
64
    });
65
  },
66
);
67

68
function dataProviderForSub(): Array<unknown> {
69
  return [
70
    [[], [], []],
71
    [[0], [0], [0]],
72
    [[2], [2], [0]],
73
    [[0, 0], [0, 0], [0, 0]],
74
    [[0, 0, 0], [0, 0, 0], [0, 0, 0]],
75
    [[1, 2, 3], [1, 2, 3], [0, 0, 0]],
76
    [[1, 2, 3], [1, 1, 1], [0, 1, 2]],
77
  ];
78
}
79

80
describe.each([
81
  ...dataProviderForMul(),
82
] as Array<[NumericVector, number, NumericVector]>)(
83
  'Vector mul test',
84
  (input: NumericVector, multiplier: number, expected: NumericVector) => {
85
    it('', () => {
86
      expect(toVector(input).clone().mul(multiplier)).toEqual(expected);
87
    });
88
  },
89
);
90

91
function dataProviderForMul(): Array<unknown> {
92
  return [
93
    [[], 1, []],
94
    [[0], 1, [0]],
95
    [[2], 1, [2]],
96
    [[2], 2, [4]],
97
    [[0, 0], -3, [-0, -0]],
98
    [[1, 2, 3], 2, [2, 4, 6]],
99
    [[1, 2, 3], 3, [3, 6, 9]],
100
    [[1, 2, 3], -3, [-3, -6, -9]],
101
  ];
102
}
103

104
describe.each([
105
  ...dataProviderForDiv(),
106
] as Array<[NumericVector, number, NumericVector]>)(
107
  'Vector div test',
108
  (input: NumericVector, divider: number, expected: NumericVector) => {
109
    it('', () => {
110
      expect(toVector(input).clone().div(divider).isEqual(expected)).toBeTruthy();
111
    });
112
  },
113
);
114

115
function dataProviderForDiv(): Array<unknown> {
116
  return [
117
    [[], 1, []],
118
    [[0], 1, [0]],
119
    [[2], 1, [2]],
120
    [[2], 2, [1]],
121
    [[0, 0], -3, [0, 0]],
122
    [[2, 4, 6], 2, [1, 2, 3]],
123
    [[3, 6, 9], 3, [1, 2, 3]],
124
    [[-3, -6, -9], -3, [1, 2, 3]],
125
  ];
126
}
127

128
describe.each([
129
  ...dataProviderForInverse(),
130
] as Array<[NumericVector, NumericVector]>)(
131
  'Vector inverse test',
132
  (input: NumericVector, expected: NumericVector) => {
133
    it('', () => {
134
      expect(toVector(input).clone().inverse()).toEqual(expected);
135
    });
136
  },
137
);
138

139
function dataProviderForInverse(): Array<unknown> {
140
  return [
141
    [[], []],
142
    [[0], [-0]],
143
    [[1], [-1]],
144
    [[-1], [1]],
145
    [[2], [-2]],
146
    [[0, 0], [-0, -0]],
147
    [[0, 1], [-0, -1]],
148
    [[0, -1], [-0, 1]],
149
    [[2, -1], [-2, 1]],
150
    [[1, -2, 3], [-1, 2, -3]],
151
  ];
152
}
153

154
describe.each([
155
  ...dataProviderForMulScalar(),
156
] as Array<[NumericVector, NumericVector, number]>)(
157
  'Vector mul scalar test',
158
  (lhs: NumericVector, rhs: NumericVector, expected: number) => {
159
    it('', () => {
160
      expect(toVector(lhs).clone().mulScalar(rhs)).toBeCloseTo(expected);
161
      expect(toVector(rhs).clone().mulScalar(lhs)).toBeCloseTo(expected);
162
    });
163
  },
164
);
165

166
function dataProviderForMulScalar(): Array<unknown> {
167
  return [
168
    [[], [], 0],
169
    [[0], [0], 0],
170
    [[1], [2], 2],
171
    [[0, 1, 2], [3, 0, 0], 0],
172
    [[2, 3, 4], [5, 1, 7], 41],
173
  ];
174
}
175

176
describe.each([
177
  ...dataProviderForMulCoords(),
178
] as Array<[NumericVector, NumericVector, NumericVector]>)(
179
  'Vector mul coords test',
180
  (lhs: NumericVector, rhs: NumericVector, expected: NumericVector) => {
181
    it('', () => {
182
      expect(toVector(lhs).clone().mulCoords(rhs)).toEqual(expected);
183
      expect(toVector(rhs).clone().mulCoords(lhs)).toEqual(expected);
184
    });
185
  },
186
);
187

188
function dataProviderForMulCoords(): Array<unknown> {
189
  return [
190
    [[], [], []],
191
    [[0], [0], [0]],
192
    [[2], [2], [4]],
193
    [[0, 0], [0, 0], [0, 0]],
194
    [[0, 0, 0], [0, 0, 0], [0, 0, 0]],
195
    [[1, 2, 3], [1, 2, 3], [1, 4, 9]],
196
  ];
197
}
198

199
describe.each([
200
  ...dataProviderForDivCoords(),
201
] as Array<[NumericVector, NumericVector, NumericVector]>)(
202
  'Vector div coords test',
203
  (lhs: NumericVector, rhs: NumericVector, expected: NumericVector) => {
204
    it('', () => {
205
      expect(toVector(lhs).clone().divCoords(rhs).isEqual(expected)).toBeTruthy();
206
    });
207
  },
208
);
209

210
function dataProviderForDivCoords(): Array<unknown> {
211
  return [
212
    [[], [], []],
213
    [[0], [1], [0]],
214
    [[4], [2], [2]],
215
    [[0, 0], [1, 1], [0, 0]],
216
    [[9, 4, 1], [3, 2, 1], [3, 2, 1]],
217
  ];
218
}
219

220
describe.each([
221
  ...dataProviderForIsEqualTrue(),
222
] as Array<[NumericVector, NumericVector]>)(
223
  'Vector is equal test',
224
  (input: NumericVector, expected: NumericVector) => {
225
    it('', () => {
226
      expect(toVector(input).clone().isEqual(expected)).toBeTruthy();
227
    });
228
  },
229
);
230

231
function dataProviderForIsEqualTrue(): Array<unknown> {
232
  return [
233
    [[], []],
234
    [[0], [0]],
235
    [[0.1], [0.1]],
236
    [[0.1, 1, 2], [0.1, 1, 2]],
237
  ];
238
}
239

240
describe.each([
241
  ...dataProviderForIsEqualFalse(),
242
] as Array<[NumericVector, NumericVector]>)(
243
  'Vector is equal test',
244
  (input: NumericVector, expected: NumericVector) => {
245
    it('', () => {
246
      expect(toVector(input).clone().isEqual(expected)).toBeFalsy();
247
    });
248
  },
249
);
250

251
function dataProviderForIsEqualFalse(): Array<unknown> {
252
  return [
253
    [[0.000001], [0]],
254
    [[0.1], [0.2]],
255
    [[0.2, 1, 2], [0.1, 1, 2]],
256
    [[0.2, 1, 2], [0.2, 1, 2.00001]],
257
  ];
258
}
259

260
describe.each([
261
  ...dataProviderForIsNormalizedTrue(),
262
] as Array<[NumericVector]>)(
263
  'Vector is normalized true test',
264
  (input: NumericVector) => {
265
    it('', () => {
266
      expect(toVector(input).isNormalized()).toBeTruthy();
267
    });
268
  },
269
);
270

271
function dataProviderForIsNormalizedTrue(): Array<unknown> {
272
  return [
273
    [[1]],
274
    [createVector([0.1]).normalize()],
275
    [createVector([0.1, 1, 2]).normalize()],
276
  ];
277
}
278

279
describe.each([
280
  ...dataProviderForIsNormalizedFalse(),
281
] as Array<[NumericVector]>)(
282
  'Vector is normalized false test',
283
  (input: NumericVector) => {
284
    it('', () => {
285
      expect(toVector(input).isNormalized()).toBeFalsy();
286
    });
287
  },
288
);
289

290
function dataProviderForIsNormalizedFalse(): Array<unknown> {
291
  return [
292
    [[0]],
293
    [[0.1]],
294
    [[0.1, 2, 5]],
295
  ];
296
}
297