@cortex-js/compute-engine 0.19.0 → 0.19.1

package/dist/compute-engine.js

@@ -1,4 +1,4 @@
-/** CortexJS Compute Engine 0.19.0 */
+/** CortexJS Compute Engine 0.19.1 */
     (function(global,factory){typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'],factory):(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ComputeEngine = {}));})(this, (function (exports) { 'use strict';
 var ComputeEngine = (() => {
   var __create = Object.create;
@@ -12306,90 +12306,6 @@ var ComputeEngine = (() => {
     const t = z + gammaG + 0.5;
     return Math.sqrt(2 * Math.PI) * Math.pow(t, z + 0.5) * Math.exp(-t) * x;
   }
-  function fromDigits(s, base = 10) {
-    let value = 0;
-    for (let i = 0; i < s.length; i++) {
-      const k = {
-        " ": -1,
-        "\xA0": -1,
-        // NBS
-        "\u2000": -1,
-        // EN QUAD
-        "\u2001": -1,
-        // EM QUAD
-        "\u2002": -1,
-        // EN SPACE
-        "\u2003": -1,
-        // EM SPACE
-        "\u2004": -1,
-        // THREE-PER-EM SPACE
-        "\u2005": -1,
-        // FOUR-PER-EM SPACE
-        "\u2006": -1,
-        // SIX-PER-EM SPACE
-        "\u2007": -1,
-        // FIGURE SPACE
-        "\u2008": -1,
-        // PUNCTUATION SPACE
-        "\u2009": -1,
-        // THIN SPACE
-        "\u200A": -1,
-        // HAIR SPACE
-        "\u200B": -1,
-        // ZWS
-        "\u202F": -1,
-        // NARROW NBS
-        "\u205F": -1,
-        // MEDIUM MATHEMATICAL SPACE
-        "_": -1,
-        ",": -1,
-        "0": 0,
-        "1": 1,
-        "2": 2,
-        "3": 3,
-        "4": 4,
-        "5": 5,
-        "6": 6,
-        "7": 7,
-        "8": 8,
-        "9": 9,
-        "a": 10,
-        "b": 11,
-        "c": 12,
-        "d": 13,
-        "e": 14,
-        "f": 15,
-        "g": 16,
-        "h": 17,
-        "i": 18,
-        "j": 19,
-        "k": 20,
-        "l": 21,
-        "m": 22,
-        "n": 23,
-        "o": 24,
-        "p": 25,
-        "q": 26,
-        "r": 27,
-        "s": 28,
-        "t": 29,
-        "u": 30,
-        "v": 31,
-        "w": 32,
-        "x": 33,
-        "y": 34,
-        "z": 35
-      }[s[i]];
-      if (k !== -1) {
-        if (k === void 0)
-          return [value, s.substring(i)];
-        if (k >= base)
-          return [value, s.substring(i)];
-        value = value * base + k;
-      }
-    }
-    return [value, ""];
-  }
   function asFloat(expr) {
     if (expr === void 0 || expr === null)
       return null;
@@ -12540,6 +12456,148 @@ var ComputeEngine = (() => {
     const [val, err] = extrapolate(f, x, { step: dir > 0 ? 1 : -1 });
     return val;
   }
+  function fromRoman(roman) {
+    if (roman === "N")
+      return [0, ""];
+    const romanMap = {
+      I: 1,
+      V: 5,
+      X: 10,
+      L: 50,
+      C: 100,
+      D: 500,
+      M: 1e3
+    };
+    let total = 0;
+    let prevValue = 0;
+    roman = roman.toUpperCase();
+    for (let i = roman.length - 1; i >= 0; i--) {
+      const currentValue = romanMap[roman[i]];
+      if (currentValue === void 0)
+        return [total, roman.slice(i)];
+      if (currentValue < prevValue)
+        total -= currentValue;
+      else
+        total += currentValue;
+      prevValue = currentValue;
+    }
+    return [total, ""];
+  }
+  function fromDigits(s, baseInput) {
+    s = s.trim();
+    if (s.length === 0)
+      return [NaN, ""];
+    if (s.startsWith("+"))
+      return fromDigits(s.slice(1), baseInput);
+    if (s.startsWith("-")) {
+      const [v, r] = fromDigits(s.slice(1), baseInput);
+      return [-v, r];
+    }
+    let base = 10;
+    if (typeof baseInput === "string")
+      baseInput = baseInput.toLowerCase();
+    if (s.startsWith("0x")) {
+      base = 16;
+      s = s.slice(2);
+    } else if (s.startsWith("0b")) {
+      base = 2;
+      s = s.slice(2);
+    } else if (baseInput === "roman") {
+      return fromRoman(s);
+    } else if (baseInput === "base64" || baseInput === "base-64") {
+      try {
+        return [parseInt(btoa(s)), ""];
+      } catch (e) {
+        return [NaN, ""];
+      }
+    } else if (typeof baseInput === "number") {
+      base = baseInput;
+    } else if (typeof baseInput === "string") {
+      base = parseInt(baseInput);
+    }
+    let value = 0;
+    for (let i = 0; i < s.length; i++) {
+      const k = {
+        " ": -1,
+        "\xA0": -1,
+        // NBS
+        "\u2000": -1,
+        // EN QUAD
+        "\u2001": -1,
+        // EM QUAD
+        "\u2002": -1,
+        // EN SPACE
+        "\u2003": -1,
+        // EM SPACE
+        "\u2004": -1,
+        // THREE-PER-EM SPACE
+        "\u2005": -1,
+        // FOUR-PER-EM SPACE
+        "\u2006": -1,
+        // SIX-PER-EM SPACE
+        "\u2007": -1,
+        // FIGURE SPACE
+        "\u2008": -1,
+        // PUNCTUATION SPACE
+        "\u2009": -1,
+        // THIN SPACE
+        "\u200A": -1,
+        // HAIR SPACE
+        "\u200B": -1,
+        // ZWS
+        "\u202F": -1,
+        // NARROW NBS
+        "\u205F": -1,
+        // MEDIUM MATHEMATICAL SPACE
+        "_": -1,
+        ",": -1,
+        "0": 0,
+        "1": 1,
+        "2": 2,
+        "3": 3,
+        "4": 4,
+        "5": 5,
+        "6": 6,
+        "7": 7,
+        "8": 8,
+        "9": 9,
+        "a": 10,
+        "b": 11,
+        "c": 12,
+        "d": 13,
+        "e": 14,
+        "f": 15,
+        "g": 16,
+        "h": 17,
+        "i": 18,
+        "j": 19,
+        "k": 20,
+        "l": 21,
+        "m": 22,
+        "n": 23,
+        "o": 24,
+        "p": 25,
+        "q": 26,
+        "r": 27,
+        "s": 28,
+        "t": 29,
+        "u": 30,
+        "v": 31,
+        "w": 32,
+        "x": 33,
+        "y": 34,
+        "z": 35
+      }[s[i]];
+      if (k !== -1) {
+        if (k === void 0)
+          return [value, s.substring(i)];
+        if (k >= base)
+          return [value, s.substring(i)];
+        value = value * base + k;
+      }
+    }
+    return [value, ""];
+  }
 
   // src/compute-engine/numerics/numeric-bigint.ts
   function bigint(a) {
@@ -20726,23 +20784,24 @@ var ComputeEngine = (() => {
         // @todo could accept `0xcafe`, `0b01010` or `(deadbeef)_16` as string formats
         // @todo could accept "roman"... as base
         // @todo could accept optional third parameter as the (padded) length of the output
-        threadable: true,
         signature: {
-          domain: ["FunctionOf", "Strings", ["OptArg", "Integers"], "Integers"],
+          domain: ["FunctionOf", "Strings", ["OptArg", "Anything"], "Integers"],
           evaluate: (ce, ops2) => {
-            const op12 = ops2[0];
-            if (!op12.string)
-              return ce.domainError("Strings", op12.domain, op12);
-            const op22 = ops2[1];
+            let op12 = ops2[0]?.string;
+            if (!op12)
+              return ce.domainError("Strings", ops2[0]?.domain, ops2[0]);
+            op12 = op12.trim();
+            if (op12.startsWith("0x"))
+              return ce.number(parseInt(op12.slice(2), 16));
+            if (op12.startsWith("0b"))
+              return ce.number(parseInt(op12.slice(2), 2));
+            const op22 = ops2[1] ?? ce.Nothing;
             if (op22.isNothing)
-              return ce.number(Number.parseInt(op12.string, 10));
-            if (op22.numericValue === null) {
-              return ce.error(["unexpected-base", op22.latex], op22);
-            }
+              return ce.number(Number.parseInt(op12, 10));
             const base = asFloat(op22);
-            if (!Number.isInteger(base) || base < 2 || base > 36)
+            if (base && (!Number.isInteger(base) || base < 2 || base > 36))
               return ce.error(["unexpected-base", base], op22);
-            const [value, rest] = fromDigits(op12.string, base);
+            const [value, rest] = fromDigits(op12, op22.string ?? op22.symbol ?? 10);
             if (rest)
               return ce.error(["unexpected-digit", { str: rest[0] }], {
                 str: rest
@@ -20764,7 +20823,7 @@ var ComputeEngine = (() => {
             const val = asFloat(op12) ?? NaN;
             if (Number.isNaN(val) || !Number.isInteger(val))
               return ce.domainError("Integers", op12.domain, op12);
-            const op22 = ops2[1];
+            const op22 = ops2[1] ?? ce.Nothing;
             if (op22.isNothing) {
               const op1Num = op12.numericValue;
               if (typeof op1Num === "number")
@@ -27443,19 +27502,19 @@ ${JSON.stringify(entry)}`
       if (symDef) {
         if (symDef.constant)
           throw Error(`Cannot assign a value to the constant "${id}"`);
-        if (args)
-          throw Error(`The symbol "${id}" is not a function`);
-        if (typeof value === "function")
+        if (!symDef.inferredDomain && isFunctionValue(value))
           throw Error(`Cannot assign a function to symbol "${id}"`);
-        if (value === void 0 || value === null) {
-          symDef.value = void 0;
-          return this;
-        }
         const scope = symDef.scope;
         scope?.ids?.delete(symDef.name);
-        symDef.value = this.box(value);
-        scope?.ids?.set(symDef.name, symDef);
-        return this;
+        if (!args && !isFunctionValue(value)) {
+          if (value === void 0 || value === null) {
+            symDef.value = void 0;
+            return this;
+          }
+          symDef.value = this.box(value);
+          scope?.ids?.set(symDef.name, symDef);
+          return this;
+        }
       }
       const fnDef = this.lookupFunction(id);
       if (fnDef) {
@@ -27465,17 +27524,15 @@ ${JSON.stringify(entry)}`
           return this;
         if (typeof value === "function") {
           const previousScope2 = this.swapScope(scope);
-          this.defineFunction(id, {
-            signature: { evaluate: value }
-          });
+          this.defineFunction(id, { signature: { evaluate: value } });
           this.swapScope(previousScope2);
           return this;
         }
+        if (args && isFunctionValue(value))
+          throw Error(`Unexpected arguments for "${id}"`);
         const val = args ? this.box(["Function", value, ...args]) : this.box(value);
         const previousScope = this.swapScope(scope);
-        this.defineFunction(id, {
-          signature: { evaluate: val }
-        });
+        this.defineFunction(id, { signature: { evaluate: val } });
         this.swapScope(previousScope);
         return this;
       }
@@ -27484,9 +27541,11 @@ ${JSON.stringify(entry)}`
         return this;
       }
       if (typeof value === "function") {
-        this.defineFunction(id, {
-          signature: { evaluate: value }
-        });
+        this.defineFunction(id, { signature: { evaluate: value } });
+        return this;
+      }
+      if (value instanceof _BoxedExpression && value.domain?.base === "Functions") {
+        this.defineFunction(id, { signature: { evaluate: value } });
         return this;
       }
       if (Array.isArray(value) || value instanceof _BoxedExpression || args) {
@@ -28076,12 +28135,19 @@ ${JSON.stringify(entry)}`
       }
     }
   };
+  function isFunctionValue(value) {
+    if (typeof value === "function")
+      return true;
+    if (value instanceof _BoxedExpression && value.domain?.base === "Functions")
+      return true;
+    return false;
+  }
 
   // src/compute-engine.ts
-  var version = "0.19.0";
+  var version = "0.19.1";
   globalThis[Symbol.for("io.cortexjs.compute-engine")] = {
     ComputeEngine: ComputeEngine.prototype.constructor,
-    version: "0.19.0"
+    version: "0.19.1"
   };
   return __toCommonJS(compute_engine_exports);
 })();