feat: add matrixGetSubMatrix function

src/__tests__/__snapshots__/index.test.ts.snap

@@ -141,6 +141,7 @@ exports[`test existence of exported functions 1`] = `
   "matrixClone",
   "matrixColumnsCorrelation",
   "matrixCreateEmpty",
+  "matrixGetSubMatrix",
   "matrixHistogram",
   "matrixMaxAbsoluteZ",
   "matrixMedian",

src/matrix/__tests__/matrixCheckRanges.test.ts

@@ -0,0 +1,40 @@
+import { matrixCheckRanges } from '../matrixCheckRanges';
+
+test('should not throw error for valid indices', () => {
+  // Define a sample matrix
+  const matrix = [
+    new Float64Array([1, 2, 3]),
+    new Float64Array([4, 5, 6]),
+    new Float64Array([7, 8, 9]),
+  ];
+
+  // Define options with valid indices
+  const options = {
+    startRow: 0,
+    startColumn: 0,
+    endRow: 2,
+    endColumn: 2,
+  };
+
+  expect(() => matrixCheckRanges(matrix, options)).not.toThrow();
+});
+
+test('should throw RangeError for out-of-range indices', () => {
+  // Define a sample matrix
+  const matrix = [
+    new Float64Array([1, 2, 3]),
+    new Float64Array([4, 5, 6]),
+    new Float64Array([7, 8, 9]),
+  ];
+
+  // Define options with out-of-range indices
+  const options = {
+    startRow: 0,
+    startColumn: 0,
+    endRow: 3, // Out of range
+    endColumn: 2,
+  };
+
+  // Call the function and expect test to throw RangeError
+  expect(() => matrixCheckRanges(matrix, options)).toThrow(RangeError);
+});

src/matrix/__tests__/matrixGetSubMatrix.test.ts

@@ -0,0 +1,62 @@
+import { matrixGetSubMatrix } from '../matrixGetSubMatrix';
+
+test('should extract submatrix correctly without duplication', () => {
+  const matrix = [
+    new Float64Array([1, 2, 3]),
+    new Float64Array([4, 5, 6]),
+    new Float64Array([7, 8, 9]),
+  ];
+  const options = {
+    startRow: 0,
+    startColumn: 1,
+    endRow: 1,
+    endColumn: 2,
+    duplicate: false,
+  };
+
+  const subMatrix = matrixGetSubMatrix(matrix, options);
+  const expectedResult = [new Float64Array([2, 3]), new Float64Array([5, 6])];
+  expect(subMatrix).toEqual(expectedResult);
+
+  subMatrix[0][0] = 10;
+  expect(matrix[0][1]).toBe(10);
+});
+
+test('should extract submatrix correctly with duplication', () => {
+  const matrix = [
+    new Float64Array([1, 2, 3]),
+    new Float64Array([4, 5, 6]),
+    new Float64Array([7, 8, 9]),
+  ];
+  const options = {
+    startRow: 0,
+    startColumn: 1,
+    endRow: 1,
+    endColumn: 2,
+    duplicate: true,
+  };
+
+  const subMatrix = matrixGetSubMatrix(matrix, options);
+  const expectedResult = [new Float64Array([2, 3]), new Float64Array([5, 6])];
+  expect(subMatrix).toEqual(expectedResult);
+
+  subMatrix[0][0] = 10;
+  expect(matrix[0][1]).toBe(2);
+});
+
+test('should throw RangeError for out-of-range indices', () => {
+  const matrix = [
+    new Float64Array([1, 2, 3]),
+    new Float64Array([4, 5, 6]),
+    new Float64Array([7, 8, 9]),
+  ];
+  const options = {
+    startRow: 0,
+    startColumn: 1,
+    endRow: 3, // Out of range
+    endColumn: 2,
+    duplicate: true,
+  };
+
+  expect(() => matrixGetSubMatrix(matrix, options)).toThrow(RangeError);
+});

src/matrix/index.ts

@@ -7,6 +7,7 @@ export * from './matrixCheck';
 export * from './matrixClone';
 export * from './matrixColumnsCorrelation';
 export * from './matrixCreateEmpty';
+export * from './matrixGetSubMatrix';
 export * from './matrixHistogram';
 export * from './matrixMaxAbsoluteZ';
 export * from './matrixMedian';

src/matrix/matrixCheckRanges.ts

@@ -0,0 +1,27 @@
+import { DoubleMatrix } from '../types';
+
+export function matrixCheckRanges(
+  matrix: DoubleMatrix,
+  boundaries: {
+    startRow: number;
+    endRow: number;
+    startColumn: number;
+    endColumn: number;
+  },
+) {
+  const { startRow, endRow, startColumn, endColumn } = boundaries;
+  if (
+    startRow > endRow ||
+    startColumn > endColumn ||
+    startRow < 0 ||
+    startRow >= matrix.length ||
+    endRow < 0 ||
+    endRow >= matrix.length ||
+    startColumn < 0 ||
+    startColumn >= matrix[0].length ||
+    endColumn < 0 ||
+    endColumn >= matrix[0].length
+  ) {
+    throw new RangeError('submatrix indices are out of range');
+  }
+}

src/matrix/matrixGetSubMatrix.ts

@@ -0,0 +1,62 @@
+import { matrixCheckRanges } from './matrixCheckRanges';
+
+export interface MatrixGetSubMatrixOptions {
+  /**
+   * row index in matrix for the first row in subMatrix.
+   * @default 0
+   */
+  startRow: number;
+  /**
+   * column index in matrix for the first column in subMatrix.
+   * @default 0
+   */
+  startColumn: number;
+  /**
+   * row index in matrix for the last row in subMatrix.
+   * @default matrix.length - 1
+   */
+  endRow: number;
+  /**
+   * column index in matrix for the last column in subMatrix.
+   * @default matrix[0].length - 1
+   */
+  endColumn: number;
+  /**
+   * duplicate the data
+   * @default true
+   */
+  duplicate?: boolean;
+}
+/**
+ * Get a subMatrix from matrix, the function check if the subMatrix
+ * lies into the dimensions of matrix.
+ * @param matrix - matrix that will receive the new element values.
+ * @returns The sub `matrix`.
+ */
+export function matrixGetSubMatrix(
+  matrix: Float64Array[],
+  options: MatrixGetSubMatrixOptions,
+): Float64Array[] {
+  const {
+    startRow = 0,
+    endRow = matrix.length - 1,
+    startColumn = 0,
+    endColumn = matrix[0].length - 1,
+    duplicate = true,
+  } = options;
+  matrixCheckRanges(matrix, { startColumn, startRow, endColumn, endRow });
+  const nbRows = endRow - startRow + 1;
+
+  const subMatrix: Float64Array[] = [];
+  if (duplicate) {
+    for (let i = 0; i < nbRows; i++) {
+      subMatrix.push(matrix[startRow + i].slice(startColumn, endColumn + 1));
+    }
+  } else {
+    for (let i = 0; i < nbRows; i++) {
+      subMatrix.push(matrix[startRow + i].subarray(startColumn, endColumn + 1));
+    }
+  }
+
+  return subMatrix;
+}

src/matrix/matrixSetSubMatrix.ts

@@ -1,5 +1,7 @@
 import { DoubleMatrix } from '../types';
 
+import { matrixCheckRanges } from './matrixCheckRanges';
+
 /**
  * Set in-place a subMatrix to matrix, the function check if the subMatrix
  * lies into the dimensions of matrix.
@@ -17,34 +19,11 @@ export function matrixSetSubMatrix(
 ): DoubleMatrix {
   const endRow = startRow + subMatrix.length - 1;
   const endColumn = startColumn + subMatrix[0].length - 1;
-  checkRange(matrix, startRow, endRow, startColumn, endColumn);
+  matrixCheckRanges(matrix, { startRow, endRow, startColumn, endColumn });
   for (let i = 0; i < subMatrix.length; i++) {
     for (let j = 0; j < subMatrix[0].length; j++) {
       matrix[startRow + i][startColumn + j] = subMatrix[i][j];
     }
   }
   return matrix;
 }
-
-function checkRange(
-  matrix: DoubleMatrix,
-  startRow: number,
-  endRow: number,
-  startColumn: number,
-  endColumn: number,
-) {
-  if (
-    startRow > endRow ||
-    startColumn > endColumn ||
-    startRow < 0 ||
-    startRow >= matrix.length ||
-    endRow < 0 ||
-    endRow >= matrix.length ||
-    startColumn < 0 ||
-    startColumn >= matrix[0].length ||
-    endColumn < 0 ||
-    endColumn >= matrix[0].length
-  ) {
-    throw new RangeError('submatrix indices are out of range');
-  }
-}