exprify 1.0.4 → 1.0.7

package/src/utils/decimal.js

@@ -0,0 +1,264 @@
+const MAX_SAFE_DP = 100;
+
+export class ExprDecimal {
+  static DP = 20;
+
+  #sign;
+  #int;
+  #dp;
+
+  constructor(value) {
+    if (value instanceof ExprDecimal) {
+      this.#sign = value.#sign;
+      this.#int = value.#int;
+      this.#dp = value.#dp;
+      return;
+    }
+
+    if (typeof value === 'bigint') {
+      this.#sign = value >= 0n ? 1 : -1;
+      this.#int = value >= 0n ? value : -value;
+      this.#dp = 0;
+      return;
+    }
+
+    if (typeof value === 'number') {
+      if (!Number.isFinite(value)) {
+        throw new Error(`Cannot create ExprDecimal from ${value}`);
+      }
+      value = String(value);
+    }
+
+    if (typeof value !== 'string') {
+      throw new Error('ExprDecimal expects a number, string, bigint, or ExprDecimal');
+    }
+
+    let s = value.trim();
+    if (s === '') {
+      throw new Error('Cannot create ExprDecimal from empty string');
+    }
+
+    this.#sign = 1;
+    if (s[0] === '-') {
+      this.#sign = -1;
+      s = s.slice(1);
+    } else if (s[0] === '+') {
+      s = s.slice(1);
+    }
+
+    let exp = 0;
+    const eIdx = s.search(/[eE]/);
+    if (eIdx !== -1) {
+      exp = parseInt(s.slice(eIdx + 1), 10);
+      s = s.slice(0, eIdx);
+    }
+
+    const dotIdx = s.indexOf('.');
+    if (dotIdx === -1) {
+      this.#int = BigInt(s || '0');
+      this.#dp = 0;
+    } else {
+      const intPart = s.slice(0, dotIdx) || '0';
+      const fracPart = s.slice(dotIdx + 1);
+      const combined = intPart + fracPart;
+      this.#int = BigInt(combined || '0');
+      this.#dp = fracPart.length;
+    }
+
+    this.#dp -= exp;
+    if (this.#dp < 0) {
+      this.#int *= 10n ** BigInt(-this.#dp);
+      this.#dp = 0;
+    }
+
+    this.#normalize();
+  }
+
+  #normalize() {
+    while (this.#dp > 0 && this.#int % 10n === 0n) {
+      this.#int /= 10n;
+      this.#dp--;
+    }
+    if (this.#int === 0n) {
+      this.#sign = 1;
+      this.#dp = 0;
+    }
+  }
+
+  #align(other) {
+    if (this.#dp === other.#dp) {
+      return [this.#int * BigInt(this.#sign), other.#int * BigInt(other.#sign), this.#dp];
+    }
+    if (this.#dp < other.#dp) {
+      const factor = 10n ** BigInt(other.#dp - this.#dp);
+      return [this.#int * factor * BigInt(this.#sign), other.#int * BigInt(other.#sign), other.#dp];
+    }
+    const factor = 10n ** BigInt(this.#dp - other.#dp);
+    return [this.#int * BigInt(this.#sign), other.#int * factor * BigInt(other.#sign), this.#dp];
+  }
+
+  #fromParts(sign, int, dp) {
+    const d = new ExprDecimal(0);
+    d.#sign = sign;
+    d.#int = int < 0n ? -int : int;
+    if (int < 0n) {
+      d.#sign = -sign;
+    }
+    d.#dp = dp;
+    d.#normalize();
+    return d;
+  }
+
+  plus(other) {
+    other = other instanceof ExprDecimal ? other : new ExprDecimal(other);
+    const [a, b, dp] = this.#align(other);
+    return this.#fromParts(1, a + b, dp);
+  }
+
+  minus(other) {
+    other = other instanceof ExprDecimal ? other : new ExprDecimal(other);
+    const [a, b, dp] = this.#align(other);
+    return this.#fromParts(1, a - b, dp);
+  }
+
+  times(other) {
+    other = other instanceof ExprDecimal ? other : new ExprDecimal(other);
+    const int = this.#int * other.#int;
+    const dp = this.#dp + other.#dp;
+    return this.#fromParts(this.#sign * other.#sign, int, dp);
+  }
+
+  div(other) {
+    other = other instanceof ExprDecimal ? other : new ExprDecimal(other);
+    if (other.#int === 0n) {
+      throw new Error('Division by zero');
+    }
+    const targetDp = Math.min(ExprDecimal.DP, MAX_SAFE_DP);
+    const scale = 10n ** BigInt(targetDp + other.#dp);
+    const dividend = this.#int * scale;
+    const quotient = dividend / other.#int;
+    const sign = this.#sign * other.#sign;
+    if (quotient === 0n) {
+      return new ExprDecimal(0);
+    }
+    return this.#fromParts(sign, quotient, targetDp);
+  }
+
+  mod(other) {
+    other = other instanceof ExprDecimal ? other : new ExprDecimal(other);
+    const quotient = this.div(other);
+    const truncated = quotient.#fromParts(
+      quotient.#sign,
+      quotient.#int - (quotient.#int % 10n ** BigInt(quotient.#dp > 0 ? 1 : 0)),
+      0
+    );
+    return this.minus(truncated.times(other));
+  }
+
+  pow(other) {
+    other = other instanceof ExprDecimal ? other : new ExprDecimal(other);
+    if (other.#dp > 0 || other.#sign !== 1) {
+      throw new Error('ExprDecimal pow() supports non-negative integer exponents only');
+    }
+    const exp = Number(other.#int);
+    if (exp > 100) {
+      throw new Error('ExprDecimal pow() exponent too large');
+    }
+    let result = new ExprDecimal(1);
+    for (let i = 0; i < exp; i++) {
+      result = result.times(this);
+    }
+    return result;
+  }
+
+  negated() {
+    const d = new ExprDecimal(this);
+    d.#sign = -d.#sign;
+    if (d.#int === 0n) {
+      d.#sign = 1;
+    }
+    return d;
+  }
+
+  eq(other) {
+    other = other instanceof ExprDecimal ? other : new ExprDecimal(other);
+    const [a, b] = this.#align(other);
+    return a === b;
+  }
+
+  gt(other) {
+    other = other instanceof ExprDecimal ? other : new ExprDecimal(other);
+    const [a, b] = this.#align(other);
+    return a > b;
+  }
+
+  lt(other) {
+    other = other instanceof ExprDecimal ? other : new ExprDecimal(other);
+    const [a, b] = this.#align(other);
+    return a < b;
+  }
+
+  gte(other) {
+    return this.gt(other) || this.eq(other);
+  }
+
+  lte(other) {
+    return this.lt(other) || this.eq(other);
+  }
+
+  toString() {
+    let s = this.#int.toString();
+    const edp = this.#dp;
+
+    const toScientific = (intStr, exponent) => {
+      const coeffInt = intStr[0];
+      const coeffFrac = intStr.slice(1).replace(/0+$/, '');
+      let r = coeffInt;
+      if (coeffFrac) {
+        r += `.${coeffFrac}`;
+      }
+      r += 'e';
+      r += exponent >= 0 ? '+' : '';
+      r += exponent;
+      return this.#sign === -1 ? `-${r}` : r;
+    };
+
+    if (edp === 0) {
+      if (s.length > 15) {
+        return toScientific(s, s.length - 1);
+      }
+      return this.#sign === -1 ? `-${s}` : s;
+    }
+
+    while (s.length <= edp) {
+      s = `0${s}`;
+    }
+    const dotPos = s.length - edp;
+    const intPartRaw = s.slice(0, dotPos);
+    const intTrimmed = intPartRaw.replace(/^0+/, '') || '0';
+    const fracRaw = s.slice(dotPos);
+
+    if (intTrimmed.length > 15 || (intTrimmed === '0' && fracRaw.replace(/0+$/, '').length > 15)) {
+      const normalized = s.replace(/^0+/, '') || '0';
+      const leadZeros = s.length - normalized.length;
+      return toScientific(normalized, dotPos - leadZeros - 1);
+    }
+
+    const intPart = intPartRaw || '0';
+    const fracPart = fracRaw.replace(/0+$/, '');
+    if (fracPart === '') {
+      return this.#sign === -1 ? `-${intPart}` : intPart;
+    }
+    return `${this.#sign === -1 ? '-' : ''}${intPart}.${fracPart}`;
+  }
+
+  toNumber() {
+    return Number(this.toString());
+  }
+
+  static isDecimal(value) {
+    return value instanceof ExprDecimal;
+  }
+}
+
+export default ExprDecimal;

package/src/utils/globalUnits.js

@@ -1,5 +1,4 @@
 export const globalUnits = {
-  // Length
   length: {
     m: { value: 1, unit: 'meter', symbol: 'm' },
     cm: { value: 0.01, unit: 'centimeter', symbol: 'cm' },
@@ -11,7 +10,7 @@ export const globalUnits = {
     em: { value: 0.000264583 * 16, unit: 'em', symbol: 'em', note: '1em = 16px by default' },
     rem: { value: 0.000264583 * 16, unit: 'rem', symbol: 'rem', note: 'root em = 16px by default' },
     pt: { value: 0.000352778, unit: 'point', symbol: 'pt', note: '1pt = 1/72 inch' },
-    pc: { value: 0.00423333, unit: 'pica', symbol: 'pc', note: '1pc = 12pt' },
+    pica: { value: 0.00423333, unit: 'pica', symbol: 'pc', note: '1pc = 12pt' },
     inch: { value: 0.0254, unit: 'inch', symbol: 'in' },
     ft: { value: 0.3048, unit: 'foot', symbol: 'ft' },
     yd: { value: 0.9144, unit: 'yard', symbol: 'yd' },
@@ -22,7 +21,7 @@ export const globalUnits = {
     fathom: { value: 1.8288, unit: 'fathom', symbol: 'fathom' },
     au: { value: 1.496e11, unit: 'astronomical unit', symbol: 'AU' },
     ly: { value: 9.4607e15, unit: 'light year', symbol: 'ly' },
-    pc: { value: 3.0857e16, unit: 'parsec', symbol: 'pc' }
+    pc: { value: 3.0857e16, unit: 'parsec', symbol: 'pc' },
   },
 
   // Weight / Mass
@@ -33,7 +32,7 @@ export const globalUnits = {
     t: { value: 1000, unit: 'tonne', symbol: 't', note: 'metric ton' },
     lb: { value: 0.453592, unit: 'pound', symbol: 'lb' },
     oz: { value: 0.0283495, unit: 'ounce', symbol: 'oz' },
-    stone: { value: 6.35029, unit: 'stone', symbol: 'st', note: '1 stone = 14 lb' }
+    stone: { value: 6.35029, unit: 'stone', symbol: 'st', note: '1 stone = 14 lb' },
   },
 
   // Time
@@ -44,18 +43,18 @@ export const globalUnits = {
     day: { value: 86400, unit: 'day', symbol: 'd' },
     week: { value: 604800, unit: 'week', symbol: 'wk' },
     month: { value: 2629800, unit: 'month', symbol: 'mo', note: 'average month = 30.44 days' },
-    year: { value: 31557600, unit: 'year', symbol: 'yr', note: 'average year = 365.25 days' }
+    year: { value: 31557600, unit: 'year', symbol: 'yr', note: 'average year = 365.25 days' },
   },
 
   // Voltage
   voltage: {
-    V:      { value: 1, unit: 'volt', symbol: 'V' },
+    V: { value: 1, unit: 'volt', symbol: 'V' },
     mV: { value: 0.001, unit: 'millivolt', symbol: 'mV' },
     kV: { value: 1000, unit: 'kilovolt', symbol: 'kV' },
     MV: { value: 1e6, unit: 'megavolt', symbol: 'MV' },
     GV: { value: 1e9, unit: 'gigavolt', symbol: 'GV' },
     statV: { value: 299.792458, unit: 'statvolt', symbol: 'statV', note: 'CGS unit' },
-    abV: { value: 1e-8, unit: 'abvolt', symbol: 'abV', note: 'CGS electromagnetic unit' }
+    abV: { value: 1e-8, unit: 'abvolt', symbol: 'abV', note: 'CGS electromagnetic unit' },
   },
 
   // Frequency
@@ -64,7 +63,7 @@ export const globalUnits = {
     kHz: { value: 1e3, unit: 'kilohertz', symbol: 'kHz' },
     MHz: { value: 1e6, unit: 'megahertz', symbol: 'MHz' },
     GHz: { value: 1e9, unit: 'gigahertz', symbol: 'GHz' },
-    THz: { value: 1e12, unit: 'terahertz', symbol: 'THz' }
+    THz: { value: 1e12, unit: 'terahertz', symbol: 'THz' },
   },
 
   // Power
@@ -75,22 +74,32 @@ export const globalUnits = {
     MW: { value: 1e6, unit: 'megawatt', symbol: 'MW' },
     GW: { value: 1e9, unit: 'gigawatt', symbol: 'GW' },
     HP: { value: 745.7, unit: 'horsepower', symbol: 'HP', note: 'mechanical HP = 745.7 W' },
-    kcal_per_h: { value: 1.163, unit: 'kilocalorie per hour', symbol: 'kcal/h', note: '= 1.163 W' },
-    BTU_per_h: { value: 0.29307107, unit: 'BTU per hour', symbol: 'BTU/h', note: '= 0.293 W' }
+    'kcal/h': { value: 1.163, unit: 'kilocalorie per hour', symbol: 'kcal/h', note: '= 1.163 W' },
+    'BTU/h': { value: 0.29307107, unit: 'BTU per hour', symbol: 'BTU/h', note: '= 0.293 W' },
   },
 
   // Sound
   sound: {
     dB: { value: 1, unit: 'decibel', symbol: 'dB', note: 'logarithmic unit of sound intensity' },
-    dBA: { value: 1, unit: 'A-weighted decibel', symbol: 'dBA', note: 'Adjusted for human hearing' },
-    dBC: { value: 1, unit: 'C-weighted decibel', symbol: 'dBC', note: 'Flat weighting for high-level sounds' }
+    dBA: {
+      value: 1,
+      unit: 'A-weighted decibel',
+      symbol: 'dBA',
+      note: 'Adjusted for human hearing',
+    },
+    dBC: {
+      value: 1,
+      unit: 'C-weighted decibel',
+      symbol: 'dBC',
+      note: 'Flat weighting for high-level sounds',
+    },
   },
 
   // Temperature
   temperature: {
     K: { value: 1, unit: 'kelvin', symbol: 'K' },
     C: { value: 1, unit: 'Celsius', symbol: '°C', note: '°C → K: add 273.15' },
-    F: { value: 1, unit: 'Fahrenheit', symbol: '°F', note: '°F → K: (°F - 32) * 5/9 + 273.15' }
+    F: { value: 1, unit: 'Fahrenheit', symbol: '°F', note: '°F → K: (°F - 32) * 5/9 + 273.15' },
   },
 
   // Pressure
@@ -101,7 +110,7 @@ export const globalUnits = {
     bar: { value: 1e5, unit: 'bar', symbol: 'bar' },
     atm: { value: 101325, unit: 'atmosphere', symbol: 'atm' },
     psi: { value: 6894.757, unit: 'pound per square inch', symbol: 'psi' },
-    mmHg:{ value: 133.322, unit: 'millimeter of mercury', symbol: 'mmHg' }
+    mmHg: { value: 133.322, unit: 'millimeter of mercury', symbol: 'mmHg' },
   },
 
   // Energy
@@ -109,9 +118,9 @@ export const globalUnits = {
     J: { value: 1, unit: 'joule', symbol: 'J' },
     kJ: { value: 1000, unit: 'kilojoule', symbol: 'kJ' },
     cal: { value: 4.184, unit: 'calorie', symbol: 'cal' },
-    kcal:{ value: 4184, unit: 'kilocalorie', symbol: 'kcal' },
+    kcal: { value: 4184, unit: 'kilocalorie', symbol: 'kcal' },
     eV: { value: 1.60218e-19, unit: 'electronvolt', symbol: 'eV' },
-    BTU: { value: 1055.06, unit: 'BTU', symbol: 'BTU' }
+    BTU: { value: 1055.06, unit: 'BTU', symbol: 'BTU' },
   },
 
   // Force
@@ -120,7 +129,7 @@ export const globalUnits = {
     kN: { value: 1000, unit: 'kilonewton', symbol: 'kN' },
     lbf: { value: 4.44822, unit: 'pound-force', symbol: 'lbf' },
     kgf: { value: 9.80665, unit: 'kilogram-force', symbol: 'kgf' },
-    dyne:{ value: 1e-5, unit: 'dyne', symbol: 'dyn' }
+    dyne: { value: 1e-5, unit: 'dyne', symbol: 'dyn' },
   },
 
   // Area
@@ -129,9 +138,9 @@ export const globalUnits = {
     cm2: { value: 0.0001, unit: 'square centimeter', symbol: 'cm²' },
     km2: { value: 1e6, unit: 'square kilometer', symbol: 'km²' },
     acre: { value: 4046.856, unit: 'acre', symbol: 'acre' },
-    hectare:{ value: 10000, unit: 'hectare', symbol: 'ha' },
+    hectare: { value: 10000, unit: 'hectare', symbol: 'ha' },
     ft2: { value: 0.092903, unit: 'square foot', symbol: 'ft²' },
-    yd2: { value: 0.836127, unit: 'square yard', symbol: 'yd²' }
+    yd2: { value: 0.836127, unit: 'square yard', symbol: 'yd²' },
   },
 
   // Volume
@@ -139,9 +148,9 @@ export const globalUnits = {
     m3: { value: 1, unit: 'cubic meter', symbol: 'm³' },
     L: { value: 0.001, unit: 'liter', symbol: 'L' },
     mL: { value: 1e-6, unit: 'milliliter', symbol: 'mL' },
-    gallon:{ value: 0.00378541, unit: 'US gallon', symbol: 'gal' },
+    gallon: { value: 0.00378541, unit: 'US gallon', symbol: 'gal' },
     pint: { value: 0.000473176, unit: 'US pint', symbol: 'pt' },
-    floz: { value: 2.9574e-5, unit: 'US fluid ounce', symbol: 'fl oz' }
+    floz: { value: 2.9574e-5, unit: 'US fluid ounce', symbol: 'fl oz' },
   },
 
   // Electrical Current
@@ -149,34 +158,34 @@ export const globalUnits = {
     A: { value: 1, unit: 'ampere', symbol: 'A' },
     mA: { value: 0.001, unit: 'milliampere', symbol: 'mA' },
     uA: { value: 0.000001, unit: 'microampere', symbol: 'uA' },
-    kA: { value: 1000, unit: 'kiloampere', symbol: 'kA' }
+    kA: { value: 1000, unit: 'kiloampere', symbol: 'kA' },
   },
 
   // Resistance / Conductance
   resistance: {
     ohm: { value: 1, unit: 'ohm' },
-    kohm: { value: 1000, unit: 'kiloohm'},
-    megaohm: { value: 1e6, unit: 'megaohm'},
-    S: { value: 1, unit: 'siemens', symbol: 'S', note: 'conductance' }
+    kohm: { value: 1000, unit: 'kiloohm' },
+    megaohm: { value: 1e6, unit: 'megaohm' },
+    S: { value: 1, unit: 'siemens', symbol: 'S', note: 'conductance' },
   },
 
   // Capacitance / Inductance
   capacitance: {
     F: { value: 1, unit: 'farad', symbol: 'F' },
-    mF: { value: 0.001, unit: 'millifarad'},
-    uF: { value: 0.000001, unit: 'microfarad' }
+    mF: { value: 0.001, unit: 'millifarad' },
+    uF: { value: 0.000001, unit: 'microfarad' },
   },
   inductance: {
     H: { value: 1, unit: 'henry', symbol: 'H' },
     mH: { value: 0.001, unit: 'millihenry', symbol: 'mH' },
-    uH: { value: 0.000001, unit: 'microhenry', symbol: 'uH' }
+    uH: { value: 0.000001, unit: 'microhenry', symbol: 'uH' },
   },
 
   // Luminous Intensity / Illuminance
   light: {
     cd: { value: 1, unit: 'candela', symbol: 'cd' },
     lm: { value: 1, unit: 'lumen', symbol: 'lm' },
-    lx: { value: 1, unit: 'lux', symbol: 'lx' }
+    lx: { value: 1, unit: 'lux', symbol: 'lx' },
   },
 
   // Data / Digital Storage
@@ -186,17 +195,16 @@ export const globalUnits = {
     KB: { value: 8e3, unit: 'kilobyte', symbol: 'KB' },
     MB: { value: 8e6, unit: 'megabyte', symbol: 'MB' },
     GB: { value: 8e9, unit: 'gigabyte', symbol: 'GB' },
-    TB: { value: 8e12, unit: 'terabyte', symbol: 'TB' }
+    TB: { value: 8e12, unit: 'terabyte', symbol: 'TB' },
   },
 
   // Angle
   angle: {
     deg: { value: 1, unit: 'degree', symbol: '°' },
     rad: { value: 57.2958, unit: 'radian', symbol: 'rad', note: '1 rad = 57.2958°' },
-    grad:{ value: 0.9, unit: 'grad', symbol: 'grad', note: '1 grad = 0.9°' }
+    grad: { value: 0.9, unit: 'grad', symbol: 'grad', note: '1 grad = 0.9°' },
   },
   radiation: {
-    // Absorbed Dose
     Gy: { value: 1, unit: 'gray', symbol: 'Gy', note: 'Absorbed dose: 1 Gy = 1 J/kg' },
     mGy: { value: 0.001, unit: 'milligray', symbol: 'mGy' },
     rad: { value: 0.01, unit: 'rad', symbol: 'rad', note: '1 rad = 0.01 Gy' },
@@ -212,6 +220,6 @@ export const globalUnits = {
     MBq: { value: 1e6, unit: 'megabecquerel', symbol: 'MBq' },
     GBq: { value: 1e9, unit: 'gigabecquerel', symbol: 'GBq' },
     Ci: { value: 3.7e10, unit: 'curie', symbol: 'Ci', note: '1 Ci = 3.7 x 10¹⁰ decays per second' },
-    mCi: { value: 3.7e7, unit: 'millicurie', symbol: 'mCi' }
-  }
-};
+    mCi: { value: 3.7e7, unit: 'millicurie', symbol: 'mCi' },
+  },
+};

package/src/utils/matrix.js

@@ -1,11 +1,11 @@
-export const isDenseMatrixWrapper = (value) =>
+export const isDenseMatrixWrapper = (/** @type {any} */ value) =>
   value &&
-  typeof value === "object" &&
-  value.exprify === "DenseMatrix" &&
-  "data" in value &&
-  "size" in value;
+  typeof value === 'object' &&
+  value.exprify === 'DenseMatrix' &&
+  'data' in value &&
+  'size' in value;
 
-export const cloneMatrixData = (value) => {
+export const cloneMatrixData = (/** @type {any[]} */ value) => {
   if (Array.isArray(value)) {
     return value.map(cloneMatrixData);
   }
@@ -13,7 +13,7 @@ export const cloneMatrixData = (value) => {
   return value;
 };
 
-export const getMatrixSize = (data) => {
+export const getMatrixSize = (/** @type {any[]} */ data) => {
   if (Array.isArray(data) && data.every(Array.isArray)) {
     return [data.length, data[0]?.length || 0];
   }
@@ -22,24 +22,24 @@ export const getMatrixSize = (data) => {
     return [data.length];
   }
 
-  throw new Error("Matrix data must be an array");
+  throw new Error('Matrix data must be an array');
 };
 
-export const wrapDenseMatrix = (data) => ({
-  exprify: "DenseMatrix",
+export const wrapDenseMatrix = (/** @type {any[][]} */ data) => ({
+  exprify: 'DenseMatrix',
   data: cloneMatrixData(data),
-  size: getMatrixSize(data)
+  size: getMatrixSize(data),
 });
 
-export const unwrapDenseMatrix = (value) =>
+export const unwrapDenseMatrix = (/** @type {any} */ value) =>
   isDenseMatrixWrapper(value) ? cloneMatrixData(value.data) : value;
 
-export const serializeExprifyValue = (value) => {
+export const serializeExprifyValue = (/** @type {any} */ value) => {
   if (isDenseMatrixWrapper(value)) {
     return JSON.stringify(value);
   }
 
-  if (Array.isArray(value) || (value && typeof value === "object")) {
+  if (Array.isArray(value) || (value && typeof value === 'object')) {
     return JSON.stringify(value, (_, current) => {
       if (isDenseMatrixWrapper(current)) {
         return current;