fix: keep input type in reimZeroFilling

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);

src/reim/reimZeroFilling.ts

@@ -1,4 +1,8 @@
+import type { DoubleArray } from 'cheminfo-types';
+
 import type { DataReIm } from '../types/index.ts';
+import type { DoubleArrayConstructor } from '../utils/createArray.ts';
+import { createDoubleArray } from '../utils/createArray.ts';
 
 /**
  * This function make a zero filling to re and im part.
@@ -8,7 +12,10 @@ import type { DataReIm } from '../types/index.ts';
  * truncated arrays if totalLength is smaller current length or
  * the same input if totalLength is equal that current length
  */
-export function reimZeroFilling(data: DataReIm, totalLength: number): DataReIm {
+export function reimZeroFilling<ArrayType extends DoubleArray>(
+  data: DataReIm<ArrayType>,
+  totalLength: number,
+): DataReIm<ArrayType> {
   if (!Number.isInteger(totalLength) || totalLength < 0) {
     throw new RangeError('totalLength must be a non-negative integer');
   }
@@ -20,19 +27,27 @@ export function reimZeroFilling(data: DataReIm, totalLength: number): DataReIm {
 
   if (length > totalLength) {
     return {
-      re: re.slice(0, totalLength),
-      im: im.slice(0, totalLength),
+      re: re.slice(0, totalLength) as ArrayType,
+      im: im.slice(0, totalLength) as ArrayType,
     };
   }
 
-  const newRE = new Float64Array(totalLength);
-  const newIM = new Float64Array(totalLength);
+  const newRE = createDoubleArray(
+    re.constructor as DoubleArrayConstructor,
+    totalLength,
+  );
+  const newIM = createDoubleArray(
+    im.constructor as DoubleArrayConstructor,
+    totalLength,
+  );
 
-  newRE.set(re);
-  newIM.set(im);
+  for (let i = 0; i < re.length; i++) {
+    newRE[i] = re[i];
+    newIM[i] = im[i];
+  }
 
   return {
-    re: newRE,
-    im: newIM,
+    re: newRE as ArrayType,
+    im: newIM as ArrayType,
   };
 }

src/utils/__tests__/createFromToArray.test.ts

@@ -112,5 +112,5 @@ test('case when we choose a distribution other than uniform or log', () => {
       // @ts-expect-error Testing bad argument.
       distribution: 'other',
     });
-  }).toThrow(Error);
+  }).toThrowError(Error);
 });

src/utils/__tests__/getRescaler.test.ts

@@ -37,7 +37,7 @@ test('getRescale with wrong min / max, no clamp', () => {
     clamp: false,
   });
 
-  expect(() => rescaler(2)).toThrow('Value 2 is out of range [0, 1]');
+  expect(() => rescaler(2)).toThrowError('Value 2 is out of range [0, 1]');
 });
 
 test('getRescale with wrong min / max and logartihmic', () => {

src/utils/calculateAdaptiveWeights.ts

@@ -16,8 +16,7 @@ export interface WeightsAndControlPoints {
   weights?: NumberArray;
 }
 
-export interface CalculateAdaptiveWeightsOptions
-  extends WeightsAndControlPoints {
+export interface CalculateAdaptiveWeightsOptions extends WeightsAndControlPoints {
   /**
    * Factor that determines how quickly the weights are updated in each iteration.
    * A value between 0 and 1, where higher values mean faster updates.

src/x/__tests__/xBoxPlot.test.ts

@@ -92,7 +92,7 @@ test('xBoxPlot odd small', () => {
 test('xBoxPlot too small', () => {
   const array: number[] = [];
 
-  expect(() => xBoxPlot(array)).toThrow('input must not be empty');
+  expect(() => xBoxPlot(array)).toThrowError('input must not be empty');
 });
 
 test('xBoxPlot with one element', () => {

src/x/__tests__/xCheck.test.ts

@@ -3,10 +3,10 @@ import { expect, test } from 'vitest';
 import { xCheck } from '../xCheck.ts';
 
 test('should throw on invalid value', () => {
-  expect(() => xCheck()).toThrow(/input must be an array/);
-  expect(() => xCheck([])).toThrow(/input must not be empty/);
-  expect(() => xCheck([1])).not.toThrow();
-  expect(() => xCheck([1], { minLength: 2 })).toThrow(
+  expect(() => xCheck()).toThrowError(/input must be an array/);
+  expect(() => xCheck([])).toThrowError(/input must not be empty/);
+  expect(() => xCheck([1])).not.toThrowError();
+  expect(() => xCheck([1], { minLength: 2 })).toThrowError(
     /input must have a length of at least 2/,
   );
 });

src/x/__tests__/xDistributionStats.test.ts

@@ -5,7 +5,9 @@ import { xDistributionStats } from '../xDistributionStats.ts';
 test('empty array', () => {
   const data: number[] = [];
 
-  expect(() => xDistributionStats(data)).toThrow('input must not be empty');
+  expect(() => xDistributionStats(data)).toThrowError(
+    'input must not be empty',
+  );
 });
 
 test('one element', () => {

src/x/__tests__/xMeanAbsoluteError.test.ts

@@ -21,5 +21,5 @@ test('different length', () => {
 
   expect(() => {
     return xMeanAbsoluteError(array1, array2);
-  }).toThrow(/length of array1 and array2 must be identical/);
+  }).toThrowError(/length of array1 and array2 must be identical/);
 });

src/x/__tests__/xMeanSquaredError.test.ts

@@ -21,5 +21,5 @@ test('different length', () => {
 
   expect(() => {
     return xMeanSquaredError(array1, array2);
-  }).toThrow(/length of array1 and array2 must be identical/);
+  }).toThrowError(/length of array1 and array2 must be identical/);
 });

src/x/__tests__/xMeanWeighted.test.ts

@@ -30,10 +30,10 @@ test('xMeanWeighted', () => {
     xMeanWeighted([3, 2, 1], [1, 1, 1], { fromIndex: 1, toIndex: 1 }),
   ).toBe(2);
   // expect to throw an error if the length of the arrays are not the same
-  expect(() => xMeanWeighted([1, 2, 3], [1, 1])).toThrow(
+  expect(() => xMeanWeighted([1, 2, 3], [1, 1])).toThrowError(
     'array and weights must have the same length',
   );
-  expect(() => xMeanWeighted([1, 2, 3], [0, 0, 0])).toThrow(
+  expect(() => xMeanWeighted([1, 2, 3], [0, 0, 0])).toThrowError(
     'sum of weights must be > 0',
   );
 });

src/x/__tests__/xMedian.test.ts

@@ -31,5 +31,5 @@ test('should return the median with typed array', () => {
 });
 
 test('should throw on invalid value', () => {
-  expect(() => xMedian([])).toThrow(/input must not be empty/);
+  expect(() => xMedian([])).toThrowError(/input must not be empty/);
 });

src/x/__tests__/xMode.test.ts

@@ -18,5 +18,5 @@ test('should return the mode', () => {
 });
 
 test('should throw on invalid value', () => {
-  expect(() => xMode([])).toThrow(/input must not be empty/);
+  expect(() => xMode([])).toThrowError(/input must not be empty/);
 });

src/x/__tests__/xNormed.test.ts

@@ -5,21 +5,21 @@ import { xNormed } from '../xNormed.ts';
 test('should return the norm', () => {
   expect(() => {
     xNormed([0]);
-  }).toThrow('trying to divide by 0');
+  }).toThrowError('trying to divide by 0');
   expect(() => {
     xNormed([0, 0]);
-  }).toThrow('trying to divide by 0');
+  }).toThrowError('trying to divide by 0');
   expect(xNormed([-1, 1])).toStrictEqual(Float64Array.from([-0.5, 0.5]));
   expect(xNormed([1, 3])).toStrictEqual(Float64Array.from([0.25, 0.75]));
 });
 
 test('should return the norm algorithm=absolute', () => {
   expect(() => {
     xNormed([0], { algorithm: 'absolute' });
-  }).toThrow('trying to divide by 0');
+  }).toThrowError('trying to divide by 0');
   expect(() => {
     xNormed([0, 0], { algorithm: 'absolute' });
-  }).toThrow('trying to divide by 0');
+  }).toThrowError('trying to divide by 0');
   expect(xNormed([-1, 1], { algorithm: 'absolute' })).toStrictEqual(
     Float64Array.from([-0.5, 0.5]),
   );
@@ -31,10 +31,10 @@ test('should return the norm algorithm=absolute', () => {
 test('should return the norm algorithm=max', () => {
   expect(() => {
     xNormed([0], { algorithm: 'max' });
-  }).toThrow('trying to divide by 0');
+  }).toThrowError('trying to divide by 0');
   expect(() => {
     xNormed([0, 0], { algorithm: 'max' });
-  }).toThrow('trying to divide by 0');
+  }).toThrowError('trying to divide by 0');
   expect(xNormed([-1, 1], { algorithm: 'max' })).toStrictEqual(
     Float64Array.from([-1, 1]),
   );
@@ -46,10 +46,10 @@ test('should return the norm algorithm=max', () => {
 test('should return the norm algorithm=max and max to 100', () => {
   expect(() => {
     xNormed([0], { algorithm: 'max', value: 100 });
-  }).toThrow('trying to divide by 0');
+  }).toThrowError('trying to divide by 0');
   expect(() => {
     xNormed([0, 0], { algorithm: 'max', value: 100 });
-  }).toThrow('trying to divide by 0');
+  }).toThrowError('trying to divide by 0');
 
   expect(xNormed([-1, 1], { algorithm: 'max', value: 100 })).toStrictEqual(
     Float64Array.from([-100, 100]),
@@ -62,13 +62,13 @@ test('should return the norm algorithm=max and max to 100', () => {
 test('should return the norm algorithm=sum', () => {
   expect(() => {
     xNormed([0], { algorithm: 'sum' });
-  }).toThrow('trying to divide by 0');
+  }).toThrowError('trying to divide by 0');
   expect(() => {
     xNormed([0, 0], { algorithm: 'sum' });
-  }).toThrow('trying to divide by 0');
+  }).toThrowError('trying to divide by 0');
   expect(() => {
     xNormed([-1, 1], { algorithm: 'sum' });
-  }).toThrow('trying to divide by 0');
+  }).toThrowError('trying to divide by 0');
   expect(xNormed([-1, 3], { algorithm: 'sum' })).toStrictEqual(
     Float64Array.from([-0.5, 1.5]),
   );
@@ -80,13 +80,13 @@ test('should return the norm algorithm=sum', () => {
 test('should return the norm algorithm=sum sumValue=5', () => {
   expect(() => {
     xNormed([0], { algorithm: 'sum', value: 5 });
-  }).toThrow('trying to divide by 0');
+  }).toThrowError('trying to divide by 0');
   expect(() => {
     xNormed([0, 0], { algorithm: 'sum', value: 5 });
-  }).toThrow('trying to divide by 0');
+  }).toThrowError('trying to divide by 0');
   expect(() => {
     xNormed([-1, 1], { algorithm: 'sum', value: 5 });
-  }).toThrow('trying to divide by 0');
+  }).toThrowError('trying to divide by 0');
   expect(xNormed([-1, 3], { algorithm: 'sum', value: 5 })).toStrictEqual(
     Float64Array.from([-2.5, 7.5]),
   );
@@ -96,5 +96,5 @@ test('should return the norm algorithm=sum sumValue=5', () => {
 });
 
 test('should throw on invalid value', () => {
-  expect(() => xNormed([])).toThrow(/input must not be empty/);
+  expect(() => xNormed([])).toThrowError(/input must not be empty/);
 });