oakscriptjs 0.8.2 → 0.9.0

package/dist/cjs/matrix/index.js

@@ -0,0 +1,1200 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var matrix_exports = {};
+__export(matrix_exports, {
+  add_col: () => add_col,
+  add_row: () => add_row,
+  avg: () => avg,
+  col: () => col,
+  columns: () => columns,
+  concat: () => concat,
+  copy: () => copy,
+  det: () => det,
+  diff: () => diff,
+  eigenvalues: () => eigenvalues,
+  eigenvectors: () => eigenvectors,
+  elements_count: () => elements_count,
+  fill: () => fill,
+  get: () => get,
+  inv: () => inv,
+  is_antidiagonal: () => is_antidiagonal,
+  is_antisymmetric: () => is_antisymmetric,
+  is_binary: () => is_binary,
+  is_diagonal: () => is_diagonal,
+  is_identity: () => is_identity,
+  is_square: () => is_square,
+  is_stochastic: () => is_stochastic,
+  is_symmetric: () => is_symmetric,
+  is_triangular: () => is_triangular,
+  is_zero: () => is_zero,
+  kron: () => kron,
+  max: () => max,
+  median: () => median,
+  min: () => min,
+  mode: () => mode,
+  mult: () => mult,
+  new_matrix: () => new_matrix,
+  newtype: () => newtype,
+  pinv: () => pinv,
+  pow: () => pow,
+  rank: () => rank,
+  remove_col: () => remove_col,
+  remove_row: () => remove_row,
+  reshape: () => reshape,
+  reverse: () => reverse,
+  row: () => row,
+  rows: () => rows,
+  set: () => set,
+  sort: () => sort,
+  submatrix: () => submatrix,
+  sum: () => sum,
+  swap_columns: () => swap_columns,
+  swap_rows: () => swap_rows,
+  trace: () => trace,
+  transpose: () => transpose
+});
+module.exports = __toCommonJS(matrix_exports);
+function new_matrix(rows2, columns2, initial_value) {
+  const data = [];
+  for (let i = 0; i < rows2; i++) {
+    const row2 = [];
+    for (let j = 0; j < columns2; j++) {
+      row2.push(initial_value);
+    }
+    data.push(row2);
+  }
+  return { rows: rows2, columns: columns2, data };
+}
+function get(id, row2, column) {
+  if (row2 < 0 || row2 >= id.rows || column < 0 || column >= id.columns) {
+    throw new Error(`Matrix index out of bounds: [${row2}, ${column}] for matrix of size [${id.rows}, ${id.columns}]`);
+  }
+  return id.data[row2][column];
+}
+function set(id, row2, column, value) {
+  if (row2 < 0 || row2 >= id.rows || column < 0 || column >= id.columns) {
+    throw new Error(`Matrix index out of bounds: [${row2}, ${column}] for matrix of size [${id.rows}, ${id.columns}]`);
+  }
+  id.data[row2][column] = value;
+}
+function rows(id) {
+  return id.rows;
+}
+function columns(id) {
+  return id.columns;
+}
+function elements_count(id) {
+  return id.rows * id.columns;
+}
+function row(id, row_index) {
+  if (row_index < 0 || row_index >= id.rows) {
+    throw new Error(`Row index out of bounds: ${row_index} for matrix with ${id.rows} rows`);
+  }
+  return [...id.data[row_index]];
+}
+function col(id, column_index) {
+  if (column_index < 0 || column_index >= id.columns) {
+    throw new Error(`Column index out of bounds: ${column_index} for matrix with ${id.columns} columns`);
+  }
+  return id.data.map((r) => r[column_index]);
+}
+function copy(id) {
+  const newData = id.data.map((r) => [...r]);
+  return {
+    rows: id.rows,
+    columns: id.columns,
+    data: newData
+  };
+}
+function fill(id, value, from_row = 0, to_row, from_column = 0, to_column) {
+  const endRow = to_row ?? id.rows;
+  const endCol = to_column ?? id.columns;
+  for (let i = from_row; i < endRow; i++) {
+    for (let j = from_column; j < endCol; j++) {
+      id.data[i][j] = value;
+    }
+  }
+}
+function is_square(id) {
+  return id.rows === id.columns;
+}
+function is_zero(id) {
+  for (let i = 0; i < id.rows; i++) {
+    for (let j = 0; j < id.columns; j++) {
+      if (id.data[i][j] !== 0) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function is_binary(id) {
+  for (let i = 0; i < id.rows; i++) {
+    for (let j = 0; j < id.columns; j++) {
+      const val = id.data[i][j];
+      if (val !== 0 && val !== 1) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function add_row(id, row2, array_id) {
+  const insertIndex = row2 ?? id.rows;
+  if (insertIndex < 0 || insertIndex > id.rows) {
+    throw new Error(`Row index out of bounds: ${insertIndex} for matrix with ${id.rows} rows`);
+  }
+  let newRow;
+  if (array_id !== void 0) {
+    if (id.columns > 0 && array_id.length !== id.columns) {
+      throw new Error(`Array size ${array_id.length} does not match matrix columns ${id.columns}`);
+    }
+    newRow = [...array_id];
+    if (id.rows === 0 && id.columns === 0) {
+      id.columns = array_id.length;
+    }
+  } else {
+    newRow = new Array(id.columns).fill(void 0);
+  }
+  id.data.splice(insertIndex, 0, newRow);
+  id.rows++;
+}
+function add_col(id, column, array_id) {
+  const insertIndex = column ?? id.columns;
+  if (insertIndex < 0 || insertIndex > id.columns) {
+    throw new Error(`Column index out of bounds: ${insertIndex} for matrix with ${id.columns} columns`);
+  }
+  if (array_id !== void 0) {
+    if (id.rows > 0 && array_id.length !== id.rows) {
+      throw new Error(`Array size ${array_id.length} does not match matrix rows ${id.rows}`);
+    }
+    if (id.rows === 0 && id.columns === 0) {
+      id.rows = array_id.length;
+      for (let i = 0; i < array_id.length; i++) {
+        id.data.push([]);
+      }
+    }
+    for (let i = 0; i < id.rows; i++) {
+      id.data[i].splice(insertIndex, 0, array_id[i]);
+    }
+  } else {
+    for (let i = 0; i < id.rows; i++) {
+      id.data[i].splice(insertIndex, 0, void 0);
+    }
+  }
+  id.columns++;
+}
+function remove_row(id, row2) {
+  const removeIndex = row2 ?? id.rows - 1;
+  if (removeIndex < 0 || removeIndex >= id.rows) {
+    throw new Error(`Row index out of bounds: ${removeIndex} for matrix with ${id.rows} rows`);
+  }
+  const removedRow = id.data.splice(removeIndex, 1)[0];
+  id.rows--;
+  return removedRow;
+}
+function remove_col(id, column) {
+  const removeIndex = column ?? id.columns - 1;
+  if (removeIndex < 0 || removeIndex >= id.columns) {
+    throw new Error(`Column index out of bounds: ${removeIndex} for matrix with ${id.columns} columns`);
+  }
+  const removedCol = [];
+  for (let i = 0; i < id.rows; i++) {
+    removedCol.push(id.data[i].splice(removeIndex, 1)[0]);
+  }
+  id.columns--;
+  return removedCol;
+}
+function swap_rows(id, row1, row2) {
+  if (row1 < 0 || row1 >= id.rows) {
+    throw new Error(`Row1 index out of bounds: ${row1} for matrix with ${id.rows} rows`);
+  }
+  if (row2 < 0 || row2 >= id.rows) {
+    throw new Error(`Row2 index out of bounds: ${row2} for matrix with ${id.rows} rows`);
+  }
+  const temp = id.data[row1];
+  id.data[row1] = id.data[row2];
+  id.data[row2] = temp;
+}
+function swap_columns(id, column1, column2) {
+  if (column1 < 0 || column1 >= id.columns) {
+    throw new Error(`Column1 index out of bounds: ${column1} for matrix with ${id.columns} columns`);
+  }
+  if (column2 < 0 || column2 >= id.columns) {
+    throw new Error(`Column2 index out of bounds: ${column2} for matrix with ${id.columns} columns`);
+  }
+  for (let i = 0; i < id.rows; i++) {
+    const temp = id.data[i][column1];
+    id.data[i][column1] = id.data[i][column2];
+    id.data[i][column2] = temp;
+  }
+}
+function transpose(id) {
+  const newData = [];
+  for (let j = 0; j < id.columns; j++) {
+    const newRow = [];
+    for (let i = 0; i < id.rows; i++) {
+      newRow.push(id.data[i][j]);
+    }
+    newData.push(newRow);
+  }
+  return {
+    rows: id.columns,
+    columns: id.rows,
+    data: newData
+  };
+}
+function concat(id1, id2) {
+  if (id1.columns !== id2.columns) {
+    throw new Error(`Column count mismatch: ${id1.columns} vs ${id2.columns}`);
+  }
+  for (let i = 0; i < id2.rows; i++) {
+    id1.data.push([...id2.data[i]]);
+  }
+  id1.rows += id2.rows;
+  return id1;
+}
+function submatrix(id, from_row = 0, to_row, from_column = 0, to_column) {
+  const endRow = to_row ?? id.rows;
+  const endCol = to_column ?? id.columns;
+  if (from_row < 0 || from_row > id.rows) {
+    throw new Error(`from_row index out of bounds: ${from_row}`);
+  }
+  if (endRow < 0 || endRow > id.rows) {
+    throw new Error(`to_row index out of bounds: ${endRow}`);
+  }
+  if (from_column < 0 || from_column > id.columns) {
+    throw new Error(`from_column index out of bounds: ${from_column}`);
+  }
+  if (endCol < 0 || endCol > id.columns) {
+    throw new Error(`to_column index out of bounds: ${endCol}`);
+  }
+  const newRows = endRow - from_row;
+  const newCols = endCol - from_column;
+  const newData = [];
+  for (let i = from_row; i < endRow; i++) {
+    const newRow = [];
+    for (let j = from_column; j < endCol; j++) {
+      newRow.push(id.data[i][j]);
+    }
+    newData.push(newRow);
+  }
+  return {
+    rows: newRows,
+    columns: newCols,
+    data: newData
+  };
+}
+function reshape(id, rows2, columns2) {
+  const totalElements = id.rows * id.columns;
+  const newTotalElements = rows2 * columns2;
+  if (totalElements !== newTotalElements) {
+    throw new Error(`Cannot reshape ${id.rows}x${id.columns} (${totalElements} elements) to ${rows2}x${columns2} (${newTotalElements} elements)`);
+  }
+  const flat = [];
+  for (let i = 0; i < id.rows; i++) {
+    for (let j = 0; j < id.columns; j++) {
+      flat.push(id.data[i][j]);
+    }
+  }
+  const newData = [];
+  let index = 0;
+  for (let i = 0; i < rows2; i++) {
+    const newRow = [];
+    for (let j = 0; j < columns2; j++) {
+      newRow.push(flat[index++]);
+    }
+    newData.push(newRow);
+  }
+  id.rows = rows2;
+  id.columns = columns2;
+  id.data = newData;
+}
+function reverse(id) {
+  id.data.reverse();
+  for (let i = 0; i < id.rows; i++) {
+    id.data[i].reverse();
+  }
+}
+function sort(id, column = 0, order = "ascending") {
+  if (column < 0 || column >= id.columns) {
+    throw new Error(`Column index out of bounds: ${column} for matrix with ${id.columns} columns`);
+  }
+  id.data.sort((a, b) => {
+    const valA = a[column];
+    const valB = b[column];
+    if (typeof valA === "number" && typeof valB === "number") {
+      return order === "ascending" ? valA - valB : valB - valA;
+    }
+    if (order === "ascending") {
+      return valA < valB ? -1 : valA > valB ? 1 : 0;
+    } else {
+      return valB < valA ? -1 : valB > valA ? 1 : 0;
+    }
+  });
+}
+function sum(id1, id2) {
+  const newData = [];
+  if (typeof id2 === "number") {
+    for (let i = 0; i < id1.rows; i++) {
+      const newRow = [];
+      for (let j = 0; j < id1.columns; j++) {
+        newRow.push(id1.data[i][j] + id2);
+      }
+      newData.push(newRow);
+    }
+    return {
+      rows: id1.rows,
+      columns: id1.columns,
+      data: newData
+    };
+  } else {
+    if (id1.rows !== id2.rows || id1.columns !== id2.columns) {
+      throw new Error(`Matrix dimensions must match: ${id1.rows}x${id1.columns} vs ${id2.rows}x${id2.columns}`);
+    }
+    for (let i = 0; i < id1.rows; i++) {
+      const newRow = [];
+      for (let j = 0; j < id1.columns; j++) {
+        newRow.push(id1.data[i][j] + id2.data[i][j]);
+      }
+      newData.push(newRow);
+    }
+    return {
+      rows: id1.rows,
+      columns: id1.columns,
+      data: newData
+    };
+  }
+}
+function diff(id1, id2) {
+  const newData = [];
+  if (typeof id2 === "number") {
+    for (let i = 0; i < id1.rows; i++) {
+      const newRow = [];
+      for (let j = 0; j < id1.columns; j++) {
+        newRow.push(id1.data[i][j] - id2);
+      }
+      newData.push(newRow);
+    }
+    return {
+      rows: id1.rows,
+      columns: id1.columns,
+      data: newData
+    };
+  } else {
+    if (id1.rows !== id2.rows || id1.columns !== id2.columns) {
+      throw new Error(`Matrix dimensions must match: ${id1.rows}x${id1.columns} vs ${id2.rows}x${id2.columns}`);
+    }
+    for (let i = 0; i < id1.rows; i++) {
+      const newRow = [];
+      for (let j = 0; j < id1.columns; j++) {
+        newRow.push(id1.data[i][j] - id2.data[i][j]);
+      }
+      newData.push(newRow);
+    }
+    return {
+      rows: id1.rows,
+      columns: id1.columns,
+      data: newData
+    };
+  }
+}
+function avg(id) {
+  if (id.rows === 0 || id.columns === 0) {
+    return NaN;
+  }
+  let total = 0;
+  let count = 0;
+  for (let i = 0; i < id.rows; i++) {
+    for (let j = 0; j < id.columns; j++) {
+      const val = id.data[i][j];
+      if (val !== null && val !== void 0 && !isNaN(val)) {
+        total += val;
+        count++;
+      }
+    }
+  }
+  return count === 0 ? NaN : total / count;
+}
+function min(id) {
+  if (id.rows === 0 || id.columns === 0) {
+    return NaN;
+  }
+  let minVal = Infinity;
+  for (let i = 0; i < id.rows; i++) {
+    for (let j = 0; j < id.columns; j++) {
+      const val = id.data[i][j];
+      if (val !== null && val !== void 0 && !isNaN(val) && val < minVal) {
+        minVal = val;
+      }
+    }
+  }
+  return minVal === Infinity ? NaN : minVal;
+}
+function max(id) {
+  if (id.rows === 0 || id.columns === 0) {
+    return NaN;
+  }
+  let maxVal = -Infinity;
+  for (let i = 0; i < id.rows; i++) {
+    for (let j = 0; j < id.columns; j++) {
+      const val = id.data[i][j];
+      if (val !== null && val !== void 0 && !isNaN(val) && val > maxVal) {
+        maxVal = val;
+      }
+    }
+  }
+  return maxVal === -Infinity ? NaN : maxVal;
+}
+function median(id) {
+  if (id.rows === 0 || id.columns === 0) {
+    return NaN;
+  }
+  const values = [];
+  for (let i = 0; i < id.rows; i++) {
+    for (let j = 0; j < id.columns; j++) {
+      const val = id.data[i][j];
+      if (val !== null && val !== void 0 && !isNaN(val)) {
+        values.push(val);
+      }
+    }
+  }
+  if (values.length === 0) {
+    return NaN;
+  }
+  values.sort((a, b) => a - b);
+  const mid = Math.floor(values.length / 2);
+  if (values.length % 2 === 0) {
+    return (values[mid - 1] + values[mid]) / 2;
+  } else {
+    return values[mid];
+  }
+}
+function mode(id) {
+  if (id.rows === 0 || id.columns === 0) {
+    return NaN;
+  }
+  const frequency = /* @__PURE__ */ new Map();
+  let maxFreq = 0;
+  let modeValue = NaN;
+  for (let i = 0; i < id.rows; i++) {
+    for (let j = 0; j < id.columns; j++) {
+      const val = id.data[i][j];
+      if (val !== null && val !== void 0 && !isNaN(val)) {
+        const freq = (frequency.get(val) || 0) + 1;
+        frequency.set(val, freq);
+        if (freq > maxFreq || freq === maxFreq && val < modeValue) {
+          maxFreq = freq;
+          modeValue = val;
+        }
+      }
+    }
+  }
+  return modeValue;
+}
+function trace(id) {
+  if (!is_square(id)) {
+    throw new Error(`Matrix must be square for trace calculation: ${id.rows}x${id.columns}`);
+  }
+  if (id.rows === 0) {
+    return 0;
+  }
+  let sum2 = 0;
+  for (let i = 0; i < id.rows; i++) {
+    const val = id.data[i][i];
+    if (val !== null && val !== void 0 && !isNaN(val)) {
+      sum2 += val;
+    }
+  }
+  return sum2;
+}
+function is_diagonal(id) {
+  if (!is_square(id)) {
+    return false;
+  }
+  for (let i = 0; i < id.rows; i++) {
+    for (let j = 0; j < id.columns; j++) {
+      if (i !== j && id.data[i][j] !== 0) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function is_identity(id) {
+  if (!is_square(id)) {
+    return false;
+  }
+  for (let i = 0; i < id.rows; i++) {
+    for (let j = 0; j < id.columns; j++) {
+      const val = id.data[i][j];
+      if (i === j) {
+        if (val !== 1) {
+          return false;
+        }
+      } else {
+        if (val !== 0) {
+          return false;
+        }
+      }
+    }
+  }
+  return true;
+}
+function is_symmetric(id) {
+  if (!is_square(id)) {
+    return false;
+  }
+  for (let i = 0; i < id.rows; i++) {
+    for (let j = i + 1; j < id.columns; j++) {
+      if (id.data[i][j] !== id.data[j][i]) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function is_antisymmetric(id) {
+  if (!is_square(id)) {
+    return false;
+  }
+  for (let i = 0; i < id.rows; i++) {
+    if (id.data[i][i] !== 0) {
+      return false;
+    }
+    for (let j = i + 1; j < id.columns; j++) {
+      const upperVal = id.data[i][j];
+      const lowerVal = id.data[j][i];
+      if (upperVal !== -lowerVal) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function is_triangular(id) {
+  if (!is_square(id)) {
+    return false;
+  }
+  let isUpper = true;
+  for (let i = 1; i < id.rows && isUpper; i++) {
+    for (let j = 0; j < i && isUpper; j++) {
+      if (id.data[i][j] !== 0) {
+        isUpper = false;
+      }
+    }
+  }
+  if (isUpper) {
+    return true;
+  }
+  let isLower = true;
+  for (let i = 0; i < id.rows - 1 && isLower; i++) {
+    for (let j = i + 1; j < id.columns && isLower; j++) {
+      if (id.data[i][j] !== 0) {
+        isLower = false;
+      }
+    }
+  }
+  return isLower;
+}
+function is_antidiagonal(id) {
+  if (!is_square(id)) {
+    return false;
+  }
+  const n = id.rows;
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < n; j++) {
+      const isAntiDiag = i + j === n - 1;
+      if (!isAntiDiag && id.data[i][j] !== 0) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function is_stochastic(id) {
+  if (id.rows === 0 || id.columns === 0) {
+    return false;
+  }
+  const tolerance = 1e-10;
+  for (let i = 0; i < id.rows; i++) {
+    let rowSum = 0;
+    for (let j = 0; j < id.columns; j++) {
+      const val = id.data[i][j];
+      if (val < 0) {
+        return false;
+      }
+      rowSum += val;
+    }
+    if (Math.abs(rowSum - 1) > tolerance) {
+      return false;
+    }
+  }
+  return true;
+}
+const EPSILON = 1e-10;
+function createIdentity(n) {
+  const m = new_matrix(n, n, 0);
+  for (let i = 0; i < n; i++) {
+    m.data[i][i] = 1;
+  }
+  return m;
+}
+function mult(id1, id2) {
+  if (typeof id2 === "number") {
+    const newData2 = [];
+    for (let i = 0; i < id1.rows; i++) {
+      const newRow = [];
+      for (let j = 0; j < id1.columns; j++) {
+        newRow.push(id1.data[i][j] * id2);
+      }
+      newData2.push(newRow);
+    }
+    return {
+      rows: id1.rows,
+      columns: id1.columns,
+      data: newData2
+    };
+  }
+  if (Array.isArray(id2) && !("rows" in id2)) {
+    const vec = id2;
+    if (vec.length !== id1.columns) {
+      throw new Error(`Vector length ${vec.length} must equal matrix columns ${id1.columns}`);
+    }
+    const result = [];
+    for (let i = 0; i < id1.rows; i++) {
+      let sum2 = 0;
+      for (let j = 0; j < id1.columns; j++) {
+        sum2 += id1.data[i][j] * vec[j];
+      }
+      result.push(sum2);
+    }
+    return result;
+  }
+  const m2 = id2;
+  if (id1.columns !== m2.rows) {
+    throw new Error(`Matrix multiplication dimension mismatch: ${id1.rows}x${id1.columns} \xD7 ${m2.rows}x${m2.columns}. First matrix columns (${id1.columns}) must equal second matrix rows (${m2.rows})`);
+  }
+  const newRows = id1.rows;
+  const newCols = m2.columns;
+  const newData = [];
+  for (let i = 0; i < newRows; i++) {
+    const newRow = [];
+    for (let j = 0; j < newCols; j++) {
+      let sum2 = 0;
+      for (let k = 0; k < id1.columns; k++) {
+        sum2 += id1.data[i][k] * m2.data[k][j];
+      }
+      newRow.push(sum2);
+    }
+    newData.push(newRow);
+  }
+  return {
+    rows: newRows,
+    columns: newCols,
+    data: newData
+  };
+}
+function pow(id, power) {
+  if (!is_square(id)) {
+    throw new Error(`Matrix must be square for power calculation: ${id.rows}x${id.columns}`);
+  }
+  const n = id.rows;
+  if (power === 0) {
+    return createIdentity(n);
+  }
+  let base;
+  let p = power;
+  if (power < 0) {
+    const inverse = inv(id);
+    if (inverse === null) {
+      throw new Error("Cannot compute negative power of singular matrix");
+    }
+    base = inverse;
+    p = -power;
+  } else {
+    base = copy(id);
+  }
+  let result = createIdentity(n);
+  while (p > 0) {
+    if (p % 2 === 1) {
+      result = mult(result, base);
+    }
+    base = mult(base, base);
+    p = Math.floor(p / 2);
+  }
+  return result;
+}
+function det(id) {
+  if (!is_square(id)) {
+    throw new Error(`Matrix must be square for determinant calculation: ${id.rows}x${id.columns}`);
+  }
+  const n = id.rows;
+  if (n === 0) {
+    return 1;
+  }
+  if (n === 1) {
+    return id.data[0][0];
+  }
+  if (n === 2) {
+    return id.data[0][0] * id.data[1][1] - id.data[0][1] * id.data[1][0];
+  }
+  const a = id.data.map((row2) => [...row2]);
+  let determinant = 1;
+  let swapCount = 0;
+  for (let col2 = 0; col2 < n; col2++) {
+    let maxRow = col2;
+    let maxVal = Math.abs(a[col2][col2]);
+    for (let row2 = col2 + 1; row2 < n; row2++) {
+      const absVal = Math.abs(a[row2][col2]);
+      if (absVal > maxVal) {
+        maxVal = absVal;
+        maxRow = row2;
+      }
+    }
+    if (maxRow !== col2) {
+      const temp = a[col2];
+      a[col2] = a[maxRow];
+      a[maxRow] = temp;
+      swapCount++;
+    }
+    const pivot = a[col2][col2];
+    if (Math.abs(pivot) < EPSILON) {
+      return 0;
+    }
+    determinant *= pivot;
+    for (let row2 = col2 + 1; row2 < n; row2++) {
+      const factor = a[row2][col2] / pivot;
+      for (let j = col2; j < n; j++) {
+        a[row2][j] = a[row2][j] - factor * a[col2][j];
+      }
+    }
+  }
+  if (swapCount % 2 === 1) {
+    determinant = -determinant;
+  }
+  return determinant;
+}
+function inv(id) {
+  if (!is_square(id)) {
+    throw new Error(`Matrix must be square for inverse calculation: ${id.rows}x${id.columns}`);
+  }
+  const n = id.rows;
+  if (n === 0) {
+    return new_matrix(0, 0, 0);
+  }
+  const aug = [];
+  for (let i = 0; i < n; i++) {
+    const row2 = [];
+    for (let j = 0; j < n; j++) {
+      row2.push(id.data[i][j]);
+    }
+    for (let j = 0; j < n; j++) {
+      row2.push(i === j ? 1 : 0);
+    }
+    aug.push(row2);
+  }
+  for (let col2 = 0; col2 < n; col2++) {
+    let maxRow = col2;
+    let maxVal = Math.abs(aug[col2][col2]);
+    for (let row2 = col2 + 1; row2 < n; row2++) {
+      const absVal = Math.abs(aug[row2][col2]);
+      if (absVal > maxVal) {
+        maxVal = absVal;
+        maxRow = row2;
+      }
+    }
+    if (maxRow !== col2) {
+      const temp = aug[col2];
+      aug[col2] = aug[maxRow];
+      aug[maxRow] = temp;
+    }
+    const pivot = aug[col2][col2];
+    if (Math.abs(pivot) < EPSILON) {
+      return null;
+    }
+    for (let j = 0; j < 2 * n; j++) {
+      aug[col2][j] = aug[col2][j] / pivot;
+    }
+    for (let row2 = 0; row2 < n; row2++) {
+      if (row2 !== col2) {
+        const factor = aug[row2][col2];
+        for (let j = 0; j < 2 * n; j++) {
+          aug[row2][j] = aug[row2][j] - factor * aug[col2][j];
+        }
+      }
+    }
+  }
+  const inverse = [];
+  for (let i = 0; i < n; i++) {
+    const row2 = [];
+    for (let j = 0; j < n; j++) {
+      row2.push(aug[i][n + j]);
+    }
+    inverse.push(row2);
+  }
+  return {
+    rows: n,
+    columns: n,
+    data: inverse
+  };
+}
+function pinv(id) {
+  const m = id.rows;
+  const n = id.columns;
+  if (m === 0 || n === 0) {
+    return new_matrix(n, m, 0);
+  }
+  if (m === n) {
+    const inverse = inv(id);
+    if (inverse !== null) {
+      return inverse;
+    }
+  }
+  const At = transpose(id);
+  if (m >= n) {
+    const AtA2 = mult(At, id);
+    const AtA_inv2 = inv(AtA2);
+    if (AtA_inv2 !== null) {
+      return mult(AtA_inv2, At);
+    }
+  }
+  const AAt = mult(id, At);
+  const AAt_inv = inv(AAt);
+  if (AAt_inv !== null) {
+    return mult(At, AAt_inv);
+  }
+  const lambda = 1e-10;
+  const AtA = mult(At, id);
+  for (let i = 0; i < AtA.rows; i++) {
+    AtA.data[i][i] = AtA.data[i][i] + lambda;
+  }
+  const AtA_inv = inv(AtA);
+  if (AtA_inv !== null) {
+    return mult(AtA_inv, At);
+  }
+  return new_matrix(n, m, 0);
+}
+function rank(id) {
+  if (id.rows === 0 || id.columns === 0) {
+    return 0;
+  }
+  const a = id.data.map((row2) => [...row2]);
+  const m = id.rows;
+  const n = id.columns;
+  let r = 0;
+  for (let col2 = 0; col2 < n && r < m; col2++) {
+    let maxRow = r;
+    let maxVal = Math.abs(a[r][col2]);
+    for (let row2 = r + 1; row2 < m; row2++) {
+      const absVal = Math.abs(a[row2][col2]);
+      if (absVal > maxVal) {
+        maxVal = absVal;
+        maxRow = row2;
+      }
+    }
+    if (maxVal < EPSILON) {
+      continue;
+    }
+    if (maxRow !== r) {
+      const temp = a[r];
+      a[r] = a[maxRow];
+      a[maxRow] = temp;
+    }
+    const pivot = a[r][col2];
+    for (let row2 = r + 1; row2 < m; row2++) {
+      const factor = a[row2][col2] / pivot;
+      for (let j = col2; j < n; j++) {
+        a[row2][j] = a[row2][j] - factor * a[r][j];
+      }
+    }
+    r++;
+  }
+  return r;
+}
+function eigenvalues(id) {
+  if (!is_square(id)) {
+    throw new Error(`Matrix must be square for eigenvalue calculation: ${id.rows}x${id.columns}`);
+  }
+  const n = id.rows;
+  if (n === 0) {
+    return [];
+  }
+  if (n === 1) {
+    return [id.data[0][0]];
+  }
+  if (n === 2) {
+    const a = id.data[0][0];
+    const b = id.data[0][1];
+    const c = id.data[1][0];
+    const d = id.data[1][1];
+    const trace2 = a + d;
+    const determinant = a * d - b * c;
+    const discriminant = trace2 * trace2 - 4 * determinant;
+    if (discriminant >= 0) {
+      const sqrtDisc = Math.sqrt(discriminant);
+      return [(trace2 + sqrtDisc) / 2, (trace2 - sqrtDisc) / 2];
+    } else {
+      return [trace2 / 2, trace2 / 2];
+    }
+  }
+  const h = toHessenberg(id);
+  const result = qrAlgorithm(h, 100);
+  return result;
+}
+function toHessenberg(m) {
+  const n = m.rows;
+  const h = m.data.map((row2) => [...row2]);
+  for (let k = 0; k < n - 2; k++) {
+    let maxVal = 0;
+    for (let i = k + 1; i < n; i++) {
+      maxVal = Math.max(maxVal, Math.abs(h[i][k]));
+    }
+    if (maxVal < EPSILON) continue;
+    let sigma = 0;
+    for (let i = k + 1; i < n; i++) {
+      sigma += h[i][k] * h[i][k];
+    }
+    sigma = Math.sqrt(sigma);
+    if (h[k + 1][k] < 0) sigma = -sigma;
+    const u = new Array(n).fill(0);
+    u[k + 1] = h[k + 1][k] + sigma;
+    for (let i = k + 2; i < n; i++) {
+      u[i] = h[i][k];
+    }
+    let uTu = 0;
+    for (let i = k + 1; i < n; i++) {
+      uTu += u[i] * u[i];
+    }
+    if (uTu < EPSILON) continue;
+    for (let j = k; j < n; j++) {
+      let dot = 0;
+      for (let i = k + 1; i < n; i++) {
+        dot += u[i] * h[i][j];
+      }
+      const factor = 2 * dot / uTu;
+      for (let i = k + 1; i < n; i++) {
+        h[i][j] = h[i][j] - factor * u[i];
+      }
+    }
+    for (let i = 0; i < n; i++) {
+      let dot = 0;
+      for (let j = k + 1; j < n; j++) {
+        dot += h[i][j] * u[j];
+      }
+      const factor = 2 * dot / uTu;
+      for (let j = k + 1; j < n; j++) {
+        h[i][j] = h[i][j] - factor * u[j];
+      }
+    }
+  }
+  return { rows: n, columns: n, data: h };
+}
+function qrAlgorithm(h, maxIter) {
+  const n = h.rows;
+  const a = h.data.map((row2) => [...row2]);
+  const eigenvals = [];
+  let remaining = n;
+  for (let iter = 0; iter < maxIter && remaining > 1; iter++) {
+    let converged = false;
+    for (let i = remaining - 1; i >= 1; i--) {
+      if (Math.abs(a[i][i - 1]) < EPSILON * (Math.abs(a[i - 1][i - 1]) + Math.abs(a[i][i]))) {
+        a[i][i - 1] = 0;
+        if (i === remaining - 1) {
+          eigenvals.push(a[remaining - 1][remaining - 1]);
+          remaining--;
+          converged = true;
+          break;
+        }
+      }
+    }
+    if (converged) continue;
+    if (remaining <= 1) break;
+    const d = (a[remaining - 2][remaining - 2] - a[remaining - 1][remaining - 1]) / 2;
+    const sign = d >= 0 ? 1 : -1;
+    const mu = a[remaining - 1][remaining - 1] - sign * a[remaining - 1][remaining - 2] * a[remaining - 1][remaining - 2] / (Math.abs(d) + Math.sqrt(d * d + a[remaining - 1][remaining - 2] * a[remaining - 1][remaining - 2]));
+    let x = a[0][0] - mu;
+    let z = a[1][0];
+    for (let k = 0; k < remaining - 1; k++) {
+      let r = Math.sqrt(x * x + z * z);
+      if (r < EPSILON) {
+        r = EPSILON;
+      }
+      const c = x / r;
+      const s = z / r;
+      for (let j = Math.max(0, k - 1); j < remaining; j++) {
+        const temp = c * a[k][j] + s * a[k + 1][j];
+        a[k + 1][j] = -s * a[k][j] + c * a[k + 1][j];
+        a[k][j] = temp;
+      }
+      for (let i = 0; i < Math.min(k + 3, remaining); i++) {
+        const temp = c * a[i][k] + s * a[i][k + 1];
+        a[i][k + 1] = -s * a[i][k] + c * a[i][k + 1];
+        a[i][k] = temp;
+      }
+      if (k < remaining - 2) {
+        x = a[k + 1][k];
+        z = a[k + 2][k];
+      }
+    }
+  }
+  for (let i = 0; i < remaining; i++) {
+    eigenvals.push(a[i][i]);
+  }
+  eigenvals.sort((a2, b) => Math.abs(b) - Math.abs(a2));
+  return eigenvals;
+}
+function eigenvectors(id) {
+  if (!is_square(id)) {
+    throw new Error(`Matrix must be square for eigenvector calculation: ${id.rows}x${id.columns}`);
+  }
+  const n = id.rows;
+  if (n === 0) {
+    return new_matrix(0, 0, 0);
+  }
+  const evals = eigenvalues(id);
+  const vectors = [];
+  for (let i = 0; i < n; i++) {
+    const lambda = evals[i];
+    const vec = inverseIteration(id, lambda);
+    vectors.push(vec);
+  }
+  const result = [];
+  for (let i = 0; i < n; i++) {
+    const row2 = [];
+    for (let j = 0; j < n; j++) {
+      row2.push(vectors[j][i]);
+    }
+    result.push(row2);
+  }
+  return {
+    rows: n,
+    columns: n,
+    data: result
+  };
+}
+function inverseIteration(m, lambda) {
+  const n = m.rows;
+  const shifted = m.data.map(
+    (row2, i) => row2.map((val, j) => i === j ? val - lambda : val)
+  );
+  for (let i = 0; i < n; i++) {
+    if (Math.abs(shifted[i][i]) < EPSILON) {
+      shifted[i][i] = EPSILON;
+    }
+  }
+  let v = new Array(n).fill(1);
+  for (let iter = 0; iter < 50; iter++) {
+    const w = solveLinearSystem(shifted, v);
+    let norm = 0;
+    for (let i = 0; i < n; i++) {
+      norm += w[i] * w[i];
+    }
+    norm = Math.sqrt(norm);
+    if (norm < EPSILON) {
+      return v;
+    }
+    const newV = [];
+    for (let i = 0; i < n; i++) {
+      newV.push(w[i] / norm);
+    }
+    let diff2 = 0;
+    for (let i = 0; i < n; i++) {
+      diff2 += Math.abs(Math.abs(newV[i]) - Math.abs(v[i]));
+    }
+    v = newV;
+    if (diff2 < EPSILON) {
+      break;
+    }
+  }
+  return v;
+}
+function solveLinearSystem(a, b) {
+  const n = a.length;
+  const aug = a.map((row2, i) => [...row2, b[i]]);
+  for (let col2 = 0; col2 < n; col2++) {
+    let maxRow = col2;
+    let maxVal = Math.abs(aug[col2][col2]);
+    for (let row2 = col2 + 1; row2 < n; row2++) {
+      const absVal = Math.abs(aug[row2][col2]);
+      if (absVal > maxVal) {
+        maxVal = absVal;
+        maxRow = row2;
+      }
+    }
+    if (maxRow !== col2) {
+      const temp = aug[col2];
+      aug[col2] = aug[maxRow];
+      aug[maxRow] = temp;
+    }
+    const pivot = aug[col2][col2];
+    if (Math.abs(pivot) < EPSILON) {
+      continue;
+    }
+    for (let row2 = col2 + 1; row2 < n; row2++) {
+      const factor = aug[row2][col2] / pivot;
+      for (let j = col2; j <= n; j++) {
+        aug[row2][j] = aug[row2][j] - factor * aug[col2][j];
+      }
+    }
+  }
+  const x = new Array(n).fill(0);
+  for (let i = n - 1; i >= 0; i--) {
+    let sum2 = aug[i][n];
+    for (let j = i + 1; j < n; j++) {
+      sum2 -= aug[i][j] * x[j];
+    }
+    const diag = aug[i][i];
+    x[i] = Math.abs(diag) < EPSILON ? 0 : sum2 / diag;
+  }
+  return x;
+}
+function kron(id1, id2) {
+  const m1 = id1.rows;
+  const n1 = id1.columns;
+  const m2 = id2.rows;
+  const n2 = id2.columns;
+  const resultRows = m1 * m2;
+  const resultCols = n1 * n2;
+  const data = [];
+  for (let i = 0; i < resultRows; i++) {
+    data.push(new Array(resultCols).fill(0));
+  }
+  for (let i1 = 0; i1 < m1; i1++) {
+    for (let j1 = 0; j1 < n1; j1++) {
+      const a = id1.data[i1][j1];
+      for (let i2 = 0; i2 < m2; i2++) {
+        for (let j2 = 0; j2 < n2; j2++) {
+          const row2 = i1 * m2 + i2;
+          const col2 = j1 * n2 + j2;
+          data[row2][col2] = a * id2.data[i2][j2];
+        }
+      }
+    }
+  }
+  return {
+    rows: resultRows,
+    columns: resultCols,
+    data
+  };
+}
+function newtype(rows2 = 0, columns2 = 0, initial_value) {
+  return new_matrix(rows2, columns2, initial_value);
+}
+//# sourceMappingURL=index.js.map