fix: keep input type in reimZeroFilling (#336)

Author: jobo322

src/matrix/__tests__/matrixAutoCorrelation.test.ts

@@ -17,7 +17,7 @@ test('simple', () => {
 test('matrixAutoCorrelation too small', () => {
   const matrix = [[0]];
 
-  expect(() => matrixAutoCorrelation(matrix)).toThrow(
+  expect(() => matrixAutoCorrelation(matrix)).toThrowError(
     'can not calculate info if matrix contains less than 2 rows',
   );
 });

src/matrix/__tests__/matrixBoxPlot.test.ts

@@ -66,7 +66,7 @@ test('matrixBoxPlot odd small', () => {
 test('matrixBoxPlot too small', () => {
   const matrix = [[0], [1], [2], [4]];
 
-  expect(() => matrixBoxPlot(matrix)).toThrow(
+  expect(() => matrixBoxPlot(matrix)).toThrowError(
     'can not calculate info if matrix contains less than 5 rows',
   );
 });

src/matrix/__tests__/matrixCheck.test.ts

@@ -8,7 +8,7 @@ test('should throw error', () => {
     [3, 2, 3],
   ];
 
-  expect(() => matrixCheck(wrongMatrix)).toThrow(
+  expect(() => matrixCheck(wrongMatrix)).toThrowError(
     'all rows must has the same length',
   );
 });

src/matrix/__tests__/matrixCheckRanges.test.ts

@@ -18,7 +18,7 @@ test('should not throw error for valid indices', () => {
     endColumn: 2,
   };
 
-  expect(() => matrixCheckRanges(matrix, options)).not.toThrow();
+  expect(() => matrixCheckRanges(matrix, options)).not.toThrowError();
 });
 
 test('should throw RangeError for out-of-range indices', () => {
@@ -38,5 +38,5 @@ test('should throw RangeError for out-of-range indices', () => {
   };
 
   // Call the function and expect test to throw RangeError
-  expect(() => matrixCheckRanges(matrix, options)).toThrow(RangeError);
+  expect(() => matrixCheckRanges(matrix, options)).toThrowError(RangeError);
 });

src/matrix/__tests__/matrixGetSubMatrix.test.ts

@@ -64,5 +64,5 @@ test('should throw RangeError for out-of-range indices', () => {
     duplicate: true,
   };
 
-  expect(() => matrixGetSubMatrix(matrix, options)).toThrow(RangeError);
+  expect(() => matrixGetSubMatrix(matrix, options)).toThrowError(RangeError);
 });

src/matrix/__tests__/matrixMaxAbsoluteZ.test.ts

@@ -27,5 +27,5 @@ test('large negative', () => {
 test('zero', () => {
   expect(() => {
     matrixMaxAbsoluteZ([[]]);
-  }).toThrow('matrix must have at least 1 row and 1 column');
+  }).toThrowError('matrix must have at least 1 row and 1 column');
 });

src/matrix/__tests__/matrixMinMaxAbsoluteZ.test.ts

@@ -18,5 +18,5 @@ test('zero', () => {
 
   expect(() => {
     matrixMinMaxAbsoluteZ(matrix);
-  }).toThrow('matrixMinMaxAbsoluteZ requires at least 1 row and 1 column');
+  }).toThrowError('matrixMinMaxAbsoluteZ requires at least 1 row and 1 column');
 });

src/matrix/__tests__/matrixMinMaxZ.test.ts

@@ -16,5 +16,5 @@ test('basic', () => {
 test('zero', () => {
   expect(() => {
     matrixMinMaxZ([[]]);
-  }).toThrow('matrix must contain data');
+  }).toThrowError('matrix must contain data');
 });

src/matrix/__tests__/matrixSetSubMatrix.test.ts

@@ -24,11 +24,11 @@ test('simple case', () => {
     [3, 4, 5, 0, 0],
   ]);
 
-  expect(() => matrixSetSubMatrix(matrix, subMatrix, 2, 4)).toThrow(
+  expect(() => matrixSetSubMatrix(matrix, subMatrix, 2, 4)).toThrowError(
     'submatrix indices are out of range',
   );
 
   expect(() =>
     matrixSetSubMatrix(matrix, subMatrix.concat([0, 0]), 2, 3),
-  ).toThrow('submatrix indices are out of range');
+  ).toThrowError('submatrix indices are out of range');
 });

src/reim/__tests__/reimZeroFilling.test.ts

@@ -14,6 +14,26 @@ test('xreimZeroFilling over', () => {
     re: [0, 1, 2, 3, 0, 0],
     im: [4, 5, 6, 7, 0, 0],
   });
+
+  expect(result.re).toBeInstanceOf(Array);
+  expect(result.im).toBeInstanceOf(Array);
+});
+
+test('xreimZeroFilling over with Float64', () => {
+  const re = new Float64Array([0, 1, 2, 3]);
+  const im = new Float64Array([4, 5, 6, 7]);
+  const result = reimZeroFilling({ re, im }, 6);
+
+  const newRe = Array.from(result.re);
+  const newIm = Array.from(result.im);
+
+  expect({ re: newRe, im: newIm }).toStrictEqual({
+    re: [0, 1, 2, 3, 0, 0],
+    im: [4, 5, 6, 7, 0, 0],
+  });
+
+  expect(result.re).toBeInstanceOf(Float64Array);
+  expect(result.im).toBeInstanceOf(Float64Array);
 });
 
 test('xreimZeroFilling equal', () => {
@@ -30,8 +50,8 @@ test('xreimZeroFilling equal', () => {
 });
 
 test('xreimZeroFilling under', () => {
-  const re = [0, 1, 2, 3];
-  const im = [4, 5, 6, 7];
+  const re = new Float64Array([0, 1, 2, 3]);
+  const im = new Float64Array([4, 5, 6, 7]);
   const result = reimZeroFilling({ re, im }, 2);
   const newRe = Array.from(result.re);
   const newIm = Array.from(result.im);