@danielsimonjr/mathts-compat 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,320 @@
+import { Complex, Fraction, BigNumber } from '@danielsimonjr/mathts-core';
+export { BIGNUMBER_E, BIGNUMBER_ONE, BIGNUMBER_PI, BIGNUMBER_ZERO, BigNumber, COMPLEX_ONE, COMPLEX_ZERO, Complex, FRACTION_ONE, FRACTION_ZERO, Fraction, I } from '@danielsimonjr/mathts-core';
+import { add as add$1, subtract as subtract$1, multiply as multiply$1, divide as divide$1, pow as pow$1, sqrt as sqrt$1, abs as abs$1, exp as exp$1, log as log$1, sin as sin$1, cos as cos$1, tan as tan$1, sum as sum$1, mean as mean$1, min as min$1, max as max$1, gcd as gcd$1, lcm as lcm$1, round as round$1, floor as floor$1, ceil as ceil$1 } from '@danielsimonjr/mathts-functions';
+import { DenseMatrix, SparseMatrix } from '@danielsimonjr/mathts-matrix';
+export { DenseMatrix, SparseMatrix } from '@danielsimonjr/mathts-matrix';
+export { computePool } from '@danielsimonjr/mathts-parallel';
+
+/**
+ * mathjs Compatibility Shims
+ *
+ * Provides mathjs-compatible API wrappers around MathTS functions.
+ * This allows gradual migration from mathjs to MathTS.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Create a complex number (mathjs-compatible)
+ * @example
+ * complex(3, 4)  // Complex(3, 4)
+ * complex(5)     // Complex(5, 0)
+ * complex('3+4i') // Complex(3, 4)
+ */
+declare function complex(re?: number | string | Complex, im?: number): Complex;
+/**
+ * Create a fraction (mathjs-compatible)
+ * @example
+ * fraction(1, 2)   // Fraction(1, 2)
+ * fraction('1/2')  // Fraction(1, 2)
+ * fraction(0.5)    // Fraction(1, 2)
+ */
+declare function fraction(numerator?: number | string | Fraction, denominator?: number): Fraction;
+/**
+ * Create a BigNumber (mathjs-compatible)
+ * @example
+ * bignumber('123.456')
+ * bignumber(123)
+ */
+declare function bignumber(value?: number | string | BigNumber): BigNumber;
+/**
+ * Create a matrix (mathjs-compatible)
+ * @example
+ * matrix([[1,2],[3,4]])
+ * matrix([[1,2],[3,4]], 'sparse')
+ */
+declare function matrix(data?: number[][] | DenseMatrix | SparseMatrix, format?: 'dense' | 'sparse'): DenseMatrix | SparseMatrix;
+/**
+ * Create a sparse matrix (mathjs-compatible)
+ */
+declare function sparse(data?: number[][]): SparseMatrix;
+declare const add: typeof add$1;
+declare const subtract: typeof subtract$1;
+declare const multiply: typeof multiply$1;
+declare const divide: typeof divide$1;
+declare const pow: typeof pow$1;
+declare const sqrt: typeof sqrt$1;
+declare const abs: typeof abs$1;
+declare const exp: typeof exp$1;
+declare const log: typeof log$1;
+declare const sin: typeof sin$1;
+declare const cos: typeof cos$1;
+declare const tan: typeof tan$1;
+declare function asin(x: number): number;
+declare function acos(x: number): number;
+declare function atan(x: number): number;
+declare function atan2(y: number, x: number): number;
+declare const sum: typeof sum$1;
+declare const mean: typeof mean$1;
+declare const min: typeof min$1;
+declare const max: typeof max$1;
+declare const gcd: typeof gcd$1;
+declare const lcm: typeof lcm$1;
+declare const round: typeof round$1;
+declare const floor: typeof floor$1;
+declare const ceil: typeof ceil$1;
+/**
+ * Complex conjugate (mathjs-compatible)
+ */
+declare function conj(c: Complex): Complex;
+/**
+ * Real part (mathjs-compatible)
+ */
+declare function re(c: Complex | number): number;
+/**
+ * Imaginary part (mathjs-compatible)
+ */
+declare function im(c: Complex | number): number;
+/**
+ * Argument (phase) of complex number (mathjs-compatible)
+ */
+declare function arg(c: Complex): number;
+/**
+ * Transpose matrix (mathjs-compatible)
+ */
+declare function transpose(m: DenseMatrix | SparseMatrix | number[][]): DenseMatrix | SparseMatrix;
+/**
+ * Matrix determinant (mathjs-compatible)
+ *
+ * Computes the determinant using LU decomposition.
+ */
+declare function det(m: DenseMatrix | number[][]): number;
+/**
+ * Identity matrix (mathjs-compatible)
+ */
+declare function identity(n: number): DenseMatrix;
+/**
+ * Zeros matrix (mathjs-compatible)
+ */
+declare function zeros(rows: number, cols?: number): DenseMatrix;
+/**
+ * Ones matrix (mathjs-compatible)
+ */
+declare function ones(rows: number, cols?: number): DenseMatrix;
+/**
+ * Matrix size (mathjs-compatible)
+ */
+declare function size(m: DenseMatrix | SparseMatrix | number[][]): [number, number];
+declare function isComplex_(x: unknown): x is Complex;
+declare function isFraction_(x: unknown): x is Fraction;
+declare function isBigNumber_(x: unknown): x is BigNumber;
+declare function isNumber_(x: unknown): x is number;
+declare function isMatrix(x: unknown): x is DenseMatrix | SparseMatrix;
+declare const i: Complex;
+declare const pi: number;
+declare const e: number;
+declare const phi: number;
+declare const tau: number;
+declare const LN2: number;
+declare const LN10: number;
+declare const LOG2E: number;
+declare const LOG10E: number;
+declare const SQRT2: number;
+declare const SQRT1_2: number;
+declare const Infinity_: number;
+declare const NaN_: number;
+declare const shims: {
+    complex: typeof complex;
+    fraction: typeof fraction;
+    bignumber: typeof bignumber;
+    matrix: typeof matrix;
+    sparse: typeof sparse;
+    add: typeof add$1;
+    subtract: typeof subtract$1;
+    multiply: typeof multiply$1;
+    divide: typeof divide$1;
+    pow: typeof pow$1;
+    sqrt: typeof sqrt$1;
+    abs: typeof abs$1;
+    exp: typeof exp$1;
+    log: typeof log$1;
+    sin: typeof sin$1;
+    cos: typeof cos$1;
+    tan: typeof tan$1;
+    asin: typeof asin;
+    acos: typeof acos;
+    atan: typeof atan;
+    atan2: typeof atan2;
+    sum: typeof sum$1;
+    mean: typeof mean$1;
+    min: typeof min$1;
+    max: typeof max$1;
+    gcd: typeof gcd$1;
+    lcm: typeof lcm$1;
+    round: typeof round$1;
+    floor: typeof floor$1;
+    ceil: typeof ceil$1;
+    conj: typeof conj;
+    re: typeof re;
+    im: typeof im;
+    arg: typeof arg;
+    transpose: typeof transpose;
+    det: typeof det;
+    identity: typeof identity;
+    zeros: typeof zeros;
+    ones: typeof ones;
+    size: typeof size;
+    isComplex: typeof isComplex_;
+    isFraction: typeof isFraction_;
+    isBigNumber: typeof isBigNumber_;
+    isNumber: typeof isNumber_;
+    isMatrix: typeof isMatrix;
+    i: Complex;
+    pi: number;
+    e: number;
+    phi: number;
+    tau: number;
+    LN2: number;
+    LN10: number;
+    LOG2E: number;
+    LOG10E: number;
+    SQRT2: number;
+    SQRT1_2: number;
+    Infinity: number;
+    NaN: number;
+};
+
+/**
+ * @danielsimonjr/mathts-compat - mathjs Compatibility Layer
+ *
+ * Provides a mathjs-compatible API for gradual migration to MathTS.
+ *
+ * @example
+ * ```typescript
+ * import { create, all } from '@danielsimonjr/mathts-compat';
+ * const math = create(all);
+ *
+ * // Use mathjs-style API
+ * math.add(1, 2);
+ * math.complex(3, 4);
+ * math.matrix([[1,2],[3,4]]);
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * mathjs-compatible configuration interface
+ */
+interface MathJSConfig {
+    /** Numeric precision for BigNumber (default: 64) */
+    precision?: number;
+    /** Matrix type: 'Matrix' or 'Array' */
+    matrix?: 'Matrix' | 'Array';
+    /** Number type for parsing */
+    number?: 'number' | 'BigNumber' | 'Fraction';
+    /** Epsilon for floating point comparisons */
+    epsilon?: number;
+    /** Predictable random seed */
+    randomSeed?: string | null;
+}
+/**
+ * MathTS instance with mathjs-compatible API
+ */
+interface MathInstance {
+    config: (newConfig?: Partial<MathJSConfig>) => MathJSConfig;
+    complex: typeof shims.complex;
+    fraction: typeof shims.fraction;
+    bignumber: typeof shims.bignumber;
+    matrix: typeof shims.matrix;
+    sparse: typeof shims.sparse;
+    add: typeof shims.add;
+    subtract: typeof shims.subtract;
+    multiply: typeof shims.multiply;
+    divide: typeof shims.divide;
+    pow: typeof shims.pow;
+    sqrt: typeof shims.sqrt;
+    abs: typeof shims.abs;
+    exp: typeof shims.exp;
+    log: typeof shims.log;
+    sin: typeof shims.sin;
+    cos: typeof shims.cos;
+    tan: typeof shims.tan;
+    asin: typeof shims.asin;
+    acos: typeof shims.acos;
+    atan: typeof shims.atan;
+    atan2: typeof shims.atan2;
+    sum: typeof shims.sum;
+    mean: typeof shims.mean;
+    min: typeof shims.min;
+    max: typeof shims.max;
+    gcd: typeof shims.gcd;
+    lcm: typeof shims.lcm;
+    round: typeof shims.round;
+    floor: typeof shims.floor;
+    ceil: typeof shims.ceil;
+    conj: typeof shims.conj;
+    re: typeof shims.re;
+    im: typeof shims.im;
+    arg: typeof shims.arg;
+    transpose: typeof shims.transpose;
+    det: typeof shims.det;
+    identity: typeof shims.identity;
+    zeros: typeof shims.zeros;
+    ones: typeof shims.ones;
+    size: typeof shims.size;
+    isComplex: typeof shims.isComplex;
+    isFraction: typeof shims.isFraction;
+    isBigNumber: typeof shims.isBigNumber;
+    isNumber: typeof shims.isNumber;
+    isMatrix: typeof shims.isMatrix;
+    i: typeof shims.i;
+    pi: typeof shims.pi;
+    e: typeof shims.e;
+    phi: typeof shims.phi;
+    tau: typeof shims.tau;
+    LN2: typeof shims.LN2;
+    LN10: typeof shims.LN10;
+    LOG2E: typeof shims.LOG2E;
+    LOG10E: typeof shims.LOG10E;
+    SQRT2: typeof shims.SQRT2;
+    SQRT1_2: typeof shims.SQRT1_2;
+    Infinity: typeof shims.Infinity;
+    NaN: typeof shims.NaN;
+}
+/**
+ * Create a MathTS instance with mathjs-compatible API
+ *
+ * @param _factories - Factory functions to include (use `all` for all functions)
+ * @param config - Configuration options
+ * @returns MathTS instance with mathjs-compatible API
+ *
+ * @example
+ * ```typescript
+ * import { create, all } from '@danielsimonjr/mathts-compat';
+ * const math = create(all);
+ *
+ * math.add(1, 2);           // 3
+ * math.complex(3, 4);       // Complex(3, 4)
+ * math.matrix([[1,2],[3,4]]); // DenseMatrix
+ * ```
+ */
+declare function create(_factories?: Record<string, unknown>, config?: Partial<MathJSConfig>): MathInstance;
+/**
+ * All available factory functions
+ *
+ * Use with `create(all)` to get a fully-featured math instance.
+ */
+declare const all: Record<string, unknown>;
+
+export { Infinity_, LN10, LN2, LOG10E, LOG2E, type MathInstance, type MathJSConfig, NaN_, SQRT1_2, SQRT2, abs, acos, add, all, arg, asin, atan, atan2, bignumber, ceil, complex, conj, cos, create, det, divide, e, exp, floor, fraction, gcd, i, identity, im, isBigNumber_, isComplex_, isFraction_, isMatrix, isNumber_, lcm, log, matrix, max, mean, min, multiply, ones, phi, pi, pow, re, round, shims, sin, size, sparse, sqrt, subtract, sum, tan, tau, transpose, zeros };

package/dist/index.js

@@ -0,0 +1,512 @@
+// src/shims.ts
+import {
+  Complex,
+  Fraction,
+  BigNumber,
+  I,
+  COMPLEX_ZERO,
+  isComplex,
+  isFraction,
+  isBigNumber,
+  isNumber
+} from "@danielsimonjr/mathts-core";
+import {
+  add as _add,
+  subtract as _subtract,
+  multiply as _multiply,
+  divide as _divide,
+  pow as _pow,
+  sqrt as _sqrt,
+  abs as _abs,
+  exp as _exp,
+  log as _log,
+  sin as _sin,
+  cos as _cos,
+  tan as _tan,
+  sum as _sum,
+  mean as _mean,
+  min as _min,
+  max as _max,
+  gcd as _gcd,
+  lcm as _lcm,
+  round as _round,
+  floor as _floor,
+  ceil as _ceil
+} from "@danielsimonjr/mathts-functions";
+import { DenseMatrix, SparseMatrix } from "@danielsimonjr/mathts-matrix";
+function complex(re2, im2) {
+  if (re2 === void 0) {
+    return COMPLEX_ZERO;
+  }
+  if (re2 instanceof Complex) {
+    return re2;
+  }
+  if (typeof re2 === "string") {
+    return Complex.parse(re2);
+  }
+  return new Complex(re2, im2 ?? 0);
+}
+function fraction(numerator, denominator) {
+  if (numerator === void 0) {
+    return new Fraction(0, 1);
+  }
+  if (numerator instanceof Fraction) {
+    return numerator;
+  }
+  if (typeof numerator === "string") {
+    return Fraction.parse(numerator);
+  }
+  if (denominator !== void 0) {
+    return new Fraction(numerator, denominator);
+  }
+  return Fraction.fromNumber(numerator);
+}
+function bignumber(value) {
+  if (value === void 0) {
+    return BigNumber.fromNumber(0);
+  }
+  if (value instanceof BigNumber) {
+    return value;
+  }
+  if (typeof value === "string") {
+    return BigNumber.parse(value);
+  }
+  return BigNumber.fromNumber(value);
+}
+function matrix(data, format) {
+  if (data === void 0) {
+    return DenseMatrix.zeros(0, 0);
+  }
+  if (data instanceof DenseMatrix || data instanceof SparseMatrix) {
+    return data;
+  }
+  const dense = DenseMatrix.fromArray(data);
+  if (format === "sparse") {
+    return SparseMatrix.fromDense(dense);
+  }
+  return dense;
+}
+function sparse(data) {
+  if (data === void 0) {
+    return SparseMatrix.zeros(0, 0);
+  }
+  return SparseMatrix.fromDense(DenseMatrix.fromArray(data));
+}
+var add = _add;
+var subtract = _subtract;
+var multiply = _multiply;
+var divide = _divide;
+var pow = _pow;
+var sqrt = _sqrt;
+var abs = _abs;
+var exp = _exp;
+var log = _log;
+var sin = _sin;
+var cos = _cos;
+var tan = _tan;
+function asin(x) {
+  return Math.asin(x);
+}
+function acos(x) {
+  return Math.acos(x);
+}
+function atan(x) {
+  return Math.atan(x);
+}
+function atan2(y, x) {
+  return Math.atan2(y, x);
+}
+var sum = _sum;
+var mean = _mean;
+var min = _min;
+var max = _max;
+var gcd = _gcd;
+var lcm = _lcm;
+var round = _round;
+var floor = _floor;
+var ceil = _ceil;
+function conj(c) {
+  if (!isComplex(c)) {
+    throw new TypeError("Expected Complex number");
+  }
+  return c.conjugate();
+}
+function re(c) {
+  if (typeof c === "number") return c;
+  if (isComplex(c)) return c.re;
+  throw new TypeError("Expected Complex or number");
+}
+function im(c) {
+  if (typeof c === "number") return 0;
+  if (isComplex(c)) return c.im;
+  throw new TypeError("Expected Complex or number");
+}
+function arg(c) {
+  if (!isComplex(c)) {
+    throw new TypeError("Expected Complex number");
+  }
+  return c.arg();
+}
+function transpose(m) {
+  if (Array.isArray(m)) {
+    return DenseMatrix.fromArray(m).transpose();
+  }
+  return m.transpose();
+}
+function det(m) {
+  const matrix2 = Array.isArray(m) ? DenseMatrix.fromArray(m) : m;
+  if (!(matrix2 instanceof DenseMatrix)) {
+    throw new TypeError("Expected DenseMatrix or 2D array");
+  }
+  if (matrix2.rows !== matrix2.cols) {
+    throw new Error("Determinant requires a square matrix");
+  }
+  const n = matrix2.rows;
+  if (n === 0) return 1;
+  if (n === 1) return matrix2.get(0, 0);
+  if (n === 2) {
+    return matrix2.get(0, 0) * matrix2.get(1, 1) - matrix2.get(0, 1) * matrix2.get(1, 0);
+  }
+  if (n === 3) {
+    const a = matrix2.get(0, 0), b = matrix2.get(0, 1), c = matrix2.get(0, 2);
+    const d = matrix2.get(1, 0), e2 = matrix2.get(1, 1), f = matrix2.get(1, 2);
+    const g = matrix2.get(2, 0), h = matrix2.get(2, 1), i2 = matrix2.get(2, 2);
+    return a * (e2 * i2 - f * h) - b * (d * i2 - f * g) + c * (d * h - e2 * g);
+  }
+  const lu = [];
+  for (let i2 = 0; i2 < n; i2++) {
+    lu[i2] = [];
+    for (let j = 0; j < n; j++) {
+      lu[i2][j] = matrix2.get(i2, j);
+    }
+  }
+  let swaps = 0;
+  for (let k = 0; k < n - 1; k++) {
+    let maxVal = Math.abs(lu[k][k]);
+    let maxRow = k;
+    for (let i2 = k + 1; i2 < n; i2++) {
+      if (Math.abs(lu[i2][k]) > maxVal) {
+        maxVal = Math.abs(lu[i2][k]);
+        maxRow = i2;
+      }
+    }
+    if (maxVal < 1e-12) {
+      return 0;
+    }
+    if (maxRow !== k) {
+      [lu[k], lu[maxRow]] = [lu[maxRow], lu[k]];
+      swaps++;
+    }
+    for (let i2 = k + 1; i2 < n; i2++) {
+      lu[i2][k] /= lu[k][k];
+      for (let j = k + 1; j < n; j++) {
+        lu[i2][j] -= lu[i2][k] * lu[k][j];
+      }
+    }
+  }
+  let result = 1;
+  for (let i2 = 0; i2 < n; i2++) {
+    result *= lu[i2][i2];
+  }
+  return swaps % 2 === 0 ? result : -result;
+}
+function identity(n) {
+  return DenseMatrix.identity(n);
+}
+function zeros(rows, cols) {
+  return DenseMatrix.zeros(rows, cols ?? rows);
+}
+function ones(rows, cols) {
+  return DenseMatrix.ones(rows, cols ?? rows);
+}
+function size(m) {
+  if (Array.isArray(m)) {
+    return [m.length, m[0]?.length ?? 0];
+  }
+  return [m.rows, m.cols];
+}
+function isComplex_(x) {
+  return isComplex(x);
+}
+function isFraction_(x) {
+  return isFraction(x);
+}
+function isBigNumber_(x) {
+  return isBigNumber(x);
+}
+function isNumber_(x) {
+  return isNumber(x);
+}
+function isMatrix(x) {
+  return x instanceof DenseMatrix || x instanceof SparseMatrix;
+}
+var i = I;
+var pi = Math.PI;
+var e = Math.E;
+var phi = (1 + Math.sqrt(5)) / 2;
+var tau = 2 * Math.PI;
+var LN2 = Math.LN2;
+var LN10 = Math.LN10;
+var LOG2E = Math.LOG2E;
+var LOG10E = Math.LOG10E;
+var SQRT2 = Math.SQRT2;
+var SQRT1_2 = Math.SQRT1_2;
+var Infinity_ = Infinity;
+var NaN_ = NaN;
+var shims = {
+  // Type creation
+  complex,
+  fraction,
+  bignumber,
+  matrix,
+  sparse,
+  // Arithmetic
+  add,
+  subtract,
+  multiply,
+  divide,
+  pow,
+  sqrt,
+  abs,
+  exp,
+  log,
+  // Trigonometry
+  sin,
+  cos,
+  tan,
+  asin,
+  acos,
+  atan,
+  atan2,
+  // Statistics
+  sum,
+  mean,
+  min,
+  max,
+  // Number theory
+  gcd,
+  lcm,
+  // Rounding
+  round,
+  floor,
+  ceil,
+  // Complex-specific
+  conj,
+  re,
+  im,
+  arg,
+  // Matrix-specific
+  transpose,
+  det,
+  identity,
+  zeros,
+  ones,
+  size,
+  // Type checking
+  isComplex: isComplex_,
+  isFraction: isFraction_,
+  isBigNumber: isBigNumber_,
+  isNumber: isNumber_,
+  isMatrix,
+  // Constants
+  i,
+  pi,
+  e,
+  phi,
+  tau,
+  LN2,
+  LN10,
+  LOG2E,
+  LOG10E,
+  SQRT2,
+  SQRT1_2,
+  Infinity: Infinity_,
+  NaN: NaN_
+};
+
+// src/index.ts
+import {
+  Complex as Complex2,
+  Fraction as Fraction2,
+  BigNumber as BigNumber2,
+  I as I2,
+  COMPLEX_ZERO as COMPLEX_ZERO2,
+  COMPLEX_ONE,
+  FRACTION_ZERO,
+  FRACTION_ONE,
+  BIGNUMBER_ZERO,
+  BIGNUMBER_ONE,
+  BIGNUMBER_PI,
+  BIGNUMBER_E
+} from "@danielsimonjr/mathts-core";
+import { DenseMatrix as DenseMatrix2, SparseMatrix as SparseMatrix2 } from "@danielsimonjr/mathts-matrix";
+import { computePool } from "@danielsimonjr/mathts-parallel";
+var defaultConfig = {
+  precision: 64,
+  matrix: "Matrix",
+  number: "number",
+  epsilon: 1e-12,
+  randomSeed: null
+};
+function create(_factories = {}, config = {}) {
+  const currentConfig = { ...defaultConfig, ...config };
+  return {
+    // Configuration
+    config: (newConfig) => {
+      if (newConfig) {
+        Object.assign(currentConfig, newConfig);
+      }
+      return { ...currentConfig };
+    },
+    // Type creation
+    complex: shims.complex,
+    fraction: shims.fraction,
+    bignumber: shims.bignumber,
+    matrix: shims.matrix,
+    sparse: shims.sparse,
+    // Arithmetic
+    add: shims.add,
+    subtract: shims.subtract,
+    multiply: shims.multiply,
+    divide: shims.divide,
+    pow: shims.pow,
+    sqrt: shims.sqrt,
+    abs: shims.abs,
+    exp: shims.exp,
+    log: shims.log,
+    // Trigonometry
+    sin: shims.sin,
+    cos: shims.cos,
+    tan: shims.tan,
+    asin: shims.asin,
+    acos: shims.acos,
+    atan: shims.atan,
+    atan2: shims.atan2,
+    // Statistics
+    sum: shims.sum,
+    mean: shims.mean,
+    min: shims.min,
+    max: shims.max,
+    // Number theory
+    gcd: shims.gcd,
+    lcm: shims.lcm,
+    // Rounding
+    round: shims.round,
+    floor: shims.floor,
+    ceil: shims.ceil,
+    // Complex-specific
+    conj: shims.conj,
+    re: shims.re,
+    im: shims.im,
+    arg: shims.arg,
+    // Matrix-specific
+    transpose: shims.transpose,
+    det: shims.det,
+    identity: shims.identity,
+    zeros: shims.zeros,
+    ones: shims.ones,
+    size: shims.size,
+    // Type checking
+    isComplex: shims.isComplex,
+    isFraction: shims.isFraction,
+    isBigNumber: shims.isBigNumber,
+    isNumber: shims.isNumber,
+    isMatrix: shims.isMatrix,
+    // Constants
+    i: shims.i,
+    pi: shims.pi,
+    e: shims.e,
+    phi: shims.phi,
+    tau: shims.tau,
+    LN2: shims.LN2,
+    LN10: shims.LN10,
+    LOG2E: shims.LOG2E,
+    LOG10E: shims.LOG10E,
+    SQRT2: shims.SQRT2,
+    SQRT1_2: shims.SQRT1_2,
+    Infinity: shims.Infinity,
+    NaN: shims.NaN
+  };
+}
+var all = {
+  // Placeholder - in mathjs this contains all factory functions
+  // For MathTS compat, we include everything by default in create()
+};
+export {
+  BIGNUMBER_E,
+  BIGNUMBER_ONE,
+  BIGNUMBER_PI,
+  BIGNUMBER_ZERO,
+  BigNumber2 as BigNumber,
+  COMPLEX_ONE,
+  COMPLEX_ZERO2 as COMPLEX_ZERO,
+  Complex2 as Complex,
+  DenseMatrix2 as DenseMatrix,
+  FRACTION_ONE,
+  FRACTION_ZERO,
+  Fraction2 as Fraction,
+  I2 as I,
+  Infinity_,
+  LN10,
+  LN2,
+  LOG10E,
+  LOG2E,
+  NaN_,
+  SQRT1_2,
+  SQRT2,
+  SparseMatrix2 as SparseMatrix,
+  abs,
+  acos,
+  add,
+  all,
+  arg,
+  asin,
+  atan,
+  atan2,
+  bignumber,
+  ceil,
+  complex,
+  computePool,
+  conj,
+  cos,
+  create,
+  det,
+  divide,
+  e,
+  exp,
+  floor,
+  fraction,
+  gcd,
+  i,
+  identity,
+  im,
+  isBigNumber_,
+  isComplex_,
+  isFraction_,
+  isMatrix,
+  isNumber_,
+  lcm,
+  log,
+  matrix,
+  max,
+  mean,
+  min,
+  multiply,
+  ones,
+  phi,
+  pi,
+  pow,
+  re,
+  round,
+  shims,
+  sin,
+  size,
+  sparse,
+  sqrt,
+  subtract,
+  sum,
+  tan,
+  tau,
+  transpose,
+  zeros
+};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@danielsimonjr/mathts-compat",
+  "version": "0.1.1",
+  "description": "mathjs compatibility layer for MathTS",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --dts --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "build:prod": "tsup src/index.ts --format esm --dts --clean --minify --treeshake"
+  },
+  "dependencies": {
+    "@danielsimonjr/mathts-core": "*",
+    "@danielsimonjr/mathts-functions": "*",
+    "@danielsimonjr/mathts-matrix": "*",
+    "@danielsimonjr/mathts-parallel": "*"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.2",
+    "tsup": "^8.5.1",
+    "typescript": "^5.8.3",
+    "vitest": "^2.1.9"
+  },
+  "keywords": [
+    "math",
+    "mathjs",
+    "compat",
+    "compatibility",
+    "migration"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/danielsimonjr/Mathts.git",
+    "directory": "compat"
+  },
+  "module": "./dist/index.js",
+  "publishConfig": {
+    "access": "public"
+  }
+}