@danielsimonjr/mathts-functions 0.42.0 → 0.43.1

package/dist/index.js

@@ -189,7 +189,7 @@ __export(typed_exports, {
   findRoot: () => findRoot,
   fix: () => fix,
   floor: () => floor,
-  format: () => format4,
+  format: () => format2,
   fourier: () => fourier,
   fresnelC: () => fresnelC,
   fresnelS: () => fresnelS,
@@ -517,6 +517,12 @@ import {
   pairwiseDot,
   sumSquaredDeviations
 } from "@danielsimonjr/mathts-core";
+import {
+  pow as corePow,
+  round as coreRound,
+  fix as coreFix,
+  equal as coreEqual
+} from "@danielsimonjr/mathts-core";
 import { DenseMatrix as DenseMatrix2, backendManager as backendManager2, singularValues } from "@danielsimonjr/mathts-matrix";
 
 // src/factories/matrix-bridge.ts
@@ -837,7 +843,7 @@ var MathJSDenseMatrix = class _MathJSDenseMatrix {
   }
   // ---------------------------------------------------------------------------
   // Accelerated operations — routed through the native matrix BackendManager
-  // (JS / WASM / GPU selected by size). Additive: the synced factory
+  // (JS / WASM / GPU selected by size). Additive: the activated factory
   // `multiply`/`transpose` functions are unaffected.
   // ---------------------------------------------------------------------------
   /**
@@ -1655,13 +1661,19 @@ var sign = mathTyped2("sign", {
   }
 });
 var pow = mathTyped2("pow", {
+  // Hot cases stay inline.
   "number, number": (a, b) => Math.pow(a, b),
   "bigint, bigint": (a, b) => a ** b,
-  "Complex, number": (a, b) => a.pow(b),
-  "Complex, Complex": (a, b) => a.pow(b),
-  "Fraction, number": (a, b) => a.pow(Math.floor(b)),
-  "BigNumber, number": (a, b) => a.pow(b),
-  "BigNumber, BigNumber": (a, b) => a.pow(b.valueOf()),
+  // Rich-type policy cases DELEGATE to core's scalar `pow`, which correctly guards
+  // non-integer exponents of exact types (falling back to double-precision Math.pow,
+  // returning a plain number). The old inline copies were buggy:
+  //   pow(BigNumber(2), 0.5)  -> 1     (unguarded a.pow(0.5); core -> 1.4142…)
+  //   pow(Fraction(3), 2.9)   -> 27    (silently floored via a.pow(Math.floor(b)); core -> 24.19…)
+  "Complex, number": (a, b) => corePow(a, b),
+  "Complex, Complex": (a, b) => corePow(a, b),
+  "Fraction, number": (a, b) => corePow(a, b),
+  "BigNumber, number": (a, b) => corePow(a, b),
+  "BigNumber, BigNumber": (a, b) => corePow(a, b),
   // Dual numbers (forward-mode AD): constant or variable exponent.
   "Dual, number": (a, b) => a.powConst(b),
   "Dual, Dual": (a, b) => a.pow(b),
@@ -1874,9 +1886,12 @@ var expm1 = mathTyped2("expm1", {
 });
 var round = mathTyped2("round", {
   number: (a) => Math.round(a),
-  Fraction: (a) => a.round(),
-  BigNumber: (a) => a.round(),
-  Complex: (a) => new Complex(Math.round(a.re), Math.round(a.im)),
+  // Rich-type policy cases DELEGATE to core's scalar `round`, which uses `halfCeil`
+  // for BigNumber so round(bignumber(-2.5)) = -2 (type-consistent with number/Fraction),
+  // not the -3 the old inline `a.round()` (half-away-from-zero) produced.
+  Fraction: (a) => coreRound(a),
+  BigNumber: (a) => coreRound(a),
+  Complex: (a) => coreRound(a),
   "number, number": (a, decimals) => {
     const factor2 = Math.pow(10, decimals);
     return Math.round(a * factor2) / factor2;
@@ -1926,9 +1941,11 @@ var ceil = mathTyped2("ceil", {
 });
 var fix = mathTyped2("fix", {
   number: (a) => Math.trunc(a),
-  Fraction: (a) => a.trunc(),
-  BigNumber: (a) => a.trunc(),
-  Complex: (a) => new Complex(Math.trunc(a.re), Math.trunc(a.im)),
+  // Rich-type policy cases DELEGATE to core's scalar `fix` (truncate toward zero:
+  // floor for non-negative, ceil for negative). Removes the duplicated policy.
+  Fraction: (a) => coreFix(a),
+  BigNumber: (a) => coreFix(a),
+  Complex: (a) => coreFix(a),
   // Parallel array fix (truncate toward zero, matching the 'number' overload)
   Float64Array: async (a) => {
     if (computePool.shouldParallelize(a.length)) {
@@ -2141,11 +2158,17 @@ var tanh = mathTyped2("tanh", {
   }
 });
 var equal = mathTyped2("equal", {
-  "number, number": (a, b) => a === b,
+  // number,number DELEGATES to core's TOLERANCE-based equality (relTol/absTol via
+  // nearlyEqual) — mathjs parity. The old strict `a === b` made equal(0.1+0.2, 0.3)
+  // return false; core (and mathjs) return true. Floats are almost never bit-equal
+  // after arithmetic, so strict === is the wrong policy for a public math `equal`.
+  "number, number": (a, b) => coreEqual(a, b),
+  // bigint stays inline (core also compares bigints with ===; tolerance is meaningless).
   "bigint, bigint": (a, b) => a === b,
-  "Complex, Complex": (a, b) => a.equals(b),
-  "Fraction, Fraction": (a, b) => a.equals(b),
-  "BigNumber, BigNumber": (a, b) => a.equals(b),
+  // Rich-type cases delegate to core (exact equality for Fraction/BigNumber; Complex.equals).
+  "Complex, Complex": (a, b) => coreEqual(a, b),
+  "Fraction, Fraction": (a, b) => coreEqual(a, b),
+  "BigNumber, BigNumber": (a, b) => coreEqual(a, b),
   "Unit, Unit": (a, b) => unitSameDimension(a, b) && asUnit(a).value === asUnit(b).value
 });
 var smaller = mathTyped2("smaller", {
@@ -11604,19 +11627,6 @@ function isIndex(x) {
   const obj = x;
   return obj.constructor?.prototype?.isIndex === true;
 }
-function isObject(x) {
-  return !!(x && typeof x === "object" && x.constructor === Object && !isComplex(x) && !isFraction(x));
-}
-function isMap(object) {
-  if (!object) {
-    return false;
-  }
-  if (object instanceof Map) {
-    return true;
-  }
-  const mapLike = object;
-  return typeof mapLike.set === "function" && typeof mapLike.get === "function" && typeof mapLike.keys === "function" && typeof mapLike.has === "function";
-}
 function isAccessorNode(x) {
   if (!x || typeof x !== "object") return false;
   const obj = x;
@@ -11703,24 +11713,15 @@ import {
   traverse
 } from "@danielsimonjr/mathts-core/internal";
 
-// src/error/MathjsError.ts
-var MathjsError = class _MathjsError extends Error {
-  isMathjsError = true;
-  /**
-   * Create a MathjsError
-   * @param message  Error message
-   */
-  constructor(message) {
-    super(message);
-    this.name = "MathjsError";
-    const ErrorWithCapture = Error;
-    if (ErrorWithCapture.captureStackTrace) {
-      ErrorWithCapture.captureStackTrace(this, _MathjsError);
-    }
-  }
-};
-
 // src/utils/factory.ts
+import {
+  isFactory,
+  assertDependencies,
+  isOptionalDependency,
+  stripOptionalNotation,
+  sortFactories as coreSortFactories,
+  create as coreCreate
+} from "@danielsimonjr/mathts-core/internal";
 function factory(name254, dependencies254, create, meta) {
   function assertAndCreate(scope) {
     const deps = pickShallow(scope, dependencies254.map(stripOptionalNotation));
@@ -11735,23 +11736,6 @@ function factory(name254, dependencies254, create, meta) {
   }
   return assertAndCreate;
 }
-function assertDependencies(name254, dependencies254, scope) {
-  const allDefined = dependencies254.filter((dependency) => !isOptionalDependency(dependency)).every((dependency) => scope[dependency] !== void 0);
-  if (!allDefined) {
-    const missingDependencies = dependencies254.filter(
-      (dependency) => scope[dependency] === void 0
-    );
-    throw new MathjsError(
-      `Cannot create function "${name254}", some dependencies are missing: ${missingDependencies.map((d) => `"${d}"`).join(", ")}.`
-    );
-  }
-}
-function isOptionalDependency(dependency) {
-  return Boolean(dependency && dependency[0] === "?");
-}
-function stripOptionalNotation(dependency) {
-  return dependency && dependency[0] === "?" ? dependency.slice(1) : dependency;
-}
 
 // src/numeric/solveODE.ts
 var WASM_ODE_THRESHOLD = 10;
@@ -12062,7 +12046,7 @@ var createSolveODE = /* @__PURE__ */ factory(
     multiply: multiply2,
     divide: divide2,
     max: max2,
-    map: map2,
+    map: map3,
     abs: abs2,
     isPositive: isPositive2,
     isNegative: isNegative2,
@@ -12293,7 +12277,7 @@ var createSolveODE = /* @__PURE__ */ factory(
           }
           const errComb = stageCombo(deltaB, k);
           const errArr = Array.isArray(errComb) ? errComb : [errComb];
-          const TE = max2(abs2(map2(errArr, (X) => isUnit(X) ? X.value : X)));
+          const TE = max2(abs2(map3(errArr, (X) => isUnit(X) ? X.value : X)));
           if (TE < tol && tol / TE > 1 / 4) {
             t.push(add4(t[n], h));
             y.push(add4(y[n], multiply2(h, stageCombo(b, k))));
@@ -18280,225 +18264,12 @@ var typedRelational = {
 // src/typed/string.ts
 import { mathTyped as mathTyped15, BigNumber as BigNumber7 } from "@danielsimonjr/mathts-core";
 
-// src/utils/bignumber/formatter.ts
-function formatBigNumberToBase(n, base, size2) {
-  const BigNumberCtor = n.constructor;
-  const big2 = new BigNumberCtor(2);
-  let suffix = "";
-  if (size2) {
-    if (size2 < 1) {
-      throw new Error("size must be in greater than 0");
-    }
-    if (!isInteger(size2)) {
-      throw new Error("size must be an integer");
-    }
-    if (n.greaterThan(big2.pow(size2 - 1).sub(1)) || n.lessThan(big2.pow(size2 - 1).mul(-1))) {
-      throw new Error(`Value must be in range [-2^${size2 - 1}, 2^${size2 - 1}-1]`);
-    }
-    if (!n.isInteger()) {
-      throw new Error("Value must be an integer");
-    }
-    if (n.lessThan(0)) {
-      n = n.add(big2.pow(size2));
-    }
-    suffix = `i${size2}`;
-  }
-  switch (base) {
-    case 2:
-      return `${n.toBinary()}${suffix}`;
-    case 8:
-      return `${n.toOctal()}${suffix}`;
-    case 16:
-      return `${n.toHexadecimal()}${suffix}`;
-    default:
-      throw new Error(`Base ${base} not supported `);
-  }
-}
-function format2(value, options) {
-  const v = value;
-  if (typeof options === "function") {
-    return options(value);
-  }
-  if (!v.isFinite()) {
-    return v.isNaN() ? "NaN" : v.gt(0) ? "Infinity" : "-Infinity";
-  }
-  const { notation, precision, wordSize } = normalizeFormatOptions(
-    options
-  );
-  switch (notation) {
-    case "fixed":
-      return toFixed2(v, precision);
-    case "exponential":
-      return toExponential2(v, precision);
-    case "engineering":
-      return toEngineering2(v, precision);
-    case "bin":
-      return formatBigNumberToBase(v, 2, wordSize);
-    case "oct":
-      return formatBigNumberToBase(v, 8, wordSize);
-    case "hex":
-      return formatBigNumberToBase(v, 16, wordSize);
-    case "auto": {
-      const optionsObj = options;
-      const lowerExp = _toNumberOrDefault(optionsObj?.lowerExp, -3);
-      const upperExp = _toNumberOrDefault(optionsObj?.upperExp, 5);
-      if (v.isZero()) return "0";
-      let str;
-      const rounded = v.toSignificantDigits(precision);
-      const exp2 = rounded.e;
-      if (exp2 >= lowerExp && exp2 < upperExp) {
-        str = rounded.toFixed();
-      } else {
-        str = toExponential2(v, precision);
-      }
-      return str.replace(
-        /((\.\d*?)(0+))($|e)/,
-        function(_match, _g1, digits2, _g3, e) {
-          return digits2 !== "." ? digits2 + e : e;
-        }
-      );
-    }
-    default:
-      throw new Error(
-        'Unknown notation "' + notation + '". Choose "auto", "exponential", "fixed", "bin", "oct", or "hex.'
-      );
-  }
-}
-function toEngineering2(value, precision) {
-  const e = value.e;
-  const newExp = e % 3 === 0 ? e : e < 0 ? e - 3 - e % 3 : e - e % 3;
-  const valueWithoutExp = value.mul(Math.pow(10, -newExp));
-  let valueStr = valueWithoutExp.toPrecision(precision);
-  if (valueStr.includes("e")) {
-    const BigNumberCtor = value.constructor;
-    valueStr = new BigNumberCtor(valueStr).toFixed();
-  }
-  return valueStr + "e" + (e >= 0 ? "+" : "") + newExp.toString();
-}
-function toExponential2(value, precision) {
-  if (precision !== void 0) {
-    return value.toExponential(precision - 1);
-  } else {
-    return value.toExponential();
-  }
-}
-function toFixed2(value, precision) {
-  return value.toFixed(precision);
-}
-function _toNumberOrDefault(value, defaultValue) {
-  if (isNumber(value)) {
-    return value;
-  } else if (isBigNumber(value)) {
-    return value.toNumber();
-  } else {
-    return defaultValue;
-  }
-}
-
 // src/utils/string.ts
-function format3(value, options) {
-  const result = _format(value, options);
-  if (options && typeof options === "object" && "truncate" in options) {
-    const truncate = options.truncate;
-    if (typeof truncate === "number" && result.length > truncate) {
-      return result.substring(0, truncate - 3) + "...";
-    }
-  }
-  return result;
-}
-function _format(value, options) {
-  if (typeof value === "number") {
-    return format(value, options);
-  }
-  if (isBigNumber(value)) {
-    return format2(value, options);
-  }
-  if (looksLikeFraction(value)) {
-    if (!options || options.fraction !== "decimal") {
-      const signedNumerator = typeof value.n === "bigint" ? BigInt(value.s) * value.n : value.s * value.n;
-      return `${signedNumerator}/${value.d}`;
-    } else {
-      return value.toString();
-    }
-  }
-  if (Array.isArray(value)) {
-    return formatArray(value, options);
-  }
-  if (isString(value)) {
-    return stringify(value);
-  }
-  if (typeof value === "function") {
-    const syntax = value.syntax;
-    return syntax ? String(syntax) : "function";
-  }
-  if (value && typeof value === "object") {
-    const obj = value;
-    if (typeof obj.format === "function") {
-      return obj.format(options);
-    } else if (obj.toString(options) !== {}.toString()) {
-      return obj.toString(options);
-    } else {
-      const entries = Object.keys(obj).map((key) => {
-        return stringify(key) + ": " + format3(obj[key], options);
-      });
-      return "{" + entries.join(", ") + "}";
-    }
-  }
-  return String(value);
-}
-function stringify(value) {
-  const text = String(value);
-  let escaped = "";
-  let i = 0;
-  while (i < text.length) {
-    const c = text.charAt(i);
-    escaped += c in controlCharacters ? controlCharacters[c] : c;
-    i++;
-  }
-  return '"' + escaped + '"';
-}
-var controlCharacters = {
-  '"': '\\"',
-  "\\": "\\\\",
-  "\b": "\\b",
-  "\f": "\\f",
-  "\n": "\\n",
-  "\r": "\\r",
-  "	": "\\t"
-};
-function formatArray(array, options) {
-  if (Array.isArray(array)) {
-    let str = "[";
-    const len = array.length;
-    for (let i = 0; i < len; i++) {
-      if (i !== 0) {
-        str += ", ";
-      }
-      str += formatArray(array[i], options);
-    }
-    str += "]";
-    return str;
-  } else {
-    return format3(array, options);
-  }
-}
-function looksLikeFraction(value) {
-  const frac = value;
-  return !!frac && typeof frac === "object" && typeof frac.s === "bigint" && typeof frac.n === "bigint" && typeof frac.d === "bigint" || false;
-}
-function compareText2(x, y) {
-  if (!isString(x)) {
-    throw new TypeError(
-      "Unexpected type of argument in function compareText (expected: string or Array or Matrix, actual: " + typeOf(x) + ", index: 0)"
-    );
-  }
-  if (!isString(y)) {
-    throw new TypeError(
-      "Unexpected type of argument in function compareText (expected: string or Array or Matrix, actual: " + typeOf(y) + ", index: 1)"
-    );
-  }
-  return x === y ? 0 : x > y ? 1 : -1;
-}
+import {
+  formatGeneric,
+  stringify,
+  compareText as compareText2
+} from "@danielsimonjr/mathts-core/internal";
 
 // src/utils/print.ts
 var printTemplate = /\$([\w.]+)/g;
@@ -18546,7 +18317,7 @@ function interpolate2(template, values, options) {
     }
     if (value !== void 0) {
       if (!isString(value)) {
-        return format3(value, options);
+        return formatGeneric(value, options);
       } else {
         return value;
       }
@@ -18572,7 +18343,7 @@ var oct = mathTyped15("oct", {
   BigNumber: (x) => bigNumberToBase(x, 8),
   "BigNumber, number": (x, wordSize) => bigNumberToBase(x, 8, wordSize)
 });
-var format4 = mathTyped15("format", {
+var format2 = mathTyped15("format", {
   // Single-arg: format with defaults. For BigNumber, utils/string isBigNumber check
   // may fail (core BigNumber uses .isBigNumber property but not on prototype), so
   // we intercept BigNumber explicitly before delegating to formatValue.
@@ -18583,7 +18354,7 @@ var format4 = mathTyped15("format", {
       if (!bn.isFinite()) return bn.isNegative() ? "-Infinity" : "Infinity";
       return bn.toString();
     }
-    return format3(x, void 0);
+    return formatGeneric(x, void 0);
   },
   // Two-arg: format with options/precision. For BigNumber+number we use toPrecision
   // directly; for everything else we delegate to formatValue.
@@ -18595,9 +18366,9 @@ var format4 = mathTyped15("format", {
       if (typeof options === "number") {
         return bn.toPrecision(options);
       }
-      return format3(x, options);
+      return formatGeneric(x, options);
     }
-    return format3(x, options);
+    return formatGeneric(x, options);
   }
 });
 var print = mathTyped15("print", {
@@ -18608,7 +18379,7 @@ var typedString = {
   bin,
   hex,
   oct,
-  format: format4,
+  format: format2,
   print
 };
 
@@ -18899,35 +18670,7 @@ function initTypeBridge() {
 }
 
 // src/core/config.ts
-var DEFAULT_CONFIG = {
-  // minimum relative difference between two compared values,
-  // used by all comparison functions
-  relTol: 1e-12,
-  // minimum absolute difference between two compared values,
-  // used by all comparison functions
-  absTol: 1e-15,
-  // type of default matrix output. Choose 'matrix' (default) or 'array'
-  matrix: "Matrix",
-  // type of default number output. Choose 'number' (default) 'BigNumber', 'bigint', or 'Fraction'
-  number: "number",
-  // type of fallback used for config { number: 'bigint' } when a value cannot be represented
-  // in the configured numeric type. Choose 'number' (default) or 'BigNumber'.
-  numberFallback: "number",
-  // number of significant digits in BigNumbers
-  precision: 64,
-  // predictable output type of functions. When true, output type depends only
-  // on the input types. When false (default), output type can vary depending
-  // on input values. For example `math.sqrt(-4)` returns `complex('2i')` when
-  // predictable is false, and returns `NaN` when true.
-  predictable: false,
-  // random seed for seeded pseudo random number generation
-  // null = randomly seed
-  randomSeed: null,
-  // legacy behavior for matrix subset. When true, the subset function
-  // returns a matrix or array with the same size as the index (except for scalars).
-  // When false, it returns a matrix or array with a size depending on the type of index.
-  legacySubset: false
-};
+import { DEFAULT_CONFIG } from "@danielsimonjr/mathts-core/internal";
 
 // src/factories/scope.ts
 initTypeBridge();
@@ -19072,7 +18815,7 @@ __export(factories_exports, {
   catalan: () => catalan,
   chain: () => chain,
   classicalElectronRadius: () => classicalElectronRadius,
-  clone: () => clone3,
+  clone: () => clone2,
   column: () => column,
   complex: () => complex,
   composition: () => composition,
@@ -19184,7 +18927,7 @@ __export(factories_exports, {
   fineStructure: () => fineStructure,
   firstRadiation: () => firstRadiation,
   flatten: () => flatten3,
-  forEach: () => forEach,
+  forEach: () => forEach2,
   fraction: () => fraction,
   freqz: () => freqz,
   gamma: () => gamma,
@@ -19225,7 +18968,7 @@ __export(factories_exports, {
   mad: () => mad,
   magneticConstant: () => magneticConstant,
   magneticFluxQuantum: () => magneticFluxQuantum,
-  map: () => map,
+  map: () => map2,
   mapSlices: () => mapSlices,
   matrix: () => matrix,
   matrixFromColumns: () => matrixFromColumns,
@@ -19309,706 +19052,14 @@ __export(factories_exports, {
   zpk2tf: () => zpk2tf
 });
 
-// src/error/IndexError.ts
-var IndexError = class _IndexError extends RangeError {
-  index;
-  min;
-  max;
-  isIndexError = true;
-  /**
-   * Create an IndexError
-   *
-   * Can be called in two ways:
-   * - IndexError(index, max) - assumes min=0
-   * - IndexError(index, min, max)
-   *
-   * @param index  The actual index
-   * @param min    Minimum index (included), or max if only 2 args provided
-   * @param max    Maximum index (excluded)
-   */
-  constructor(index, min2, max2) {
-    let actualMin;
-    let actualMax;
-    if (max2 === void 0) {
-      actualMin = 0;
-      actualMax = min2;
-    } else {
-      actualMin = min2;
-      actualMax = max2;
-    }
-    let message;
-    if (actualMin !== void 0 && index < actualMin) {
-      message = "Index out of range (" + index + " < " + actualMin + ")";
-    } else if (actualMax !== void 0 && index >= actualMax) {
-      message = "Index out of range (" + index + " > " + (actualMax - 1) + ")";
-    } else {
-      message = "Index out of range (" + index + ")";
-    }
-    super(message);
-    this.index = index;
-    this.min = actualMin;
-    this.max = actualMax;
-    this.name = "IndexError";
-    const ErrorWithCapture = Error;
-    if (ErrorWithCapture.captureStackTrace) {
-      ErrorWithCapture.captureStackTrace(this, _IndexError);
-    }
-  }
-};
-
-// src/error/DimensionError.ts
-var DimensionError = class _DimensionError extends RangeError {
-  actual;
-  expected;
-  relation;
-  isDimensionError = true;
-  /**
-   * @param actual - The actual size or custom error message
-   * @param expected - The expected size (optional if actual is a custom message)
-   * @param relation - Optional relation between actual and expected size: '!=', '<', etc.
-   */
-  constructor(actual, expected, relation) {
-    let message;
-    if (typeof actual === "string" && expected === void 0) {
-      message = actual;
-    } else {
-      message = "Dimension mismatch (" + (Array.isArray(actual) ? "[" + actual.join(", ") + "]" : actual) + " " + (relation || "!=") + " " + (Array.isArray(expected) ? "[" + expected.join(", ") + "]" : expected) + ")";
-    }
-    super(message);
-    this.name = "DimensionError";
-    if (typeof actual === "string" && expected === void 0) {
-      this.actual = void 0;
-      this.expected = void 0;
-      this.relation = void 0;
-    } else {
-      this.actual = actual;
-      this.expected = expected;
-      this.relation = relation;
-    }
-    const ErrorWithCapture = Error;
-    if (ErrorWithCapture.captureStackTrace) {
-      ErrorWithCapture.captureStackTrace(this, _DimensionError);
-    }
-  }
-};
-
-// src/utils/array.ts
-function arraySize(x) {
-  const s = [];
-  let current = x;
-  while (Array.isArray(current)) {
-    s.push(current.length);
-    current = current[0];
-  }
-  return s;
-}
-function validateIndexSourceSize(value, index) {
-  const valueSize = value.isMatrix ? value._size : arraySize(value);
-  const sourceSize = index._sourceSize;
-  sourceSize.forEach((sourceDim, i) => {
-    if (sourceDim !== null && sourceDim !== valueSize[i]) {
-      throw new DimensionError(sourceDim, valueSize[i]);
-    }
-  });
-}
-function validateIndex(index, length) {
-  if (index !== void 0) {
-    if (!isNumber(index) || !isInteger(index)) {
-      throw new TypeError("Index must be an integer (value: " + index + ")");
-    }
-    if (index < 0 || typeof length === "number" && index >= length) {
-      throw new IndexError(index, length);
-    }
-  }
-}
-function isEmptyIndex(index) {
-  for (let i = 0; i < index._dimensions.length; ++i) {
-    const dimension = index._dimensions[i];
-    if (isString(dimension)) {
-      if (dimension.length === 0) {
-        return true;
-      }
-    } else {
-      const dim = dimension;
-      if (dim._data && isArray(dim._data)) {
-        if (dim._size[0] === 0) {
-          return true;
-        }
-      } else if (dim.isRange) {
-        if (dim.start === dim.end) {
-          return true;
-        }
-      }
-    }
-  }
-  return false;
-}
-function resize(array, size2, defaultValue) {
-  if (!Array.isArray(size2)) {
-    throw new TypeError("Array expected");
-  }
-  if (size2.length === 0) {
-    throw new Error("Resizing to scalar is not supported");
-  }
-  size2.forEach(function(value) {
-    if (!isNumber(value) || !isInteger(value) || value < 0) {
-      throw new TypeError(
-        "Invalid size, must contain positive integers (size: " + format3(size2, {}) + ")"
-      );
-    }
-  });
-  let arr10 = array;
-  if (isNumber(array) || isBigNumber(array)) {
-    arr10 = [array];
-  }
-  const _defaultValue = defaultValue !== void 0 ? defaultValue : 0;
-  _resize(arr10, size2, 0, _defaultValue);
-  return arr10;
-}
-function _resize(array, size2, dim, defaultValue) {
-  let i;
-  let elem;
-  const oldLen = array.length;
-  const newLen = size2[dim];
-  const minLen = Math.min(oldLen, newLen);
-  array.length = newLen;
-  if (dim < size2.length - 1) {
-    const dimNext = dim + 1;
-    for (i = 0; i < minLen; i++) {
-      let current = array[i];
-      if (!Array.isArray(current)) {
-        current = [current];
-        array[i] = current;
-      }
-      _resize(current, size2, dimNext, defaultValue);
-    }
-    for (i = minLen; i < newLen; i++) {
-      elem = [];
-      array[i] = elem;
-      _resize(elem, size2, dimNext, defaultValue);
-    }
-  } else {
-    for (i = 0; i < minLen; i++) {
-      let value = array[i];
-      while (Array.isArray(value)) {
-        value = value[0];
-      }
-      array[i] = value;
-    }
-    for (i = minLen; i < newLen; i++) {
-      array[i] = defaultValue;
-    }
-  }
-}
-function reshape(array, sizes) {
-  const flatArray = flatten2(array, true);
-  const currentLength = flatArray.length;
-  if (!Array.isArray(array) || !Array.isArray(sizes)) {
-    throw new TypeError("Array expected");
-  }
-  if (sizes.length === 0) {
-    throw new DimensionError(0, currentLength, "!=");
-  }
-  const processedSizes = processSizesWildcard(sizes, currentLength);
-  const newLength = product2(processedSizes);
-  if (currentLength !== newLength) {
-    throw new DimensionError(newLength, currentLength, "!=");
-  }
-  try {
-    return _reshape(flatArray, processedSizes);
-  } catch (e) {
-    if (e instanceof DimensionError) {
-      throw new DimensionError(newLength, currentLength, "!=");
-    }
-    throw e;
-  }
-}
-function processSizesWildcard(sizes, currentLength) {
-  const newLength = product2(sizes);
-  const processedSizes = sizes.slice();
-  const WILDCARD = -1;
-  const wildCardIndex = sizes.indexOf(WILDCARD);
-  const isMoreThanOneWildcard = sizes.indexOf(WILDCARD, wildCardIndex + 1) >= 0;
-  if (isMoreThanOneWildcard) {
-    throw new Error("More than one wildcard in sizes");
-  }
-  const hasWildcard = wildCardIndex >= 0;
-  const canReplaceWildcard = currentLength % newLength === 0;
-  if (hasWildcard) {
-    if (canReplaceWildcard) {
-      processedSizes[wildCardIndex] = -currentLength / newLength;
-    } else {
-      throw new Error(
-        "Could not replace wildcard, since " + currentLength + " is no multiple of " + -newLength
-      );
-    }
-  }
-  return processedSizes;
-}
-function product2(array) {
-  return array.reduce((prev, curr) => prev * curr, 1);
-}
-function _reshape(array, sizes) {
-  let tmpArray = array;
-  let tmpArray2;
-  for (let sizeIndex = sizes.length - 1; sizeIndex > 0; sizeIndex--) {
-    const size2 = sizes[sizeIndex];
-    tmpArray2 = [];
-    const length = tmpArray.length / size2;
-    for (let i = 0; i < length; i++) {
-      tmpArray2.push(tmpArray.slice(i * size2, (i + 1) * size2));
-    }
-    tmpArray = tmpArray2;
-  }
-  return tmpArray;
-}
-function squeeze(array, size2) {
-  const s = size2 || arraySize(array);
-  let arr10 = array;
-  while (Array.isArray(arr10) && arr10.length === 1) {
-    arr10 = arr10[0];
-    s.shift();
-  }
-  let dims = s.length;
-  while (s[dims - 1] === 1) {
-    dims--;
-  }
-  if (dims < s.length) {
-    arr10 = _squeeze(arr10, dims, 0);
-    s.length = dims;
-  }
-  return arr10;
-}
-function _squeeze(array, dims, dim) {
-  if (dim < dims) {
-    const next = dim + 1;
-    const arr10 = array;
-    for (let i = 0, ii = arr10.length; i < ii; i++) {
-      arr10[i] = _squeeze(arr10[i], dims, next);
-    }
-    return arr10;
-  } else {
-    let result = array;
-    while (Array.isArray(result)) {
-      result = result[0];
-    }
-    return result;
-  }
-}
-function flatten2(array, isRectangular = false) {
-  if (!Array.isArray(array)) {
-    return array;
-  }
-  if (typeof isRectangular !== "boolean") {
-    throw new TypeError("Boolean expected for second argument of flatten");
-  }
-  const flat = [];
-  if (isRectangular) {
-    _flattenRectangular(array);
-  } else {
-    _flatten(array);
-  }
-  return flat;
-  function _flatten(arr10) {
-    for (let i = 0; i < arr10.length; i++) {
-      const item = arr10[i];
-      if (Array.isArray(item)) {
-        _flatten(item);
-      } else {
-        flat.push(item);
-      }
-    }
-  }
-  function _flattenRectangular(arr10) {
-    if (Array.isArray(arr10[0])) {
-      for (let i = 0; i < arr10.length; i++) {
-        _flattenRectangular(arr10[i]);
-      }
-    } else {
-      for (let i = 0; i < arr10.length; i++) {
-        flat.push(arr10[i]);
-      }
-    }
-  }
-}
-function filter(array, callback) {
-  if (arraySize(array).length !== 1) {
-    throw new Error("Only one dimensional matrices supported");
-  }
-  return Array.prototype.filter.call(array, callback);
-}
-function filterRegExp(array, regexp) {
-  if (arraySize(array).length !== 1) {
-    throw new Error("Only one dimensional matrices supported");
-  }
-  return Array.prototype.filter.call(array, (entry) => regexp.test(entry));
-}
-function identify2(a) {
-  if (!Array.isArray(a)) {
-    throw new TypeError("Array input expected");
-  }
-  if (a.length === 0) {
-    return [];
-  }
-  const b = [];
-  let count2 = 0;
-  b[0] = { value: a[0], identifier: 0 };
-  for (let i = 1; i < a.length; i++) {
-    if (a[i] === a[i - 1]) {
-      count2++;
-    } else {
-      count2 = 0;
-    }
-    b.push({ value: a[i], identifier: count2 });
-  }
-  return b;
-}
-function generalize(a) {
-  if (!Array.isArray(a)) {
-    throw new TypeError("Array input expected");
-  }
-  if (a.length === 0) {
-    return [];
-  }
-  const b = [];
-  for (let i = 0; i < a.length; i++) {
-    b.push(a[i].value);
-  }
-  return b;
-}
-function getArrayDataType(array, typeOf3) {
-  let type;
-  let length = 0;
-  for (let i = 0; i < array.length; i++) {
-    const item = array[i];
-    const isArray2 = Array.isArray(item);
-    if (i === 0 && isArray2) {
-      length = item.length;
-    }
-    if (isArray2 && item.length !== length) {
-      return void 0;
-    }
-    const itemType = isArray2 ? getArrayDataType(item, typeOf3) : typeOf3(item);
-    if (type === void 0) {
-      type = itemType;
-    } else if (type !== itemType) {
-      return "mixed";
-    } else {
-    }
-  }
-  return type;
-}
-function concatRecursive(a, b, concatDim, dim) {
-  if (dim < concatDim) {
-    if (a.length !== b.length) {
-      throw new DimensionError(a.length, b.length);
-    }
-    const c = [];
-    for (let i = 0; i < a.length; i++) {
-      c[i] = concatRecursive(
-        a[i],
-        b[i],
-        concatDim,
-        dim + 1
-      );
-    }
-    return c;
-  } else {
-    return a.concat(b);
-  }
-}
-function concat(...args) {
-  const arrays = Array.prototype.slice.call(args, 0, -1);
-  const concatDim = Array.prototype.slice.call(args, -1)[0];
-  if (arrays.length === 1) {
-    return arrays[0];
-  }
-  if (arrays.length > 1) {
-    return arrays.slice(1).reduce(function(A, B) {
-      return concatRecursive(A, B, concatDim, 0);
-    }, arrays[0]);
-  } else {
-    throw new Error("Wrong number of arguments in function concat");
-  }
-}
-function broadcastSizes(...sizes) {
-  const dimensions = sizes.map((s) => s.length);
-  const N = Math.max(...dimensions);
-  const sizeMax = new Array(N).fill(null);
-  for (let i = 0; i < sizes.length; i++) {
-    const size2 = sizes[i];
-    const dim = dimensions[i];
-    for (let j = 0; j < dim; j++) {
-      const n = N - dim + j;
-      if (size2[j] > sizeMax[n]) {
-        sizeMax[n] = size2[j];
-      }
-    }
-  }
-  for (let i = 0; i < sizes.length; i++) {
-    checkBroadcastingRules(sizes[i], sizeMax);
-  }
-  return sizeMax;
-}
-function checkBroadcastingRules(size2, toSize) {
-  const N = toSize.length;
-  const dim = size2.length;
-  for (let j = 0; j < dim; j++) {
-    const n = N - dim + j;
-    if (size2[j] < toSize[n] && size2[j] > 1 || size2[j] > toSize[n]) {
-      throw new Error(
-        `shape mismatch: mismatch is found in arg with shape (${size2}) not possible to broadcast dimension ${dim} with size ${size2[j]} to size ${toSize[n]}`
-      );
-    }
-  }
-}
-function broadcastTo(array, toSize) {
-  let Asize = arraySize(array);
-  if (deepStrictEqual(Asize, toSize)) {
-    return array;
-  }
-  checkBroadcastingRules(Asize, toSize);
-  const broadcastedSize = broadcastSizes(Asize, toSize);
-  const N = broadcastedSize.length;
-  const paddedSize = [...Array(N - Asize.length).fill(1), ...Asize];
-  let A = clone2(array);
-  if (Asize.length < N) {
-    A = reshape(A, paddedSize);
-    Asize = arraySize(A);
-  }
-  for (let dim = 0; dim < N; dim++) {
-    if (Asize[dim] < broadcastedSize[dim]) {
-      A = stretch(A, broadcastedSize[dim], dim);
-      Asize = arraySize(A);
-    }
-  }
-  return A;
-}
-function stretch(arrayToStretch, sizeToStretch, dimToStretch) {
-  return concat(...Array(sizeToStretch).fill(arrayToStretch), dimToStretch);
-}
-function get2(array, index) {
-  if (!Array.isArray(array)) {
-    throw new Error("Array expected");
-  }
-  const size2 = arraySize(array);
-  if (index.length !== size2.length) {
-    throw new DimensionError(index.length, size2.length);
-  }
-  for (let x = 0; x < index.length; x++) {
-    validateIndex(index[x], size2[x]);
-  }
-  return index.reduce((acc, curr) => acc[curr], array);
-}
-function deepMap(array, callback, skipIndex = false) {
-  if (Array.isArray(array) && array.length === 0) {
-    return [];
-  }
-  if (skipIndex) {
-    return recursiveMap(array);
-  }
-  const index = [];
-  return recursiveMapWithIndex(array, 0);
-  function recursiveMapWithIndex(value, depth) {
-    if (Array.isArray(value)) {
-      const N = value.length;
-      const result = Array(N);
-      for (let i = 0; i < N; i++) {
-        index[depth] = i;
-        result[i] = recursiveMapWithIndex(value[i], depth + 1);
-      }
-      return result;
-    } else {
-      return callback(
-        value,
-        index.slice(0, depth),
-        array
-      );
-    }
-  }
-  function recursiveMap(value) {
-    if (Array.isArray(value)) {
-      const N = value.length;
-      const result = Array(N);
-      for (let i = 0; i < N; i++) {
-        result[i] = recursiveMap(value[i]);
-      }
-      return result;
-    } else {
-      return callback(value);
-    }
-  }
-}
-function deepForEach(array, callback, skipIndex = false) {
-  if (Array.isArray(array) && array.length === 0) {
-    return;
-  }
-  if (skipIndex) {
-    recursiveForEach(array);
-    return;
-  }
-  const index = [];
-  recursiveForEachWithIndex(array, 0);
-  function recursiveForEachWithIndex(value, depth) {
-    if (Array.isArray(value)) {
-      const N = value.length;
-      for (let i = 0; i < N; i++) {
-        index[depth] = i;
-        recursiveForEachWithIndex(value[i], depth + 1);
-      }
-    } else {
-      callback(
-        value,
-        index.slice(0, depth),
-        array
-      );
-    }
-  }
-  function recursiveForEach(value) {
-    if (Array.isArray(value)) {
-      const N = value.length;
-      for (let i = 0; i < N; i++) {
-        recursiveForEach(value[i]);
-      }
-    } else {
-      callback(value);
-    }
-  }
-}
-function clone2(array) {
-  return Object.assign([], array);
-}
-
-// src/utils/switch.ts
-function _switch(mat) {
-  const rows = mat;
-  const I2 = rows.length;
-  const J = rows[0].length;
-  let i, j;
-  const ret = [];
-  for (j = 0; j < J; j++) {
-    const tmp = [];
-    for (i = 0; i < I2; i++) {
-      tmp.push(rows[i][j]);
-    }
-    ret.push(tmp);
-  }
-  return ret;
-}
-
 // src/utils/collection.ts
-function containsCollections(array) {
-  for (let i = 0; i < array.length; i++) {
-    if (isCollection(array[i])) {
-      return true;
-    }
-  }
-  return false;
-}
-function deepForEach2(array, callback) {
-  if (isMatrix(array)) {
-    array.forEach((x) => callback(x), false, true);
-  } else {
-    deepForEach(array, callback, true);
-  }
-}
-function deepMap2(array, callback, skipZeros) {
-  if (!skipZeros) {
-    if (isMatrix(array)) {
-      return array.map((x) => callback(x), false, true);
-    } else {
-      return deepMap(array, callback, true);
-    }
-  }
-  const skipZerosCallback = (x) => x === 0 ? x : callback(x);
-  if (isMatrix(array)) {
-    return array.map((x) => skipZerosCallback(x), false, true);
-  } else {
-    return deepMap(array, skipZerosCallback, true);
-  }
-}
-function reduce2(mat, dim, callback) {
-  const size2 = Array.isArray(mat) ? arraySize(mat) : mat.size();
-  if (dim < 0 || dim >= size2.length) {
-    throw new IndexError(dim, 0, size2.length);
-  }
-  if (isMatrix(mat)) {
-    const reduced = _reduce(mat.valueOf(), dim, callback);
-    return mat.create(
-      reduced,
-      mat.datatype()
-    );
-  } else {
-    return _reduce(mat, dim, callback);
-  }
-}
-function _reduce(mat, dim, callback) {
-  let i;
-  let ret;
-  let val;
-  let tran;
-  if (dim <= 0) {
-    if (!Array.isArray(mat[0])) {
-      val = mat[0];
-      for (i = 1; i < mat.length; i++) {
-        val = callback(val, mat[i]);
-      }
-      return val;
-    } else {
-      tran = _switch(mat);
-      ret = [];
-      for (i = 0; i < tran.length; i++) {
-        ret[i] = _reduce(tran[i], dim - 1, callback);
-      }
-      return ret;
-    }
-  } else {
-    ret = [];
-    for (i = 0; i < mat.length; i++) {
-      ret[i] = _reduce(mat[i], dim - 1, callback);
-    }
-    return ret;
-  }
-}
-function scatter(a, j, w, x, u, mark, cindex, f, inverse, update, value) {
-  const avalues = a._values;
-  const aindex = a._index;
-  const aptr = a._ptr;
-  let k;
-  let k0;
-  let k1;
-  let i;
-  if (x) {
-    for (k0 = aptr[j], k1 = aptr[j + 1], k = k0; k < k1; k++) {
-      i = aindex[k];
-      if (w[i] !== mark) {
-        w[i] = mark;
-        cindex.push(i);
-        if (update && f) {
-          x[i] = inverse ? f(avalues[k], value) : f(value, avalues[k]);
-          u[i] = mark;
-        } else {
-          x[i] = avalues[k];
-        }
-      } else {
-        if (f) {
-          x[i] = inverse ? f(avalues[k], x[i]) : f(x[i], avalues[k]);
-        }
-        u[i] = mark;
-      }
-    }
-  } else {
-    for (k0 = aptr[j], k1 = aptr[j + 1], k = k0; k < k1; k++) {
-      i = aindex[k];
-      if (w[i] !== mark) {
-        w[i] = mark;
-        cindex.push(i);
-      } else {
-        u[i] = mark;
-      }
-    }
-  }
-}
+import {
+  containsCollections,
+  deepForEach,
+  deepMap,
+  reduce as reduce2,
+  scatter
+} from "@danielsimonjr/mathts-core/internal";
 
 // src/arithmetic/abs.ts
 var name2 = "abs";
@@ -20023,7 +19074,7 @@ var createAbs = /* @__PURE__ */ factory(
       bigint: (x) => x < 0n ? -x : x,
       // deep map collection, skip zeros since abs(0) = 0
       "Array | Matrix": typed3.referToSelf(
-        (self) => (x) => deepMap2(x, self, true)
+        (self) => (x) => deepMap(x, self, true)
       )
     });
   }
@@ -20181,7 +19232,7 @@ var createLog10 = /* @__PURE__ */ factory(
         }
       },
       "Array | Matrix": typed3.referToSelf(
-        (self) => (x) => deepMap2(x, self)
+        (self) => (x) => deepMap(x, self)
       )
     });
   }
@@ -20215,7 +19266,7 @@ var createLog2 = /* @__PURE__ */ factory(
         }
       },
       "Array | Matrix": typed3.referToSelf(
-        (self) => (x) => deepMap2(x, self)
+        (self) => (x) => deepMap(x, self)
       )
     });
     function _log2Complex(x) {
@@ -20278,7 +19329,7 @@ var createSign = /* @__PURE__ */ factory(
       },
       // deep map collection, skip zeros since sign(0) = 0
       "Array | Matrix": typed3.referToSelf(
-        (self) => (x) => deepMap2(x, self, true)
+        (self) => (x) => deepMap(x, self, true)
       ),
       Unit: typed3.referToSelf((self) => (x) => {
         if (!x._isDerived() && x.units[0].unit.offset !== 0) {
@@ -20430,7 +19481,7 @@ var createUnaryMinus = /* @__PURE__ */ factory(
       },
       // deep map collection, skip zeros since unaryMinus(0) = 0
       "Array | Matrix": typed3.referToSelf(
-        (self) => (x) => deepMap2(x, self, true)
+        (self) => (x) => deepMap(x, self, true)
       )
       // TODO: add support for string
     });
@@ -20716,7 +19767,7 @@ var createBitNot = /* @__PURE__ */ factory(
       BigNumber: bitNotBigNumber,
       bigint: (x) => ~x,
       "Array | Matrix": typed3.referToSelf(
-        (self) => (x) => deepMap2(x, self)
+        (self) => (x) => deepMap(x, self)
       )
     });
   }
@@ -20741,7 +19792,7 @@ var createArg = /* @__PURE__ */ factory(
       },
       // TODO: implement BigNumber support for function arg
       "Array | Matrix": typed3.referToSelf(
-        (self) => (x) => deepMap2(x, self)
+        (self) => (x) => deepMap(x, self)
       )
     });
   }
@@ -20764,7 +19815,7 @@ var createConj = /* @__PURE__ */ factory(
         }
       ),
       "Array | Matrix": typed3.referToSelf(
-        (self) => (x) => deepMap2(x, self)
+        (self) => (x) => deepMap(x, self)
       )
     });
   }
@@ -20779,7 +19830,7 @@ var createIm = /* @__PURE__ */ factory(name18, dependencies18, ({ typed: typed3
     "BigNumber | Fraction": (x) => x.mul(0),
     Complex: (x) => x.im,
     "Array | Matrix": typed3.referToSelf(
-      (self) => (x) => deepMap2(x, self)
+      (self) => (x) => deepMap(x, self)
     )
   });
 });
@@ -20792,7 +19843,7 @@ var createRe = /* @__PURE__ */ factory(name19, dependencies19, ({ typed: typed3
     "number | BigNumber | Fraction": (x) => x,
     Complex: (x) => x.re,
     "Array | Matrix": typed3.referToSelf(
-      (self) => (x) => deepMap2(x, self)
+      (self) => (x) => deepMap(x, self)
     )
   });
 });
@@ -20818,7 +19869,7 @@ var createNot = /* @__PURE__ */ factory(
         (self) => (x) => typed3.find(self, x.valueType())(x.value)
       ),
       "Array | Matrix": typed3.referToSelf(
-        (self) => (x) => deepMap2(x, self)
+        (self) => (x) => deepMap(x, self)
       )
     });
   }
@@ -20826,6 +19877,42 @@ var createNot = /* @__PURE__ */ factory(
 
 // src/utils/optimizeCallback.ts
 import typed2 from "typed-function";
+
+// src/utils/array.ts
+import {
+  arraySize,
+  validate,
+  validateIndexSourceSize,
+  validateIndex,
+  isEmptyIndex,
+  resize,
+  reshape,
+  processSizesWildcard,
+  squeeze,
+  unsqueeze,
+  flatten as flatten2,
+  map,
+  forEach,
+  filter,
+  filterRegExp,
+  join,
+  identify as identify2,
+  generalize,
+  getArrayDataType,
+  last,
+  concat,
+  broadcastSizes,
+  checkBroadcastingRules,
+  broadcastTo,
+  broadcastArrays,
+  stretch,
+  getArrayElement,
+  deepMapArray as deepMapArray2,
+  deepForEachArray,
+  cloneArray
+} from "@danielsimonjr/mathts-core/internal";
+
+// src/utils/optimizeCallback.ts
 function optimizeCallback(callback, array, name254, isUnary) {
   const typedAny = typed2;
   if (typedAny.isTypedFunction(callback)) {
@@ -20839,7 +19926,7 @@ function optimizeCallback(callback, array, name254, isUnary) {
         return { isUnary: false, fn: callback };
       }
       const firstIndex = size2.map(() => 0);
-      const firstValue = array.isMatrix ? array.get(firstIndex) : get2(array, firstIndex);
+      const firstValue = array.isMatrix ? array.get(firstIndex) : getArrayElement(array, firstIndex);
       numberOfArguments = _findNumberOfArgumentsTyped(
         callback,
         firstValue,
@@ -21013,7 +20100,7 @@ var createForEach = /* @__PURE__ */ factory(
 );
 function _forEach(array, callback) {
   const fastCallback = optimizeCallback(callback, array, name23);
-  deepForEach(array, fastCallback.fn, fastCallback.isUnary);
+  deepForEachArray(array, fastCallback.fn, fastCallback.isUnary);
 }
 
 // src/matrix/getMatrixDataType.ts
@@ -21062,10 +20149,10 @@ var createMap = /* @__PURE__ */ factory(
       const sizes = Arrays.map((M) => isMat(M) ? M.size() : arraySize(M));
       const newSize = broadcastSizes(...sizes);
       const numberOfArrays = Arrays.length;
-      const _get = (coll, idx) => isMat(coll) ? coll.get(idx) : get2(coll, idx);
+      const _get = (coll, idx) => isMat(coll) ? coll.get(idx) : getArrayElement(coll, idx);
       const firstValues = Arrays.map((collection, i) => {
         const firstIndex = sizes[i].map(() => 0);
-        return isMat(collection) ? collection.get(firstIndex) : get2(collection, firstIndex);
+        return isMat(collection) ? collection.get(firstIndex) : getArrayElement(collection, firstIndex);
       });
       const callbackArgCount = typed3.isTypedFunction(multiCallback) ? _getTypedCallbackArgCount(
         multiCallback,
@@ -21182,7 +20269,7 @@ var createMap = /* @__PURE__ */ factory(
     }
     function _mapArray(array, callback) {
       const fastCallback = optimizeCallback(callback, array, name25);
-      return deepMap(
+      return deepMapArray2(
         array,
         fastCallback.fn,
         fastCallback.isUnary
@@ -21704,7 +20791,7 @@ var createErf = /* @__PURE__ */ factory(
               }
             }
           }
-          return deepMap2(n, self);
+          return deepMap(n, self);
         }
       )
       // TODO: For complex numbers, use the approximation for the Faddeeva function
@@ -21811,8 +20898,8 @@ var createFormat = /* @__PURE__ */ factory(
   dependencies35,
   ({ typed: typed3 }) => {
     return typed3(name35, {
-      any: format3,
-      "any, Object | function | number | BigNumber": format3
+      any: formatGeneric,
+      "any, Object | function | number | BigNumber": formatGeneric
     });
   }
 );
@@ -21844,7 +20931,7 @@ function _print(template, values, options) {
     }
     if (value !== void 0) {
       if (!isString(value)) {
-        return format3(value, options);
+        return formatGeneric(value, options);
       } else {
         return value;
       }
@@ -22432,7 +21519,7 @@ var createIsNaN = /* @__PURE__ */ factory(
         return Number.isNaN(x.value);
       },
       "Array | Matrix": typed3.referToSelf(
-        (self) => (x) => deepMap2(x, self)
+        (self) => (x) => deepMap(x, self)
       )
     });
   }
@@ -22455,7 +21542,7 @@ var createIsNegative = /* @__PURE__ */ factory(
         (self) => (x) => typed3.find(self, x.valueType())(x.value)
       ),
       "Array | Matrix": typed3.referToSelf(
-        (self) => (x) => deepMap2(x, self)
+        (self) => (x) => deepMap(x, self)
       )
     });
   }
@@ -22472,7 +21559,7 @@ var createIsNumeric = /* @__PURE__ */ factory(
       "number | BigNumber | bigint | Fraction | boolean": () => true,
       "Complex | Unit | string | null | undefined | Node": () => false,
       "Array | Matrix": typed3.referToSelf(
-        (self) => (x) => deepMap2(x, self)
+        (self) => (x) => deepMap(x, self)
       )
     });
   }
@@ -22494,7 +21581,7 @@ var createIsPositive = /* @__PURE__ */ factory(
         (self) => (x) => typed3.find(self, x.valueType())(x.value)
       ),
       "Array | Matrix": typed3.referToSelf(
-        (self) => (x) => deepMap2(x, self)
+        (self) => (x) => deepMap(x, self)
       )
     });
   }
@@ -22594,7 +21681,7 @@ var createIsPrime = /* @__PURE__ */ factory(
         return true;
       },
       "Array | Matrix": typed3.referToSelf(
-        (self) => (x) => deepMap2(x, self)
+        (self) => (x) => deepMap(x, self)
       )
     });
   }
@@ -22722,7 +21809,7 @@ var createUnaryPlus = /* @__PURE__ */ factory(
       },
       // deep map collection, skip zeros since unaryPlus(0) = 0
       "Array | Matrix": typed3.referToSelf(
-        (self) => (x) => deepMap2(x, self, true)
+        (self) => (x) => deepMap(x, self, true)
       ),
       boolean: function(x) {
         return numeric2(x ? 1 : 0, config2.number);
@@ -23032,7 +22119,7 @@ var createProd = /* @__PURE__ */ factory(
         }
       }
       let prod2;
-      deepForEach2(array, function(value) {
+      deepForEach(array, function(value) {
         try {
           const converted = typeof value === "string" ? parseNumberWithConfig2(value) : value;
           prod2 = prod2 === void 0 ? converted : multiplyScalar2(prod2, converted);
@@ -23054,13 +22141,13 @@ var dependencies77 = ["typed", "format"];
 var createBin = /* @__PURE__ */ factory(
   name77,
   dependencies77,
-  ({ typed: typed3, format: format6 }) => {
+  ({ typed: typed3, format: format4 }) => {
     return typed3(name77, {
       "number | BigNumber": function(n) {
-        return format6(n, { notation: "bin" });
+        return format4(n, { notation: "bin" });
       },
       "number | BigNumber, number | BigNumber": function(n, wordSize) {
-        return format6(n, { notation: "bin", wordSize });
+        return format4(n, { notation: "bin", wordSize });
       }
     });
   }
@@ -23072,13 +22159,13 @@ var dependencies78 = ["typed", "format"];
 var createHex = /* @__PURE__ */ factory(
   name78,
   dependencies78,
-  ({ typed: typed3, format: format6 }) => {
+  ({ typed: typed3, format: format4 }) => {
     return typed3(name78, {
       "number | BigNumber": function(n) {
-        return format6(n, { notation: "hex" });
+        return format4(n, { notation: "hex" });
       },
       "number | BigNumber, number | BigNumber": function(n, wordSize) {
-        return format6(n, { notation: "hex", wordSize });
+        return format4(n, { notation: "hex", wordSize });
       }
     });
   }
@@ -23090,13 +22177,13 @@ var dependencies79 = ["typed", "format"];
 var createOct = /* @__PURE__ */ factory(
   name79,
   dependencies79,
-  ({ typed: typed3, format: format6 }) => {
+  ({ typed: typed3, format: format4 }) => {
     return typed3(name79, {
       "number | BigNumber": function(n) {
-        return format6(n, { notation: "oct" });
+        return format4(n, { notation: "oct" });
       },
       "number | BigNumber, number | BigNumber": function(n, wordSize) {
-        return format6(n, { notation: "oct", wordSize });
+        return format4(n, { notation: "oct", wordSize });
       }
     });
   }
@@ -23127,9 +22214,9 @@ var dependencies81 = ["typed", "isBounded", "map"];
 var createIsFinite = /* @__PURE__ */ factory(
   name81,
   dependencies81,
-  ({ typed: typed3, isBounded: isBounded2, map: map2 }) => {
+  ({ typed: typed3, isBounded: isBounded2, map: map3 }) => {
     return typed3(name81, {
-      "Array | Matrix": (A) => map2(A, isBounded2),
+      "Array | Matrix": (A) => map3(A, isBounded2),
       any: (x) => isBounded2(x)
     });
   }
@@ -23149,7 +22236,7 @@ var createIsZero = /* @__PURE__ */ factory(
         (self) => (x) => typed3.find(self, x.valueType())(x.value)
       ),
       "Array | Matrix": typed3.referToSelf(
-        (self) => (x) => deepMap2(x, self)
+        (self) => (x) => deepMap(x, self)
       )
     });
   }
@@ -23254,7 +22341,7 @@ var createTranspose = /* @__PURE__ */ factory(
             const columns = size2[1];
             if (columns === 0) {
               throw new RangeError(
-                "Cannot transpose a 2D matrix with no columns (size: " + format3(size2, {}) + ")"
+                "Cannot transpose a 2D matrix with no columns (size: " + formatGeneric(size2, {}) + ")"
               );
             }
             switch (x.storage()) {
@@ -23269,7 +22356,7 @@ var createTranspose = /* @__PURE__ */ factory(
           break;
         default:
           throw new RangeError(
-            "Matrix must be a vector or two dimensional (size: " + format3(size2, {}) + ")"
+            "Matrix must be a vector or two dimensional (size: " + formatGeneric(size2, {}) + ")"
           );
       }
       return c;
@@ -23386,47 +22473,47 @@ var createIdentity = /* @__PURE__ */ factory(
       "": function() {
         return config2.matrix === "Matrix" ? matrix2([]) : [];
       },
-      string: function(format6) {
-        return matrix2(format6);
+      string: function(format4) {
+        return matrix2(format4);
       },
       "number | BigNumber": function(rows) {
         return _identity(rows, rows, config2.matrix === "Matrix" ? "dense" : void 0);
       },
-      "number | BigNumber, string": function(rows, format6) {
-        return _identity(rows, rows, format6);
+      "number | BigNumber, string": function(rows, format4) {
+        return _identity(rows, rows, format4);
       },
       "number | BigNumber, number | BigNumber": function(rows, cols) {
         return _identity(rows, cols, config2.matrix === "Matrix" ? "dense" : void 0);
       },
-      "number | BigNumber, number | BigNumber, string": function(rows, cols, format6) {
-        return _identity(rows, cols, format6);
+      "number | BigNumber, number | BigNumber, string": function(rows, cols, format4) {
+        return _identity(rows, cols, format4);
       },
       Array: function(size2) {
         return _identityVector(size2);
       },
-      "Array, string": function(size2, format6) {
-        return _identityVector(size2, format6);
+      "Array, string": function(size2, format4) {
+        return _identityVector(size2, format4);
       },
       Matrix: function(size2) {
         return _identityVector(size2.valueOf(), size2.storage());
       },
-      "Matrix, string": function(size2, format6) {
-        return _identityVector(size2.valueOf(), format6);
+      "Matrix, string": function(size2, format4) {
+        return _identityVector(size2.valueOf(), format4);
       }
     });
-    function _identityVector(size2, format6) {
+    function _identityVector(size2, format4) {
       switch (size2.length) {
         case 0:
-          return format6 ? matrix2(format6) : [];
+          return format4 ? matrix2(format4) : [];
         case 1:
-          return _identity(size2[0], size2[0], format6);
+          return _identity(size2[0], size2[0], format4);
         case 2:
-          return _identity(size2[0], size2[1], format6);
+          return _identity(size2[0], size2[1], format4);
         default:
           throw new Error("Vector containing two values expected");
       }
     }
-    function _identity(rows, cols, format6) {
+    function _identity(rows, cols, format4) {
       const Big = isBigNumber(rows) || isBigNumber(cols) ? BigNumber9 : null;
       if (isBigNumber(rows)) rows = rows.toNumber();
       if (isBigNumber(cols)) cols = cols.toNumber();
@@ -23439,14 +22526,14 @@ var createIdentity = /* @__PURE__ */ factory(
       const one = Big ? new BigNumber9(1) : 1;
       const defaultValue = Big ? new Big(0) : 0;
       const size2 = [rows, cols];
-      if (format6) {
-        if (format6 === "sparse") {
+      if (format4) {
+        if (format4 === "sparse") {
           return SparseMatrix.diagonal(size2, one, 0, defaultValue);
         }
-        if (format6 === "dense") {
+        if (format4 === "dense") {
           return DenseMatrix6.diagonal(size2, one, 0, defaultValue);
         }
-        throw new TypeError(`Unknown matrix type "${format6}"`);
+        throw new TypeError(`Unknown matrix type "${format4}"`);
       }
       const res = resize([], size2, defaultValue);
       const minimum = rows < cols ? rows : cols;
@@ -23467,10 +22554,10 @@ function createZerosAndOnes(name254, defaultValue, { typed: typed3, config: conf
     // math.zeros/ones(m, n, p, ..., format)
     // TODO: more accurate signature '...number | BigNumber, string' as soon as typed-function supports this
     "...number | BigNumber | string": function(size2) {
-      const last = size2[size2.length - 1];
-      if (typeof last === "string") {
-        const format6 = size2.pop();
-        return _zerosAndOnes(size2, format6);
+      const last2 = size2[size2.length - 1];
+      if (typeof last2 === "string") {
+        const format4 = size2.pop();
+        return _zerosAndOnes(size2, format4);
       } else if (config2.matrix === "Array") {
         return _zerosAndOnes(size2);
       } else {
@@ -23479,20 +22566,20 @@ function createZerosAndOnes(name254, defaultValue, { typed: typed3, config: conf
     },
     Array: _zerosAndOnes,
     Matrix: function(size2) {
-      const format6 = size2.storage();
-      return _zerosAndOnes(size2.valueOf(), format6);
+      const format4 = size2.storage();
+      return _zerosAndOnes(size2.valueOf(), format4);
     },
-    "Array | Matrix, string": function(size2, format6) {
+    "Array | Matrix, string": function(size2, format4) {
       const sizeArray = Array.isArray(size2) ? size2 : size2.valueOf();
-      return _zerosAndOnes(sizeArray, format6);
+      return _zerosAndOnes(sizeArray, format4);
     }
   });
-  function _zerosAndOnes(size2, format6) {
+  function _zerosAndOnes(size2, format4) {
     const hasBigNumbers = _normalize(size2);
     const dflt = hasBigNumbers ? new BigNumber9(defaultValue) : defaultValue;
     _validate(size2);
-    if (format6) {
-      const m = matrix2(format6);
+    if (format4) {
+      const m = matrix2(format4);
       if (size2.length > 0) {
         return m.resize(size2, dflt);
       }
@@ -23564,14 +22651,14 @@ var createDiag = /* @__PURE__ */ factory(
       "Array, BigNumber": function(x, k) {
         return _diag(x, k.toNumber(), arraySize(x), null);
       },
-      "Array, string": function(x, format6) {
-        return _diag(x, 0, arraySize(x), format6);
+      "Array, string": function(x, format4) {
+        return _diag(x, 0, arraySize(x), format4);
       },
-      "Array, number, string": function(x, k, format6) {
-        return _diag(x, k, arraySize(x), format6);
+      "Array, number, string": function(x, k, format4) {
+        return _diag(x, k, arraySize(x), format4);
       },
-      "Array, BigNumber, string": function(x, k, format6) {
-        return _diag(x, k.toNumber(), arraySize(x), format6);
+      "Array, BigNumber, string": function(x, k, format4) {
+        return _diag(x, k.toNumber(), arraySize(x), format4);
       },
       Matrix: function(x) {
         return _diag(x, 0, x.size(), x.storage());
@@ -23582,17 +22669,17 @@ var createDiag = /* @__PURE__ */ factory(
       "Matrix, BigNumber": function(x, k) {
         return _diag(x, k.toNumber(), x.size(), x.storage());
       },
-      "Matrix, string": function(x, format6) {
-        return _diag(x, 0, x.size(), format6);
+      "Matrix, string": function(x, format4) {
+        return _diag(x, 0, x.size(), format4);
       },
-      "Matrix, number, string": function(x, k, format6) {
-        return _diag(x, k, x.size(), format6);
+      "Matrix, number, string": function(x, k, format4) {
+        return _diag(x, k, x.size(), format4);
       },
-      "Matrix, BigNumber, string": function(x, k, format6) {
-        return _diag(x, k.toNumber(), x.size(), format6);
+      "Matrix, BigNumber, string": function(x, k, format4) {
+        return _diag(x, k.toNumber(), x.size(), format4);
       }
     });
-    function _diag(x, k, size2, format6) {
+    function _diag(x, k, size2, format4) {
       if (!isInteger(k)) {
         throw new TypeError("Second parameter in function diag must be an integer");
       }
@@ -23600,26 +22687,26 @@ var createDiag = /* @__PURE__ */ factory(
       const kSub = k < 0 ? -k : 0;
       switch (size2.length) {
         case 1:
-          return _createDiagonalMatrix(x, k, format6, size2[0], kSub, kSuper);
+          return _createDiagonalMatrix(x, k, format4, size2[0], kSub, kSuper);
         case 2:
-          return _getDiagonal(x, k, format6, size2, kSub, kSuper);
+          return _getDiagonal(x, k, format4, size2, kSub, kSuper);
       }
       throw new RangeError("Matrix for function diag must be 2 dimensional");
     }
-    function _createDiagonalMatrix(x, k, format6, l, kSub, kSuper) {
+    function _createDiagonalMatrix(x, k, format4, l, kSub, kSuper) {
       const ms = [l + kSub, l + kSuper];
-      if (format6 && format6 !== "sparse" && format6 !== "dense") {
-        throw new TypeError(`Unknown matrix type ${format6}"`);
+      if (format4 && format4 !== "sparse" && format4 !== "dense") {
+        throw new TypeError(`Unknown matrix type ${format4}"`);
       }
-      const m = format6 === "sparse" ? SparseMatrix.diagonal(ms, x, k) : DenseMatrix6.diagonal(ms, x, k);
-      return format6 !== null ? m : m.valueOf();
+      const m = format4 === "sparse" ? SparseMatrix.diagonal(ms, x, k) : DenseMatrix6.diagonal(ms, x, k);
+      return format4 !== null ? m : m.valueOf();
     }
-    function _getDiagonal(x, k, format6, s, kSub, kSuper) {
+    function _getDiagonal(x, k, format4, s, kSub, kSuper) {
       if (isMatrix(x)) {
         const dm = x.diagonal(k);
-        if (format6 !== null) {
-          if (format6 !== dm.storage()) {
-            return matrix2(dm.valueOf(), format6);
+        if (format4 !== null) {
+          if (format4 !== dm.storage()) {
+            return matrix2(dm.valueOf(), format4);
           }
           return dm;
         }
@@ -23630,7 +22717,7 @@ var createDiag = /* @__PURE__ */ factory(
       for (let i = 0; i < n; i++) {
         vector[i] = x[i + kSub][i + kSuper];
       }
-      return format6 !== null ? matrix2(vector) : vector;
+      return format4 !== null ? matrix2(vector) : vector;
     }
   }
 );
@@ -23748,11 +22835,11 @@ var createMatrixFromFunction = /* @__PURE__ */ factory(
     isZero: isZero2
   }) => {
     return typed3(name91, {
-      "Array | Matrix, function, string, string": function(size2, fn, format6, datatype) {
-        return _create(size2, fn, format6, datatype);
+      "Array | Matrix, function, string, string": function(size2, fn, format4, datatype) {
+        return _create(size2, fn, format4, datatype);
       },
-      "Array | Matrix, function, string": function(size2, fn, format6) {
-        return _create(size2, fn, format6, void 0);
+      "Array | Matrix, function, string": function(size2, fn, format4) {
+        return _create(size2, fn, format4, void 0);
       },
       "Matrix, function": function(size2, fn) {
         return _create(size2, fn, "dense", void 0);
@@ -23760,19 +22847,19 @@ var createMatrixFromFunction = /* @__PURE__ */ factory(
       "Array, function": function(size2, fn) {
         return _create(size2, fn, "dense", void 0).toArray();
       },
-      "Array | Matrix, string, function": function(size2, format6, fn) {
-        return _create(size2, fn, format6, void 0);
+      "Array | Matrix, string, function": function(size2, format4, fn) {
+        return _create(size2, fn, format4, void 0);
       },
-      "Array | Matrix, string, string, function": function(size2, format6, datatype, fn) {
-        return _create(size2, fn, format6, datatype);
+      "Array | Matrix, string, string, function": function(size2, format4, datatype, fn) {
+        return _create(size2, fn, format4, datatype);
       }
     });
-    function _create(size2, fn, format6, datatype) {
+    function _create(size2, fn, format4, datatype) {
       let m;
       if (datatype !== void 0) {
-        m = matrix2(format6, datatype);
+        m = matrix2(format4, datatype);
       } else {
-        m = matrix2(format6);
+        m = matrix2(format4);
       }
       m.resize(size2);
       m.forEach(function(_, index) {
@@ -23958,7 +23045,7 @@ var createTrace = /* @__PURE__ */ factory(
           if (size2[0] === 1) {
             return clone(data[0]);
           }
-          throw new RangeError("Matrix must be square (size: " + format3(size2, {}) + ")");
+          throw new RangeError("Matrix must be square (size: " + formatGeneric(size2, {}) + ")");
         case 2: {
           const rows = size2[0];
           const cols = size2[1];
@@ -23969,11 +23056,11 @@ var createTrace = /* @__PURE__ */ factory(
             }
             return sum3;
           } else {
-            throw new RangeError("Matrix must be square (size: " + format3(size2, {}) + ")");
+            throw new RangeError("Matrix must be square (size: " + formatGeneric(size2, {}) + ")");
           }
         }
         default:
-          throw new RangeError("Matrix must be two dimensional (size: " + format3(size2, {}) + ")");
+          throw new RangeError("Matrix must be two dimensional (size: " + formatGeneric(size2, {}) + ")");
       }
     }
     function _sparseTrace(m) {
@@ -24003,7 +23090,7 @@ var createTrace = /* @__PURE__ */ factory(
         }
         return sum3;
       }
-      throw new RangeError("Matrix must be square (size: " + format3(size2, {}) + ")");
+      throw new RangeError("Matrix must be square (size: " + formatGeneric(size2, {}) + ")");
     }
   }
 );
@@ -24070,7 +23157,7 @@ var createDet = /* @__PURE__ */ factory(
             if (size2[0] === 0) {
               return 1;
             } else {
-              throw new RangeError("Matrix must be square (size: " + format3(size2, {}) + ")");
+              throw new RangeError("Matrix must be square (size: " + formatGeneric(size2, {}) + ")");
             }
           case 2: {
             const rows = size2[0];
@@ -24081,12 +23168,12 @@ var createDet = /* @__PURE__ */ factory(
             if (cols === 0) {
               return 1;
             } else {
-              throw new RangeError("Matrix must be square (size: " + format3(size2, {}) + ")");
+              throw new RangeError("Matrix must be square (size: " + formatGeneric(size2, {}) + ")");
             }
           }
           default:
             throw new RangeError(
-              "Matrix must be two dimensional (size: " + format3(size2, {}) + ")"
+              "Matrix must be two dimensional (size: " + formatGeneric(size2, {}) + ")"
             );
         }
       }
@@ -24416,14 +23503,14 @@ var createCsAmd = /* @__PURE__ */ factory(
       const degree2 = 5 * (n + 1);
       const w = 6 * (n + 1);
       const hhead = 7 * (n + 1);
-      const last = P2;
+      const last2 = P2;
       let mark = _initializeQuotientGraph(
         n,
         cptr,
         W,
         len,
         head,
-        last,
+        last2,
         next,
         hhead,
         nv,
@@ -24431,13 +23518,13 @@ var createCsAmd = /* @__PURE__ */ factory(
         elen,
         degree2
       );
-      let nel = _initializeDegreeLists(n, cptr, W, degree2, elen, w, dense, nv, head, last, next);
+      let nel = _initializeDegreeLists(n, cptr, W, degree2, elen, w, dense, nv, head, last2, next);
       let mindeg = 0;
       let i, j, k, k1, k2, e, pj, ln, nvi, pk, eln, p1, p2, pn, h, d;
       while (nel < n) {
         for (k = -1; mindeg < n && (k = W[head + mindeg]) === -1; mindeg++) ;
         if (W[next + k] !== -1) {
-          last[W[next + k]] = -1;
+          last2[W[next + k]] = -1;
         }
         W[head + mindeg] = W[next + k];
         const elenk = W[elen + k];
@@ -24467,10 +23554,10 @@ var createCsAmd = /* @__PURE__ */ factory(
             W[nv + i] = -nvi;
             cindex[pk2++] = i;
             if (W[next + i] !== -1) {
-              last[W[next + i]] = last[i];
+              last2[W[next + i]] = last2[i];
             }
-            if (last[i] !== -1) {
-              W[next + last[i]] = W[next + i];
+            if (last2[i] !== -1) {
+              W[next + last2[i]] = W[next + i];
             } else {
               W[head + W[degree2 + i]] = W[next + i];
             }
@@ -24553,7 +23640,7 @@ var createCsAmd = /* @__PURE__ */ factory(
             h = (h < 0 ? -h : h) % n;
             W[next + i] = W[hhead + h];
             W[hhead + h] = i;
-            last[i] = h;
+            last2[i] = h;
           }
         }
         W[degree2 + k] = dk;
@@ -24564,7 +23651,7 @@ var createCsAmd = /* @__PURE__ */ factory(
           if (W[nv + i] >= 0) {
             continue;
           }
-          h = last[i];
+          h = last2[i];
           i = W[hhead + h];
           W[hhead + h] = -1;
           for (; i !== -1 && W[next + i] !== -1; i = W[next + i], mark++) {
@@ -24604,10 +23691,10 @@ var createCsAmd = /* @__PURE__ */ factory(
           d = W[degree2 + i] + dk - nvi;
           d = Math.min(d, n - nel - nvi);
           if (W[head + d] !== -1) {
-            last[W[head + d]] = i;
+            last2[W[head + d]] = i;
           }
           W[next + i] = W[head + d];
-          last[i] = -1;
+          last2[i] = -1;
           W[head + d] = i;
           mindeg = Math.min(mindeg, d);
           W[degree2 + i] = d;
@@ -24677,14 +23764,14 @@ var createCsAmd = /* @__PURE__ */ factory(
       }
       return multiply2(at, a);
     }
-    function _initializeQuotientGraph(n, cptr, W, len, head, last, next, hhead, nv, w, elen, degree2) {
+    function _initializeQuotientGraph(n, cptr, W, len, head, last2, next, hhead, nv, w, elen, degree2) {
       for (let k = 0; k < n; k++) {
         W[len + k] = cptr[k + 1] - cptr[k];
       }
       W[len + n] = 0;
       for (let i = 0; i <= n; i++) {
         W[head + i] = -1;
-        last[i] = -1;
+        last2[i] = -1;
         W[next + i] = -1;
         W[hhead + i] = -1;
         W[nv + i] = 1;
@@ -24698,7 +23785,7 @@ var createCsAmd = /* @__PURE__ */ factory(
       W[w + n] = 0;
       return mark;
     }
-    function _initializeDegreeLists(n, cptr, W, degree2, elen, w, dense, nv, head, last, next) {
+    function _initializeDegreeLists(n, cptr, W, degree2, elen, w, dense, nv, head, last2, next) {
       let nel = 0;
       for (let i = 0; i < n; i++) {
         const d = W[degree2 + i];
@@ -24716,7 +23803,7 @@ var createCsAmd = /* @__PURE__ */ factory(
         } else {
           const h = W[head + d];
           if (h !== -1) {
-            last[h] = i;
+            last2[h] = i;
           }
           W[next + i] = W[head + d];
           W[head + d] = i;
@@ -25186,12 +24273,12 @@ function createSolveValidation({ DenseMatrix: DenseMatrix6 }) {
   return function solveValidation(m, b, copy) {
     const mSize = m.size();
     if (mSize.length !== 2) {
-      throw new RangeError("Matrix must be two dimensional (size: " + format3(mSize, {}) + ")");
+      throw new RangeError("Matrix must be two dimensional (size: " + formatGeneric(mSize, {}) + ")");
     }
     const rows = mSize[0];
     const columns = mSize[1];
     if (rows !== columns) {
-      throw new RangeError("Matrix must be square (size: " + format3(mSize, {}) + ")");
+      throw new RangeError("Matrix must be square (size: " + formatGeneric(mSize, {}) + ")");
     }
     let data = [];
     if (isMatrix(b)) {
@@ -26354,7 +25441,7 @@ var createRound = /* @__PURE__ */ factory(
       ),
       "Array | Matrix, number | BigNumber, Unit": typed3.referToSelf(
         (self) => (x, n, unit2) => {
-          return deepMap2(x, (value) => self(value, n, unit2), true);
+          return deepMap(x, (value) => self(value, n, unit2), true);
         }
       ),
       "Array | Matrix | Unit, Unit": typed3.referToSelf(
@@ -26362,7 +25449,7 @@ var createRound = /* @__PURE__ */ factory(
       ),
       "Array | Matrix": typed3.referToSelf(
         (self) => (x) => {
-          return deepMap2(x, self, true);
+          return deepMap(x, self, true);
         }
       ),
       "SparseMatrix, number | BigNumber": typed3.referToSelf(
@@ -26536,6 +25623,12 @@ var createCatalan = /* @__PURE__ */ factory(
   }
 );
 
+// src/error/IndexError.ts
+import { IndexError, createIndexError } from "@danielsimonjr/mathts-core/internal";
+
+// src/error/DimensionError.ts
+import { DimensionError } from "@danielsimonjr/mathts-core/internal";
+
 // src/matrix/concat.ts
 var name115 = "concat";
 var dependencies115 = ["typed", "matrix", "isInteger"];
@@ -26657,7 +25750,7 @@ var createInv = /* @__PURE__ */ factory(
                 return [divideScalar2(1, x[0])];
               }
             } else {
-              throw new RangeError("Matrix must be square (size: " + format3(size2, {}) + ")");
+              throw new RangeError("Matrix must be square (size: " + formatGeneric(size2, {}) + ")");
             }
           case 2: {
             const rows = size2[0];
@@ -26671,12 +25764,12 @@ var createInv = /* @__PURE__ */ factory(
                 return _inv4(x, rows, cols);
               }
             } else {
-              throw new RangeError("Matrix must be square (size: " + format3(size2, {}) + ")");
+              throw new RangeError("Matrix must be square (size: " + formatGeneric(size2, {}) + ")");
             }
           }
           default:
             throw new RangeError(
-              "Matrix must be two dimensional (size: " + format3(size2, {}) + ")"
+              "Matrix must be two dimensional (size: " + formatGeneric(size2, {}) + ")"
             );
         }
       },
@@ -26833,7 +25926,7 @@ function _mapSlices(mat, dim, callback) {
     if (!Array.isArray(mat[0])) {
       return callback(mat);
     } else {
-      tran = _switch2(mat);
+      tran = _switch(mat);
       ret = [];
       for (i = 0; i < tran.length; i++) {
         ret[i] = _mapSlices(tran[i], dim - 1, callback);
@@ -26848,7 +25941,7 @@ function _mapSlices(mat, dim, callback) {
     return ret;
   }
 }
-function _switch2(mat) {
+function _switch(mat) {
   const I2 = mat.length;
   const J = mat[0].length;
   let i, j;
@@ -26872,13 +25965,13 @@ var createResize = /* @__PURE__ */ factory(
   ({ typed: typed3, config: config2, matrix: matrix2 }) => {
     return typed3(name118, {
       "any, Array | Matrix": function(x, size2) {
-        return _resize2(x, size2);
+        return _resize(x, size2);
       },
       "any, Array | Matrix, any": function(x, size2, defaultValue) {
-        return _resize2(x, size2, defaultValue);
+        return _resize(x, size2, defaultValue);
       }
     });
-    function _resize2(x, size2, defaultValue) {
+    function _resize(x, size2, defaultValue) {
       let sz = isMatrix(size2) ? size2.valueOf() : size2;
       if (isBigNumber(sz[0])) {
         sz = sz.map(function(value) {
@@ -26919,7 +26012,7 @@ var createResize = /* @__PURE__ */ factory(
       const len = size2[0];
       if (typeof len !== "number" || !isInteger(len)) {
         throw new TypeError(
-          "Invalid size, must contain positive integers (size: " + format3(size2, {}) + ")"
+          "Invalid size, must contain positive integers (size: " + formatGeneric(size2, {}) + ")"
         );
       }
       if (str.length > len) {
@@ -27731,7 +26824,7 @@ var createIsInteger = /* @__PURE__ */ factory(
       bigint: (_b) => true,
       Fraction: (r) => r.d === 1n,
       "Array | Matrix": typed3.referToSelf(
-        (self) => (x) => deepMap2(x, self)
+        (self) => (x) => deepMap(x, self)
       )
     });
   }
@@ -27797,6 +26890,23 @@ var createZpk2tf = /* @__PURE__ */ factory(
   }
 );
 
+// src/utils/switch.ts
+function _switch2(mat) {
+  const rows = mat;
+  const I2 = rows.length;
+  const J = rows[0].length;
+  let i, j;
+  const ret = [];
+  for (j = 0; j < J; j++) {
+    const tmp = [];
+    for (i = 0; i < I2; i++) {
+      tmp.push(rows[i][j]);
+    }
+    ret.push(tmp);
+  }
+  return ret;
+}
+
 // src/statistics/cumsum.ts
 import { neumaierCumsum as neumaierCumsum2 } from "@danielsimonjr/mathts-core";
 function isFlatNumberArray2(arr10) {
@@ -27878,7 +26988,7 @@ var createCumSum = /* @__PURE__ */ factory(
         if (!Array.isArray(initialValue)) {
           return _cumsummap(mat);
         } else {
-          tran = _switch(mat);
+          tran = _switch2(mat);
           ret = [];
           for (i = 0; i < tran.length; i++) {
             ret[i] = _cumsumDimensional(tran[i], dim - 1);
@@ -27934,7 +27044,7 @@ var createSum = /* @__PURE__ */ factory(
         return pairwiseSum2(array);
       }
       let sum3;
-      deepForEach2(array, function(value) {
+      deepForEach(array, function(value) {
         try {
           const converted = typeof value === "string" ? parseNumberWithConfig2(value) : value;
           sum3 = sum3 === void 0 ? converted : add4(sum3, converted);
@@ -28275,7 +27385,7 @@ var createFloor = /* @__PURE__ */ factory(
       ),
       "Array | Matrix, number | BigNumber, Unit": typed3.referToSelf(
         (self) => (x, n, unit2) => {
-          return deepMap2(x, (value) => self(value, n, unit2), true);
+          return deepMap(x, (value) => self(value, n, unit2), true);
         }
       ),
       "Array | Matrix | Unit, Unit": typed3.referToSelf(
@@ -28283,12 +27393,12 @@ var createFloor = /* @__PURE__ */ factory(
       ),
       "Array | Matrix": typed3.referToSelf(
         (self) => (x) => {
-          return deepMap2(x, self, true);
+          return deepMap(x, self, true);
         }
       ),
       "Array, number | BigNumber": typed3.referToSelf(
         (self) => (x, n) => {
-          return deepMap2(x, (i) => self(i, n), true);
+          return deepMap(x, (i) => self(i, n), true);
         }
       ),
       "SparseMatrix, number | BigNumber": typed3.referToSelf(
@@ -29020,7 +28130,7 @@ var createLog1p = /* @__PURE__ */ factory(
         }
       },
       "Array | Matrix": typed3.referToSelf(
-        (self) => (x) => deepMap2(x, self)
+        (self) => (x) => deepMap(x, self)
       ),
       "any, any": typed3.referToSelf(
         (self) => (x, base) => {
@@ -29376,7 +28486,7 @@ var createCeil = /* @__PURE__ */ factory(
       ),
       "Array | Matrix, number | BigNumber, Unit": typed3.referToSelf(
         (self) => (x, n, unit2) => {
-          return deepMap2(x, (value) => self(value, n, unit2), true);
+          return deepMap(x, (value) => self(value, n, unit2), true);
         }
       ),
       "Array | Matrix | Unit, Unit": typed3.referToSelf(
@@ -29384,12 +28494,12 @@ var createCeil = /* @__PURE__ */ factory(
       ),
       "Array | Matrix": typed3.referToSelf(
         (self) => (x) => {
-          return deepMap2(x, self, true);
+          return deepMap(x, self, true);
         }
       ),
       "Array, number | BigNumber": typed3.referToSelf(
         (self) => (x, n) => {
-          return deepMap2(x, (i) => self(i, n), true);
+          return deepMap(x, (i) => self(i, n), true);
         }
       ),
       "SparseMatrix, number | BigNumber": typed3.referToSelf(
@@ -30565,7 +29675,7 @@ var createFix = /* @__PURE__ */ factory(
       ),
       "Array | Matrix, number | BigNumber, Unit": typed3.referToSelf(
         (self) => (x, n, unit2) => {
-          return deepMap2(x, (value) => self(value, n, unit2), true);
+          return deepMap(x, (value) => self(value, n, unit2), true);
         }
       ),
       "Array | Matrix | Unit, Unit": typed3.referToSelf(
@@ -30573,12 +29683,12 @@ var createFix = /* @__PURE__ */ factory(
       ),
       "Array | Matrix": typed3.referToSelf(
         (self) => (x) => {
-          return deepMap2(x, self, true);
+          return deepMap(x, self, true);
         }
       ),
       "Array | Matrix, number | BigNumber": typed3.referToSelf(
         (self) => (x, n) => {
-          return deepMap2(x, (i) => self(i, n), true);
+          return deepMap(x, (i) => self(i, n), true);
         }
       ),
       "number | Complex | Fraction | BigNumber, Array": typed3.referToSelf(
@@ -30930,7 +30040,7 @@ var createPinv = /* @__PURE__ */ factory(
           }
           default:
             throw new RangeError(
-              "Matrix must be two dimensional (size: " + format3(size2, {}) + ")"
+              "Matrix must be two dimensional (size: " + formatGeneric(size2, {}) + ")"
             );
         }
       },
@@ -31664,7 +30774,7 @@ var createMax = /* @__PURE__ */ factory(
         }
       }
       let res;
-      deepForEach2(array, function(value) {
+      deepForEach(array, function(value) {
         try {
           if (mathIsNaN(value)) {
             res = value;
@@ -31743,7 +30853,7 @@ var createMin = /* @__PURE__ */ factory(
         }
       }
       let min2;
-      deepForEach2(array, function(value) {
+      deepForEach(array, function(value) {
         try {
           if (mathIsNaN(value)) {
             min2 = value;
@@ -32275,7 +31385,7 @@ var createFactorial = /* @__PURE__ */ factory(
         return gamma2(n.add(1));
       },
       "Array | Matrix": typed3.referToSelf(
-        (self) => (n) => deepMap2(n, self)
+        (self) => (n) => deepMap(n, self)
       )
     });
   }
@@ -32646,93 +31756,14 @@ var createLeafCount = /* @__PURE__ */ factory(
 );
 
 // src/utils/map.ts
-var ObjectWrappingMap = class {
-  wrappedObject;
-  [Symbol.toStringTag] = "ObjectWrappingMap";
-  constructor(object) {
-    this.wrappedObject = object;
-  }
-  /**
-   * Declared as a real method rather than assigned in the constructor through a
-   * cast. The old form satisfied the runtime but never appeared in the emitted
-   * type, so `implements Map<K, V>` was a lie that only surfaced downstream:
-   * consumers compiling with `skipLibCheck: false` got TS2420 ("incorrectly
-   * implements interface 'Map'... '[Symbol.iterator]' is missing").
-   */
-  [Symbol.iterator]() {
-    return this.entries();
-  }
-  // @ts-expect-error: Implementation is compatible but TS can't infer it
-  keys() {
-    return Object.keys(this.wrappedObject).filter((key) => this.has(key)).values();
-  }
-  get(key) {
-    return getSafeProperty(this.wrappedObject, key);
-  }
-  set(key, value) {
-    setSafeProperty(this.wrappedObject, key, value);
-    return this;
-  }
-  has(key) {
-    return isSafeProperty(this.wrappedObject, key) && key in this.wrappedObject;
-  }
-  // @ts-expect-error: Implementation is compatible but TS can't infer it
-  entries() {
-    return mapIterator(this.keys(), (key) => [key, this.get(key)]);
-  }
-  // @ts-expect-error: Implementation is compatible but TS can't infer it
-  *values() {
-    for (const key of this.keys()) {
-      yield this.get(key);
-    }
-  }
-  forEach(callback) {
-    for (const key of this.keys()) {
-      callback(this.get(key), key, this);
-    }
-  }
-  delete(key) {
-    if (isSafeProperty(this.wrappedObject, key)) {
-      delete this.wrappedObject[key];
-      return true;
-    }
-    return false;
-  }
-  clear() {
-    for (const key of this.keys()) {
-      this.delete(key);
-    }
-  }
-  get size() {
-    return Object.keys(this.wrappedObject).length;
-  }
-};
-function mapIterator(it, callback) {
-  return {
-    next: () => {
-      const n = it.next();
-      return n.done ? n : {
-        value: callback(n.value),
-        done: false
-      };
-    }
-  };
-}
-function createEmptyMap() {
-  return /* @__PURE__ */ new Map();
-}
-function createMap2(mapOrObject) {
-  if (!mapOrObject) {
-    return createEmptyMap();
-  }
-  if (isMap(mapOrObject)) {
-    return mapOrObject;
-  }
-  if (isObject(mapOrObject)) {
-    return new ObjectWrappingMap(mapOrObject);
-  }
-  throw new Error("createMap can create maps from objects or Maps");
-}
+import {
+  ObjectWrappingMap,
+  PartitionedMap,
+  createEmptyMap,
+  createMap as createMap2,
+  assignMap,
+  isObjectWrappingMap
+} from "@danielsimonjr/mathts-core/internal";
 
 // src/algebra/resolve.ts
 var name192 = "resolve";
@@ -33259,15 +32290,15 @@ var createSimplifyConstant = /* @__PURE__ */ factory(
       const reduction = args.reduce(
         (sofar, next) => {
           if (!isNode(next)) {
-            const last = sofar.pop();
-            if (isNode(last)) {
-              return [last, next];
+            const last2 = sofar.pop();
+            if (isNode(last2)) {
+              return [last2, next];
             }
             try {
-              sofar.push(_eval(fn, [last, next], options));
+              sofar.push(_eval(fn, [last2, next], options));
               return sofar;
             } catch {
-              sofar.push(last);
+              sofar.push(last2);
             }
           }
           sofar.push(_ensureNode(sofar.pop()));
@@ -33650,7 +32681,7 @@ var createChainClass = /* @__PURE__ */ factory(
       return this.value;
     };
     Chain2.prototype.toString = function() {
-      return format3(this.value, {});
+      return formatGeneric(this.value, {});
     };
     Chain2.prototype.toJSON = function() {
       return {
@@ -33974,7 +33005,7 @@ var createIndexClass = /* @__PURE__ */ factory(
       matrix2._size = [arg3.length];
       return matrix2;
     }
-    class Index2 {
+    class Index {
       /**
        * Type identifier
        */
@@ -33999,7 +33030,7 @@ var createIndexClass = /* @__PURE__ */ factory(
        */
       _isScalar;
       constructor(...ranges) {
-        if (!(this instanceof Index2)) {
+        if (!(this instanceof Index)) {
           throw new SyntaxError("Constructor must be called with the new operator");
         }
         this._dimensions = [];
@@ -34049,7 +33080,7 @@ var createIndexClass = /* @__PURE__ */ factory(
        * @return {Index} clone
        */
       clone() {
-        const index = new Index2();
+        const index = new Index();
         index._dimensions = clone(this._dimensions);
         index._isScalar = this._isScalar;
         index._sourceSize = this._sourceSize;
@@ -34063,7 +33094,7 @@ var createIndexClass = /* @__PURE__ */ factory(
        * @private
        */
       static create(ranges) {
-        return new Index2(...ranges);
+        return new Index(...ranges);
       }
       /**
        * Retrieve the size of the index, the number of elements for each dimension.
@@ -34216,13 +33247,13 @@ var createIndexClass = /* @__PURE__ */ factory(
        * @return {Index}
        */
       static fromJSON(json) {
-        return Index2.create(json.dimensions);
+        return Index.create(json.dimensions);
       }
     }
-    const indexProto = Index2.prototype;
+    const indexProto = Index.prototype;
     indexProto.type = "Index";
     indexProto.isIndex = true;
-    return Index2;
+    return Index;
   },
   { isClass: true }
 );
@@ -34319,7 +33350,7 @@ var createUnitFunction = /* @__PURE__ */ factory(
         return new Unit2(value);
       },
       "Array | Matrix": typed3.referToSelf(
-        (self) => (x) => deepMap2(x, self)
+        (self) => (x) => deepMap(x, self)
       )
     });
   }
@@ -34806,7 +33837,7 @@ var dependencies207 = ["typed", "Index", "matrix", "range"];
 var createColumn = /* @__PURE__ */ factory(
   name207,
   dependencies207,
-  ({ typed: typed3, Index: Index2, matrix: matrix2, range: range2 }) => {
+  ({ typed: typed3, Index, matrix: matrix2, range: range2 }) => {
     return typed3(name207, {
       "Matrix, number": _column,
       "Array, number": function(value, column2) {
@@ -34819,7 +33850,7 @@ var createColumn = /* @__PURE__ */ factory(
       }
       validateIndex(column2, value.size()[1]);
       const rowRange = range2(0, value.size()[0]);
-      const index = new Index2(rowRange, [column2]);
+      const index = new Index(rowRange, [column2]);
       const result = value.subset(index);
       return isMatrix(result) ? result : matrix2([[result]]);
     }
@@ -34832,7 +33863,7 @@ var dependencies208 = ["typed", "Index", "matrix", "range"];
 var createRow = /* @__PURE__ */ factory(
   name208,
   dependencies208,
-  ({ typed: typed3, Index: Index2, matrix: matrix2, range: range2 }) => {
+  ({ typed: typed3, Index, matrix: matrix2, range: range2 }) => {
     return typed3(name208, {
       "Matrix, number": _row,
       "Array, number": function(value, row2) {
@@ -34845,7 +33876,7 @@ var createRow = /* @__PURE__ */ factory(
       }
       validateIndex(row2, value.size()[0]);
       const columnRange = range2(0, value.size()[1]);
-      const index = new Index2([row2], columnRange);
+      const index = new Index([row2], columnRange);
       const result = value.subset(index);
       return isMatrix(result) ? result : matrix2([[result]]);
     }
@@ -34887,15 +33918,15 @@ var createCross = /* @__PURE__ */ factory(
           "Vectors with length 3 expected (Size A = [" + xSize.join(", ") + "], B = [" + ySize.join(", ") + "])"
         );
       }
-      const product3 = [
+      const product2 = [
         subtract3(multiply2(x[1], y[2]), multiply2(x[2], y[1])),
         subtract3(multiply2(x[2], y[0]), multiply2(x[0], y[2])),
         subtract3(multiply2(x[0], y[1]), multiply2(x[1], y[0]))
       ];
       if (highestDimension > 1) {
-        return [product3];
+        return [product2];
       } else {
-        return product3;
+        return product2;
       }
     }
   }
@@ -35008,7 +34039,7 @@ var dependencies211 = [
 var createSqrtm = /* @__PURE__ */ factory(
   name211,
   dependencies211,
-  ({ typed: typed3, abs: abs2, add: add4, multiply: multiply2, map: map2, sqrt: sqrt2, subtract: subtract3, inv: inv3, size: size2, max: max2, identity: identity2 }) => {
+  ({ typed: typed3, abs: abs2, add: add4, multiply: multiply2, map: map3, sqrt: sqrt2, subtract: subtract3, inv: inv3, size: size2, max: max2, identity: identity2 }) => {
     const _maxIterations = 1e3;
     const _tolerance = 1e-6;
     function _tryWasmSqrtm(A, n) {
@@ -35089,10 +34120,10 @@ var createSqrtm = /* @__PURE__ */ factory(
         switch (sizeArray.length) {
           case 1:
             if (sizeArray[0] === 1) {
-              return map2(A, sqrt2);
+              return map3(A, sqrt2);
             } else {
               throw new RangeError(
-                "Matrix must be square (size: " + format3(sizeArray, {}) + ")"
+                "Matrix must be square (size: " + formatGeneric(sizeArray, {}) + ")"
               );
             }
           case 2: {
@@ -35104,13 +34135,13 @@ var createSqrtm = /* @__PURE__ */ factory(
               return _denmanBeavers(A);
             } else {
               throw new RangeError(
-                "Matrix must be square (size: " + format3(sizeArray, {}) + ")"
+                "Matrix must be square (size: " + formatGeneric(sizeArray, {}) + ")"
               );
             }
           }
           default:
             throw new RangeError(
-              "Matrix must be at most two dimensional (size: " + format3(sizeArray, {}) + ")"
+              "Matrix must be at most two dimensional (size: " + formatGeneric(sizeArray, {}) + ")"
             );
         }
       }
@@ -36326,7 +35357,7 @@ var createMean = /* @__PURE__ */ factory(
       }
       let sum3;
       let num2 = 0;
-      deepForEach2(array, function(value) {
+      deepForEach(array, function(value) {
         try {
           sum3 = sum3 === void 0 ? value : add4(sum3, value);
           num2++;
@@ -36467,7 +35498,7 @@ var createVariance = /* @__PURE__ */ factory(
       }
       let sum3;
       let num2 = 0;
-      deepForEach2(array, function(value) {
+      deepForEach(array, function(value) {
         try {
           sum3 = sum3 === void 0 ? value : add4(sum3, value);
           num2++;
@@ -36478,7 +35509,7 @@ var createVariance = /* @__PURE__ */ factory(
       if (num2 === 0) throw new Error("Cannot calculate variance of an empty array");
       const mean7 = divide2(sum3, num2);
       sum3 = void 0;
-      deepForEach2(array, function(value) {
+      deepForEach(array, function(value) {
         const diff2 = subtract3(value, mean7);
         sum3 = sum3 === void 0 ? multiply2(diff2, diff2) : add4(sum3, multiply2(diff2, diff2));
       });
@@ -36696,7 +35727,7 @@ var createKldivergence = /* @__PURE__ */ factory(
     divide: divide2,
     sum: sum3,
     multiply: multiply2,
-    map: map2,
+    map: map3,
     dotDivide: dotDivide2,
     log: log3,
     isNumeric: isNumeric2
@@ -36740,7 +35771,7 @@ var createKldivergence = /* @__PURE__ */ factory(
       const result = sum3(
         multiply2(
           qnorm,
-          map2(dotDivide2(qnorm, pnorm), (x) => log3(x))
+          map3(dotDivide2(qnorm, pnorm), (x) => log3(x))
         )
       );
       if (isNumeric2(result)) {
@@ -36763,7 +35794,7 @@ var createMultinomial = /* @__PURE__ */ factory(
       "Array | Matrix": function(a) {
         let sum3 = 0;
         let denom = 1;
-        deepForEach2(a, function(ai) {
+        deepForEach(a, function(ai) {
           if (!isInteger3(ai) || !isPositive2(ai)) {
             throw new TypeError("Positive integer value expected in function multinomial");
           }
@@ -36913,11 +35944,11 @@ var dependencies226 = ["typed", "size", "subset", "compareNatural", "Index", "De
 var createSetCartesian = /* @__PURE__ */ factory(
   name226,
   dependencies226,
-  ({ typed: typed3, size: size2, subset: subset2, compareNatural: compareNatural3, Index: Index2, DenseMatrix: DenseMatrix6 }) => {
+  ({ typed: typed3, size: size2, subset: subset2, compareNatural: compareNatural3, Index, DenseMatrix: DenseMatrix6 }) => {
     return typed3(name226, {
       "Array | Matrix, Array | Matrix": function(a1, a2) {
         let result = [];
-        if (subset2(size2(a1), new Index2(0)) !== 0 && subset2(size2(a2), new Index2(0)) !== 0) {
+        if (subset2(size2(a1), new Index(0)) !== 0 && subset2(size2(a2), new Index(0)) !== 0) {
           const b1 = flatten2(Array.isArray(a1) ? a1 : a1.toArray()).sort(compareNatural3);
           const b2 = flatten2(Array.isArray(a2) ? a2 : a2.toArray()).sort(compareNatural3);
           result = [];
@@ -36942,13 +35973,13 @@ var dependencies227 = ["typed", "size", "subset", "compareNatural", "Index", "De
 var createSetDifference = /* @__PURE__ */ factory(
   name227,
   dependencies227,
-  ({ typed: typed3, size: size2, subset: subset2, compareNatural: compareNatural3, Index: Index2, DenseMatrix: DenseMatrix6 }) => {
+  ({ typed: typed3, size: size2, subset: subset2, compareNatural: compareNatural3, Index, DenseMatrix: DenseMatrix6 }) => {
     return typed3(name227, {
       "Array | Matrix, Array | Matrix": function(a1, a2) {
         let result;
-        if (subset2(size2(a1), new Index2(0)) === 0) {
+        if (subset2(size2(a1), new Index(0)) === 0) {
           result = [];
-        } else if (subset2(size2(a2), new Index2(0)) === 0) {
+        } else if (subset2(size2(a2), new Index(0)) === 0) {
           return flatten2(a1.toArray());
         } else {
           const b1 = identify2(flatten2(Array.isArray(a1) ? a1 : a1.toArray()).sort(compareNatural3));
@@ -36983,11 +36014,11 @@ var dependencies228 = ["typed", "size", "subset", "compareNatural", "Index", "De
 var createSetDistinct = /* @__PURE__ */ factory(
   name228,
   dependencies228,
-  ({ typed: typed3, size: size2, subset: subset2, compareNatural: compareNatural3, Index: Index2, DenseMatrix: DenseMatrix6 }) => {
+  ({ typed: typed3, size: size2, subset: subset2, compareNatural: compareNatural3, Index, DenseMatrix: DenseMatrix6 }) => {
     return typed3(name228, {
       "Array | Matrix": function(a) {
         let result;
-        if (subset2(size2(a), new Index2(0)) === 0) {
+        if (subset2(size2(a), new Index(0)) === 0) {
           result = [];
         } else {
           const b = flatten2(Array.isArray(a) ? a : a.toArray()).sort(compareNatural3);
@@ -37014,11 +36045,11 @@ var dependencies229 = ["typed", "size", "subset", "compareNatural", "Index", "De
 var createSetIntersect = /* @__PURE__ */ factory(
   name229,
   dependencies229,
-  ({ typed: typed3, size: size2, subset: subset2, compareNatural: compareNatural3, Index: Index2, DenseMatrix: DenseMatrix6 }) => {
+  ({ typed: typed3, size: size2, subset: subset2, compareNatural: compareNatural3, Index, DenseMatrix: DenseMatrix6 }) => {
     return typed3(name229, {
       "Array | Matrix, Array | Matrix": function(a1, a2) {
         let result;
-        if (subset2(size2(a1), new Index2(0)) === 0 || subset2(size2(a2), new Index2(0)) === 0) {
+        if (subset2(size2(a1), new Index(0)) === 0 || subset2(size2(a2), new Index(0)) === 0) {
           result = [];
         } else {
           const b1 = identify2(flatten2(Array.isArray(a1) ? a1 : a1.toArray()).sort(compareNatural3));
@@ -37048,12 +36079,12 @@ var dependencies230 = ["typed", "size", "subset", "compareNatural", "Index"];
 var createSetIsSubset = /* @__PURE__ */ factory(
   name230,
   dependencies230,
-  ({ typed: typed3, size: size2, subset: subset2, compareNatural: compareNatural3, Index: Index2 }) => {
+  ({ typed: typed3, size: size2, subset: subset2, compareNatural: compareNatural3, Index }) => {
     return typed3(name230, {
       "Array | Matrix, Array | Matrix": function(a1, a2) {
-        if (subset2(size2(a1), new Index2(0)) === 0) {
+        if (subset2(size2(a1), new Index(0)) === 0) {
           return true;
-        } else if (subset2(size2(a2), new Index2(0)) === 0) {
+        } else if (subset2(size2(a2), new Index(0)) === 0) {
           return false;
         }
         const b1 = identify2(flatten2(Array.isArray(a1) ? a1 : a1.toArray()).sort(compareNatural3));
@@ -37083,10 +36114,10 @@ var dependencies231 = ["typed", "size", "subset", "compareNatural", "Index"];
 var createSetMultiplicity = /* @__PURE__ */ factory(
   name231,
   dependencies231,
-  ({ typed: typed3, size: size2, subset: subset2, compareNatural: compareNatural3, Index: Index2 }) => {
+  ({ typed: typed3, size: size2, subset: subset2, compareNatural: compareNatural3, Index }) => {
     return typed3(name231, {
       "number | BigNumber | Fraction | Complex, Array | Matrix": function(e, a) {
-        if (subset2(size2(a), new Index2(0)) === 0) {
+        if (subset2(size2(a), new Index(0)) === 0) {
           return 0;
         }
         const b = flatten2(Array.isArray(a) ? a : a.toArray());
@@ -37108,10 +36139,10 @@ var dependencies232 = ["typed", "size", "subset", "compareNatural", "Index"];
 var createSetPowerset = /* @__PURE__ */ factory(
   name232,
   dependencies232,
-  ({ typed: typed3, size: size2, subset: subset2, compareNatural: compareNatural3, Index: Index2 }) => {
+  ({ typed: typed3, size: size2, subset: subset2, compareNatural: compareNatural3, Index }) => {
     return typed3(name232, {
       "Array | Matrix": function(a) {
-        if (subset2(size2(a), new Index2(0)) === 0) {
+        if (subset2(size2(a), new Index(0)) === 0) {
           return [];
         }
         const b = flatten2(Array.isArray(a) ? a : a.toArray()).sort(compareNatural3);
@@ -37501,9 +36532,9 @@ var createSimplifyCore = /* @__PURE__ */ factory(
         if (op) {
           if (fnode.args.length > 2 && hasProperty(node, "associative", context)) {
             while (fnode.args.length > 2) {
-              const last = fnode.args.pop();
+              const last2 = fnode.args.pop();
               const seclast = fnode.args.pop();
-              fnode.args.push(new OperatorNode(op, fnode.name, [last, seclast]));
+              fnode.args.push(new OperatorNode(op, fnode.name, [last2, seclast]));
             }
           }
           node = new OperatorNode(op, fnode.name, fnode.args);
@@ -37929,7 +36960,7 @@ var dependencies236 = ["typed", "Index"];
 var createIndex = /* @__PURE__ */ factory(
   name236,
   dependencies236,
-  ({ typed: typed3, Index: Index2 }) => {
+  ({ typed: typed3, Index }) => {
     return typed3(name236, {
       "...number | string | BigNumber | Range | Array | Matrix": function(args) {
         const ranges = args.map(function(arg3) {
@@ -37943,7 +36974,7 @@ var createIndex = /* @__PURE__ */ factory(
             return arg3;
           }
         });
-        return new Index2(...ranges);
+        return new Index(...ranges);
       }
     });
   }
@@ -38054,9 +37085,9 @@ function createComplexEigs({
     if (findVectors) {
       Rdiag = Array(N).fill(one);
     }
-    let last = false;
-    while (!last) {
-      last = true;
+    let last2 = false;
+    while (!last2) {
+      last2 = true;
       for (let i = 0; i < N; i++) {
         let colNorm = realzero;
         let rowNorm = realzero;
@@ -38083,7 +37114,7 @@ function createComplexEigs({
             multiplyScalar2(addScalar2(colNorm, rowNorm), 0.95)
           );
           if (condition) {
-            last = false;
+            last2 = false;
             const g = divideScalar2(1, f);
             for (let j = 0; j < N; j++) {
               if (i === j) {
@@ -38949,7 +37980,7 @@ var createEigs = /* @__PURE__ */ factory(
       const arr10 = mat.toArray();
       const asize = mat.size();
       if (asize.length !== 2 || asize[0] !== asize[1]) {
-        throw new RangeError(`Matrix must be square (size: ${format3(asize, {})})`);
+        throw new RangeError(`Matrix must be square (size: ${formatGeneric(asize, {})})`);
       }
       const N = asize[0];
       if (isReal(arr10, N, prec)) {
@@ -39347,7 +38378,7 @@ var dependencies240 = ["typed", "abs", "map", "median", "subtract"];
 var createMad = /* @__PURE__ */ factory(
   name240,
   dependencies240,
-  ({ typed: typed3, abs: abs2, map: map2, median: median2, subtract: subtract3 }) => {
+  ({ typed: typed3, abs: abs2, map: map3, median: median2, subtract: subtract3 }) => {
     return typed3(name240, {
       // mad([a, b, c, d, ...])
       "Array | Matrix": _mad,
@@ -39377,7 +38408,7 @@ var createMad = /* @__PURE__ */ factory(
       try {
         const med = median2(flat);
         return median2(
-          map2(flat, function(value) {
+          map3(flat, function(value) {
             return abs2(subtract3(value, med));
           })
         );
@@ -39398,7 +38429,7 @@ var dependencies241 = ["typed", "map", "sqrt", "variance"];
 var createStd = /* @__PURE__ */ factory(
   name241,
   dependencies241,
-  ({ typed: typed3, map: map2, sqrt: sqrt2, variance: variance2 }) => {
+  ({ typed: typed3, map: map3, sqrt: sqrt2, variance: variance2 }) => {
     return typed3(name241, {
       // std([a, b, c, d, ...])
       "Array | Matrix": _std,
@@ -39421,7 +38452,7 @@ var createStd = /* @__PURE__ */ factory(
       try {
         const v = variance2(...args);
         if (isCollection(v)) {
-          return map2(v, sqrt2);
+          return map3(v, sqrt2);
         } else {
           return sqrt2(v);
         }
@@ -39442,12 +38473,12 @@ var dependencies242 = ["typed", "size", "concat", "subset", "setDifference", "In
 var createSetSymDifference = /* @__PURE__ */ factory(
   name242,
   dependencies242,
-  ({ typed: typed3, size: size2, concat: concat3, subset: subset2, setDifference: setDifference3, Index: Index2 }) => {
+  ({ typed: typed3, size: size2, concat: concat3, subset: subset2, setDifference: setDifference3, Index }) => {
     return typed3(name242, {
       "Array | Matrix, Array | Matrix": function(a1, a2) {
-        if (subset2(size2(a1), new Index2(0)) === 0) {
+        if (subset2(size2(a1), new Index(0)) === 0) {
           return flatten2(a2);
-        } else if (subset2(size2(a2), new Index2(0)) === 0) {
+        } else if (subset2(size2(a2), new Index(0)) === 0) {
           return flatten2(a1);
         }
         const b1 = flatten2(a1);
@@ -41574,13 +40605,13 @@ var createSetUnion = /* @__PURE__ */ factory(
     subset: subset2,
     setIntersect: setIntersect3,
     setSymDifference: setSymDifference3,
-    Index: Index2
+    Index
   }) => {
     return typed3(name247, {
       "Array | Matrix, Array | Matrix": function(a1, a2) {
-        if (subset2(size2(a1), new Index2(0)) === 0) {
+        if (subset2(size2(a1), new Index(0)) === 0) {
           return flatten2(a2);
-        } else if (subset2(size2(a2), new Index2(0)) === 0) {
+        } else if (subset2(size2(a2), new Index(0)) === 0) {
           return flatten2(a1);
         }
         const b1 = flatten2(a1);
@@ -41649,14 +40680,14 @@ var createRotationMatrix = /* @__PURE__ */ factory(
       "": function() {
         return config2.matrix === "Matrix" ? matrix2([]) : [];
       },
-      string: function(format6) {
-        return matrix2(format6);
+      string: function(format4) {
+        return matrix2(format4);
       },
       "number | BigNumber | Complex | Unit": function(theta) {
         return _rotationMatrix2x2(theta, config2.matrix === "Matrix" ? "dense" : void 0);
       },
-      "number | BigNumber | Complex | Unit, string": function(theta, format6) {
-        return _rotationMatrix2x2(theta, format6);
+      "number | BigNumber | Complex | Unit, string": function(theta, format4) {
+        return _rotationMatrix2x2(theta, format4);
       },
       "number | BigNumber | Complex | Unit, Array": function(theta, v) {
         const matrixV = matrix2(v);
@@ -41668,17 +40699,17 @@ var createRotationMatrix = /* @__PURE__ */ factory(
         const storageType = v.storage() || (config2.matrix === "Matrix" ? "dense" : void 0);
         return _rotationMatrix3x3(theta, v, storageType);
       },
-      "number | BigNumber | Complex | Unit, Array, string": function(theta, v, format6) {
+      "number | BigNumber | Complex | Unit, Array, string": function(theta, v, format4) {
         const matrixV = matrix2(v);
         _validateVector(matrixV);
-        return _rotationMatrix3x3(theta, matrixV, format6);
+        return _rotationMatrix3x3(theta, matrixV, format4);
       },
-      "number | BigNumber | Complex | Unit, Matrix, string": function(theta, v, format6) {
+      "number | BigNumber | Complex | Unit, Matrix, string": function(theta, v, format4) {
         _validateVector(v);
-        return _rotationMatrix3x3(theta, v, format6);
+        return _rotationMatrix3x3(theta, v, format4);
       }
     });
-    function _rotationMatrix2x2(theta, format6) {
+    function _rotationMatrix2x2(theta, format4) {
       const Big = isBigNumber(theta);
       const minusOne = Big ? new BigNumber9(-1) : -1;
       const cosTheta = cos2(theta);
@@ -41687,7 +40718,7 @@ var createRotationMatrix = /* @__PURE__ */ factory(
         [cosTheta, multiplyScalar2(minusOne, sinTheta)],
         [sinTheta, cosTheta]
       ];
-      return _convertToFormat(data, format6);
+      return _convertToFormat(data, format4);
     }
     function _validateVector(v) {
       const size2 = v.size();
@@ -41698,19 +40729,19 @@ var createRotationMatrix = /* @__PURE__ */ factory(
     function _mul(array) {
       return array.reduce((p, curr) => multiplyScalar2(p, curr));
     }
-    function _convertToFormat(data, format6) {
-      if (format6) {
-        if (format6 === "sparse") {
+    function _convertToFormat(data, format4) {
+      if (format4) {
+        if (format4 === "sparse") {
           return new SparseMatrix(data);
         }
-        if (format6 === "dense") {
+        if (format4 === "dense") {
           return new DenseMatrix6(data);
         }
-        throw new TypeError(`Unknown matrix type "${format6}"`);
+        throw new TypeError(`Unknown matrix type "${format4}"`);
       }
       return data;
     }
-    function _rotationMatrix3x3(theta, v, format6) {
+    function _rotationMatrix3x3(theta, v, format4) {
       const normV = norm4(v);
       if (normV === 0) {
         throw new RangeError("Rotation around zero vector");
@@ -41738,7 +40769,7 @@ var createRotationMatrix = /* @__PURE__ */ factory(
         [r21, r22, r23],
         [r31, r32, r33]
       ];
-      return _convertToFormat(data, format6);
+      return _convertToFormat(data, format4);
     }
   }
 );
@@ -42258,11 +41289,11 @@ var re2 = createRe(factoryScope);
 var not2 = createNot(factoryScope);
 var filter2 = createFilter(factoryScope);
 var flatten3 = createFlatten(factoryScope);
-var forEach = createForEach(factoryScope);
+var forEach2 = createForEach(factoryScope);
 var getMatrixDataType = createGetMatrixDataType(
   factoryScope
 );
-var map = createMap(factoryScope);
+var map2 = createMap(factoryScope);
 var size = createSize(factoryScope);
 var squeeze2 = createSqueeze(factoryScope);
 var combinations2 = createCombinations(factoryScope);
@@ -42274,7 +41305,7 @@ var pickRandom2 = createPickRandom(factoryScope);
 var random2 = createRandom(factoryScope);
 var equalScalar2 = createEqualScalar(factoryScope);
 var erf = createErf(factoryScope);
-var format5 = createFormat(factoryScope);
+var format3 = createFormat(factoryScope);
 var print2 = createPrint(factoryScope);
 var acoth = createAcoth(factoryScope);
 var acsch = createAcsch(factoryScope);
@@ -42283,7 +41314,7 @@ var coth = createCoth(factoryScope);
 var csch = createCsch(factoryScope);
 var sech = createSech(factoryScope);
 var toBest2 = createToBest(factoryScope);
-var clone3 = createClone(factoryScope);
+var clone2 = createClone(factoryScope);
 var isBounded = createIsBounded(factoryScope);
 var isNaN2 = createIsNaN(factoryScope);
 var isNegative = createIsNegative(factoryScope);
@@ -42335,7 +41366,7 @@ factoryScope.asinh = factory_asinh;
 factoryScope.atan = factory_atan;
 factoryScope.atanh = factory_atanh;
 factoryScope.bitNot = bitNot2;
-factoryScope.clone = clone3;
+factoryScope.clone = clone2;
 factoryScope.combinations = combinations2;
 factoryScope.combinationsWithRep = combinationsWithRep2;
 factoryScope.conj = conj2;
@@ -42348,7 +41379,7 @@ factoryScope.equalScalar = equalScalar2;
 factoryScope.erf = erf;
 factoryScope.exp = factory_exp;
 factoryScope.expm1 = factory_expm1;
-factoryScope.format = format5;
+factoryScope.format = format3;
 factoryScope.im = im2;
 factoryScope.isBounded = isBounded;
 factoryScope.isNaN = isNaN2;
@@ -42359,7 +41390,7 @@ factoryScope.isPrime = isPrime;
 factoryScope.lgamma = lgamma2;
 factoryScope.log2 = factory_log2;
 factoryScope.log10 = factory_log10;
-factoryScope.map = map;
+factoryScope.map = map2;
 factoryScope.multiplyScalar = multiplyScalar;
 factoryScope.not = not2;
 factoryScope.numeric = numeric;
@@ -42418,7 +41449,7 @@ factoryScope.isZero = isZero;
 factoryScope.prod = prod;
 factoryScope.dot = factory_dot;
 factoryScope.squeeze = squeeze2;
-factoryScope.forEach = forEach;
+factoryScope.forEach = forEach2;
 factoryScope.filter = filter2;
 var factory_transpose = createTranspose(
   factoryScope
@@ -43948,11 +42979,11 @@ function symbolicProduct(expr, varName, a, b) {
       `symbolicProduct: bounds must be finite numbers (symbolic bounds are not supported; got lower bound ${JSON.stringify(a)}, upper bound ${JSON.stringify(b)})`
     );
   }
-  let product3 = 1;
+  let product2 = 1;
   for (let k = a; k <= b; k++) {
-    product3 *= evalAt(expr, varName, k);
+    product2 *= evalAt(expr, varName, k);
   }
-  return product3;
+  return product2;
 }
 function assume(varName, property) {
   const validProperties = ["real", "positive", "negative", "integer", "nonzero", "nonnegative"];
@@ -48158,7 +47189,7 @@ function linearRegression(x, y) {
 }
 
 // src/ml/regularized-regression.ts
-function validate(X, y, name254) {
+function validate2(X, y, name254) {
   const n = X.length;
   if (n === 0) throw new Error(`${name254}: empty design matrix`);
   if (y.length !== n) {
@@ -48197,7 +47228,7 @@ function softThreshold(a, lambda) {
   return 0;
 }
 function ridge(X, y, alpha, opts) {
-  const { n, p } = validate(X, y, "ridge");
+  const { n, p } = validate2(X, y, "ridge");
   if (alpha < 0) throw new Error("ridge: alpha must be non-negative");
   const useIntercept = opts?.intercept !== false;
   const { Xc, yc, xMean, yMean } = center(X, y, n, p, useIntercept);
@@ -48252,7 +47283,7 @@ function coordinateDescent(Xs, yc, n, p, l1, l2, maxIter, tol) {
   return beta2;
 }
 function lasso(X, y, alpha, opts) {
-  const { n, p } = validate(X, y, "lasso");
+  const { n, p } = validate2(X, y, "lasso");
   if (alpha < 0) throw new Error("lasso: alpha must be non-negative");
   const useIntercept = opts?.intercept !== false;
   const maxIter = opts?.maxIter ?? 1e3;
@@ -48265,7 +47296,7 @@ function lasso(X, y, alpha, opts) {
   return { coefficients, intercept };
 }
 function elasticNet(X, y, alpha, l1Ratio, opts) {
-  const { n, p } = validate(X, y, "elasticNet");
+  const { n, p } = validate2(X, y, "elasticNet");
   if (alpha < 0) throw new Error("elasticNet: alpha must be non-negative");
   if (l1Ratio < 0 || l1Ratio > 1) throw new Error("elasticNet: l1Ratio must be in [0, 1]");
   const useIntercept = opts?.intercept !== false;
@@ -49432,6 +48463,97 @@ function butter(N, Wn, btype = "low") {
   return analogToDigital(buttap(N), Wn, btype);
 }
 
+// src/signal/fft.ts
+function complex2(re3, im3 = 0) {
+  return { re: re3, im: im3 };
+}
+function isPowerOf25(n) {
+  return n > 0 && (n & n - 1) === 0;
+}
+function nextPowerOf22(n) {
+  if (n <= 1) return 1;
+  return Math.pow(2, Math.ceil(Math.log2(n)));
+}
+function fftCore(data, inverse = false) {
+  const n = data.length;
+  if (!isPowerOf25(n)) {
+    throw new Error(`FFT length must be power of 2, got ${n}`);
+  }
+  if (n === 1) {
+    return [{ ...data[0] }];
+  }
+  const real = new Float64Array(n);
+  const imag = new Float64Array(n);
+  for (let i = 0; i < n; i++) {
+    real[i] = data[i].re;
+    imag[i] = data[i].im;
+  }
+  const out = fftCoreFloat64(real, imag, inverse);
+  const spectrum = new Array(n);
+  for (let i = 0; i < n; i++) {
+    spectrum[i] = { re: out.real[i], im: out.imag[i] };
+  }
+  return spectrum;
+}
+function fft2(signal) {
+  const originalLength = signal.length;
+  if (originalLength === 0) {
+    return {
+      spectrum: [],
+      originalLength: 0,
+      paddedLength: 0
+    };
+  }
+  let complexSignal;
+  if (signal instanceof Float64Array) {
+    complexSignal = Array.from(signal).map((x) => complex2(x, 0));
+  } else if (typeof signal[0] === "number") {
+    complexSignal = signal.map((x) => complex2(x, 0));
+  } else {
+    complexSignal = signal;
+  }
+  const paddedLength = nextPowerOf22(originalLength);
+  if (paddedLength > originalLength) {
+    const padding = new Array(paddedLength - originalLength).fill(complex2(0, 0));
+    complexSignal = [...complexSignal, ...padding];
+  }
+  const spectrum = fftCore(complexSignal, false);
+  return {
+    spectrum,
+    originalLength,
+    paddedLength
+  };
+}
+function ifft2(spectrum, originalLength) {
+  if (spectrum.length === 0) {
+    return [];
+  }
+  const paddedLength = nextPowerOf22(spectrum.length);
+  let paddedSpectrum = spectrum;
+  if (paddedLength > spectrum.length) {
+    const padding = new Array(paddedLength - spectrum.length).fill(complex2(0, 0));
+    paddedSpectrum = [...spectrum, ...padding];
+  }
+  const result = fftCore(paddedSpectrum, true);
+  if (originalLength !== void 0 && originalLength < result.length) {
+    return result.slice(0, originalLength);
+  }
+  return result;
+}
+function ifftReal(spectrum, originalLength) {
+  const complex3 = ifft2(spectrum, originalLength);
+  return complex3.map((c) => c.re);
+}
+function rollBy(arr10, count2) {
+  return [...arr10.slice(count2), ...arr10.slice(0, count2)];
+}
+function fftshift(spectrum) {
+  return rollBy(spectrum, Math.floor(spectrum.length / 2));
+}
+function ifftshift(spectrum) {
+  return rollBy(spectrum, Math.ceil(spectrum.length / 2));
+}
+
 // src/signal/fft-helpers.ts
 var callFft = fft;
 var callIfft = ifft;
@@ -49468,15 +48590,11 @@ function irfft(spec, n) {
   const result = callIfft(full);
   return result.map((v) => toReIm(v).re);
 }
-function fftshift(x) {
-  const n = x.length;
-  const half = Math.floor(n / 2);
-  return [...x.slice(half), ...x.slice(0, half)];
+function fftshift2(x) {
+  return fftshift(x);
 }
-function ifftshift(x) {
-  const n = x.length;
-  const half = Math.ceil(n / 2);
-  return [...x.slice(half), ...x.slice(0, half)];
+function ifftshift2(x) {
+  return ifftshift(x);
 }
 function fftfreq(n, d = 1) {
   const result = new Array(n);
@@ -49854,88 +48972,6 @@ function sosfilt(sos, x) {
   return y;
 }
 
-// src/signal/fft.ts
-function complex2(re3, im3 = 0) {
-  return { re: re3, im: im3 };
-}
-function isPowerOf25(n) {
-  return n > 0 && (n & n - 1) === 0;
-}
-function nextPowerOf22(n) {
-  if (n <= 1) return 1;
-  return Math.pow(2, Math.ceil(Math.log2(n)));
-}
-function fftCore(data, inverse = false) {
-  const n = data.length;
-  if (!isPowerOf25(n)) {
-    throw new Error(`FFT length must be power of 2, got ${n}`);
-  }
-  if (n === 1) {
-    return [{ ...data[0] }];
-  }
-  const real = new Float64Array(n);
-  const imag = new Float64Array(n);
-  for (let i = 0; i < n; i++) {
-    real[i] = data[i].re;
-    imag[i] = data[i].im;
-  }
-  const out = fftCoreFloat64(real, imag, inverse);
-  const spectrum = new Array(n);
-  for (let i = 0; i < n; i++) {
-    spectrum[i] = { re: out.real[i], im: out.imag[i] };
-  }
-  return spectrum;
-}
-function fft2(signal) {
-  const originalLength = signal.length;
-  if (originalLength === 0) {
-    return {
-      spectrum: [],
-      originalLength: 0,
-      paddedLength: 0
-    };
-  }
-  let complexSignal;
-  if (signal instanceof Float64Array) {
-    complexSignal = Array.from(signal).map((x) => complex2(x, 0));
-  } else if (typeof signal[0] === "number") {
-    complexSignal = signal.map((x) => complex2(x, 0));
-  } else {
-    complexSignal = signal;
-  }
-  const paddedLength = nextPowerOf22(originalLength);
-  if (paddedLength > originalLength) {
-    const padding = new Array(paddedLength - originalLength).fill(complex2(0, 0));
-    complexSignal = [...complexSignal, ...padding];
-  }
-  const spectrum = fftCore(complexSignal, false);
-  return {
-    spectrum,
-    originalLength,
-    paddedLength
-  };
-}
-function ifft2(spectrum, originalLength) {
-  if (spectrum.length === 0) {
-    return [];
-  }
-  const paddedLength = nextPowerOf22(spectrum.length);
-  let paddedSpectrum = spectrum;
-  if (paddedLength > spectrum.length) {
-    const padding = new Array(paddedLength - spectrum.length).fill(complex2(0, 0));
-    paddedSpectrum = [...spectrum, ...padding];
-  }
-  const result = fftCore(paddedSpectrum, true);
-  if (originalLength !== void 0 && originalLength < result.length) {
-    return result.slice(0, originalLength);
-  }
-  return result;
-}
-function ifftReal(spectrum, originalLength) {
-  const complex3 = ifft2(spectrum, originalLength);
-  return complex3.map((c) => c.re);
-}
-
 // src/signal/conv.ts
 function convDirect(x, h, mode2 = "full") {
   const xArr = Array.isArray(x) ? x : Array.from(x);
@@ -52273,7 +51309,7 @@ export {
   clamp,
   classicalElectronRadius,
   clearAssumptions,
-  clone3 as clone,
+  clone2 as clone,
   closenessCentrality,
   cochranQ,
   coefficientList,
@@ -52511,7 +51547,7 @@ export {
   fftGpuDispatch,
   fftfreq,
   fftn,
-  fftshift,
+  fftshift2 as fftshift,
   fibonacci,
   filter2 as filter,
   filtfilt,
@@ -52528,8 +51564,8 @@ export {
   flatten3 as flatten,
   floor,
   floydWarshall,
-  forEach,
-  format4 as format,
+  forEach2 as forEach,
+  format2 as format,
   fourier,
   fourierSeries,
   fraction,
@@ -52611,7 +51647,7 @@ export {
   idst,
   idwt,
   ifft,
-  ifftshift,
+  ifftshift2 as ifftshift,
   im,
   implicitDiff,
   indexFn as index,
@@ -52744,7 +51780,7 @@ export {
   mahalanobis,
   manhattanDistance,
   mannWhitneyTest,
-  map,
+  map2 as map,
   mapSlices,
   matmul,
   matrix,