core/utils/splits.js

  1. import { ValueErr, NotImplemented } from "./errors.js";
  2. //Different types of data splits can be added into this section.
  4. /**
  5.  * @namespace splits
  6.  * @description Collection of functions to be used for splitting data across HydroCompute
  7.  */
  9. export const splits = {
  10.   /**
  11.    * Splits a 1D array into N different chunks.
  12.    * @param {object} params - The parameters for splitting the array.
  13.    * @param {Array} params.data - The 1D array of data.
  14.    * @param {number} params.n - The number of chunks to create.
  15.    * @returns {Array} - An array of chunks.
  16.    */
  17.   split1DArray: ({ data: data, n: n }) => {
  18.     const chunkSize = Math.ceil(data.length / n);
  19.     const chunks = [];
  20.     for (let i = 0; i < n; i++) {
  21.       const chunk = data.slice(i * chunkSize, (i + 1) * chunkSize);
  22.       chunks.push(chunk);
  23.     }
  24.     return chunks;
  25.   },
  27.   /**
  28.    * Splits each array from a 2D matrix into N different chunks.
  29.    * @param {object} params - The parameters for splitting the matrix.
  30.    * @param {Array} params.data - The 2D matrix of data.
  31.    * @param {number} params.n - The number of chunks to create.
  32.    * @returns {Array} - An array of chunks.
  33.    */
  34.   splitmDArray: ({ data: data, n: n }) => {
  35.     if (data.length === 0 || !Array.isArray(data[0])) {
  36.       return splits.split1DArray({ data: data, n: n });
  37.     } else {
  38.       const result = [];
  39.       for (const subarray of data) {
  40.         result.push(splits.splitmDArray({ data: subarray, n: n }));
  41.       }
  42.       return result;
  43.     }
  44.   },
  46.   /**
  47.    * Splits a matrix into two submatrices.
  48.    * @param {object} params - The parameters for splitting the matrix.
  49.    * @param {Array} params.data - The matrix to split.
  50.    * @param {number} params.n - The number of rows for the first submatrix.
  51.    * @param {number} params.m - The number of columns for the first submatrix.
  52.    * @returns {Array} - An array containing the two submatrices.
  53.    */
  54.   splitMatrix: ({ data: data, n: n, m: m }) => {
  55.     const matrix1 = [];
  56.     const matrix2 = [];
  57.     for (let i = 0; i < n; i++) {
  58.       matrix1[i] = data[i].slice(0, m);
  59.       matrix2[i] = data[i].slice(m);
  60.     }
  61.     return [matrix1, matrix2];
  62.   },
  64.   /**
  65.    * Divides a matrix into submatrices.
  66.    * @param {object} params - The parameters for dividing the matrix.
  67.    * @param {Array} params.data - The matrix to divide.
  68.    * @param {number} params.k - The number of rows for each submatrix.
  69.    * @param {number} params.l - The number of columns for each submatrix.
  70.    * @returns {Array} - An array of submatrices.
  71.    */
  72.   divideIntoSubmatrices: ({ data: data, k: k, l: l }) => {
  73.     const submatrices = [];
  74.     for (var data of data)
  75.       for (let i = 0; i < data.length; i += k) {
  76.         for (let j = 0; j < data[0].length; j += l) {
  77.           submatrices.push(
  78.             data.slice(i, i + k).map((row) => row.slice(j, j + l))
  79.           );
  80.         }
  81.       }
  82.     return submatrices;
  83.   },
  85.   /**
  86.    * Joins chunks of data together.
  87.    * @param {object} params - The parameters for joining the chunks.
  88.    * @param {Array} params.chunks - An array of chunks to join.
  89.    * @returns {Array} - The joined array of chunks.
  90.    */
  91.   join: ({ chunks: chunks }) => {
  92.     let firstChunk = chunks[0].slice();
  93.     for (var i = 1; i < chunks.length; i++) {
  94.       firstChunk.push(...chunks[i]);
  95.     }
  96.     chunks = undefined;
  97.     return firstChunk;
  98.   },
  100.   /**
  101.    * Runs a specific split function based on the provided name and data.
  102.    * @param {string} name - The name of the split function to run.
  103.    * @param {*} data - The data to pass to the split function.
  104.    * @returns {*} - The result of the split function.
  105.    * @throws {NotImplemented} - If the split function is not found.
  106.    */
  107.   main: (name, data) => {
  108.     if (typeof splits[name] === "undefined") {
  109.       throw new NotImplemented(`Function is not found in the given script.`);
  110.     } else {
  111.       return splits[name](data);
  112.     }
  113.   },
  114. };