@cortex-js/compute-engine 0.35.3 → 0.35.5

package/dist/compute-engine.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.35.3 */
+/** Compute Engine 0.35.5 */
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -23824,7 +23824,8 @@ function typeCouldBeCollection(type2) {
   }
   if (type2.kind === "list" || type2.kind === "set" || type2.kind === "tuple")
     return true;
-  if (type2.kind === "union") return type2.types.some((t) => typeCouldBeCollection(t));
+  if (type2.kind === "union")
+    return type2.types.some((t) => typeCouldBeCollection(t));
   return false;
 }
 function typeCouldBeNumericCollection(type2) {
@@ -24632,6 +24633,16 @@ var init_arithmetic = __esm({
             return engine.function("Power", [engine.E, ...args]);
           }
         },
+        Exp2: {
+          description: "Base-2 exponential: 2^x",
+          complexity: 3500,
+          broadcastable: true,
+          signature: "(number) -> number",
+          canonical: (args, { engine }) => {
+            args = checkNumericArgs(engine, args, 1);
+            return engine.function("Power", [engine.number(2), ...args]);
+          }
+        },
         Factorial: {
           description: "Factorial function: the product of all positive integers less than or equal to n",
           wikidata: "Q120976",
@@ -24721,6 +24732,22 @@ var init_arithmetic = __esm({
             (z) => z.floor(0)
           )
         },
+        Fract: {
+          description: "Fractional part of a number: x - floor(x)",
+          complexity: 1250,
+          broadcastable: true,
+          signature: "(number) -> number",
+          sgn: ([x]) => {
+            if (x.isNonNegative) return "non-negative";
+            return void 0;
+          },
+          evaluate: ([x]) => apply(
+            x,
+            (x2) => x2 - Math.floor(x2),
+            (x2) => x2.sub(x2.floor()),
+            (z) => z.sub(z.floor(0))
+          )
+        },
         Gamma: {
           wikidata: "Q190573",
           complexity: 8e3,
@@ -24936,6 +24963,22 @@ var init_arithmetic = __esm({
           sgn: ([x]) => lnSign(x),
           canonical: ([x], { engine }) => engine._fn("Log", [x])
         },
+        Log10: {
+          description: "Base-10 Logarithm",
+          complexity: 4100,
+          broadcastable: true,
+          signature: "(number) -> number",
+          sgn: ([x]) => lnSign(x),
+          canonical: ([x], { engine }) => engine._fn("Log", [x])
+        },
+        Log2: {
+          description: "Base-2 Logarithm",
+          complexity: 4100,
+          broadcastable: true,
+          signature: "(number) -> number",
+          sgn: ([x]) => lnSign(x),
+          canonical: ([x], { engine }) => engine._fn("Log", [x, engine.number(2)])
+        },
         Mod: {
           description: "Modulo",
           wikidata: "Q1799665",
@@ -25178,6 +25221,18 @@ var init_arithmetic = __esm({
           },
           evaluate: ([x, n], { numericApproximation }) => root(x, n, { numericApproximation })
         },
+        Remainder: {
+          description: "IEEE remainder: the signed remainder after dividing x by y, with the quotient rounded to the nearest integer",
+          complexity: 2500,
+          broadcastable: true,
+          signature: "(number, number) -> number",
+          evaluate: ([a, b]) => apply2(
+            a,
+            b,
+            (a2, b2) => a2 - b2 * Math.round(a2 / b2),
+            (a2, b2) => a2.sub(b2.mul(a2.div(b2).round()))
+          )
+        },
         Round: {
           complexity: 1250,
           broadcastable: true,
@@ -25309,6 +25364,19 @@ var init_arithmetic = __esm({
             const rest = args.slice(1);
             return canonicalAdd(engine, [first, ...rest.map((x) => x.neg())]);
           }
+        },
+        Truncate: {
+          description: "Rounds a number towards zero (removes the fractional part)",
+          complexity: 1250,
+          broadcastable: true,
+          signature: "(number) -> integer",
+          sgn: ([x]) => x.sgn,
+          evaluate: ([x]) => apply(
+            x,
+            Math.trunc,
+            (x2) => x2.trunc(),
+            (z) => z.trunc(0)
+          )
         }
       },
       {
@@ -32603,7 +32671,7 @@ var DERIVATIVES_TABLE = {
     ]
   ],
   // d/dx ln(Γ(x)) = ψ(x) (digamma function)
-  LogGamma: ["Digamma", "_"],
+  GammaLn: ["Digamma", "_"],
   // d/dx ψ(x) = ψ₁(x) (trigamma function)
   // https://en.wikipedia.org/wiki/Trigamma_function
   Digamma: ["Trigamma", "_"],
@@ -35595,8 +35663,7 @@ function numberForm(expr) {
 function multiplyForm(expr) {
   if (!expr.ops) return expr;
   const ops = expr.ops.map(multiplyForm);
-  if (expr.operator === "Multiply")
-    return canonicalMultiply(expr.engine, ops);
+  if (expr.operator === "Multiply") return canonicalMultiply(expr.engine, ops);
   if (expr.operator === "Negate")
     return canonicalMultiply(expr.engine, [ops[0], expr.engine.NegativeOne]);
   return expr;
@@ -45969,7 +46036,8 @@ var BoxedFunction = class extends _BoxedExpression {
     return this.numeratorDenominator[1];
   }
   get numeratorDenominator() {
-    if (!(this.isCanonical || this.isStructural)) return [this, this.engine.One];
+    if (!(this.isCanonical || this.isStructural))
+      return [this, this.engine.One];
     if (this.isNumber !== true)
       return [this.engine.Nothing, this.engine.Nothing];
     const operator2 = this.operator;
@@ -46007,11 +46075,13 @@ var BoxedFunction = class extends _BoxedExpression {
   // ALGEBRAIC OPERATIONS
   //
   neg() {
-    if (!(this.isCanonical || this.isStructural)) throw new Error("Not canonical");
+    if (!(this.isCanonical || this.isStructural))
+      throw new Error("Not canonical");
     return negate(this);
   }
   inv() {
-    if (!(this.isCanonical || this.isStructural)) throw new Error("Not canonical");
+    if (!(this.isCanonical || this.isStructural))
+      throw new Error("Not canonical");
     if (this.isOne) return this;
     if (this.isNegativeOne) return this;
     if (this.operator === "Sqrt") return this.op1.inv().sqrt();
@@ -46032,7 +46102,8 @@ var BoxedFunction = class extends _BoxedExpression {
     return this.engine._fn("Divide", [this.engine.One, this]);
   }
   abs() {
-    if (!(this.isCanonical || this.isStructural)) throw new Error("Not canonical");
+    if (!(this.isCanonical || this.isStructural))
+      throw new Error("Not canonical");
     if (this.operator === "Abs" || this.operator === "Negate") return this;
     if (this.isNonNegative) return this;
     if (this.isNonPositive) return this.neg();
@@ -46040,11 +46111,13 @@ var BoxedFunction = class extends _BoxedExpression {
   }
   add(rhs) {
     if (rhs === 0) return this;
-    if (!(this.isCanonical || this.isStructural)) throw new Error("Not canonical");
+    if (!(this.isCanonical || this.isStructural))
+      throw new Error("Not canonical");
     return add3(this, this.engine.box(rhs));
   }
   mul(rhs) {
-    if (!(this.isCanonical || this.isStructural)) throw new Error("Not canonical");
+    if (!(this.isCanonical || this.isStructural))
+      throw new Error("Not canonical");
     if (rhs === 0) return this.engine.Zero;
     if (rhs === 1) return this;
     if (rhs === -1) return this.neg();
@@ -46056,7 +46129,8 @@ var BoxedFunction = class extends _BoxedExpression {
     return mul3(this, this.engine.box(rhs));
   }
   div(rhs) {
-    if (!(this.isCanonical || this.isStructural)) throw new Error("Not canonical");
+    if (!(this.isCanonical || this.isStructural))
+      throw new Error("Not canonical");
     return div2(this, rhs);
   }
   pow(exp3) {
@@ -46122,7 +46196,8 @@ var BoxedFunction = class extends _BoxedExpression {
   }
   ln(semiBase) {
     const base = semiBase ? this.engine.box(semiBase) : void 0;
-    if (!(this.isCanonical || this.isStructural)) throw new Error("Not canonical");
+    if (!(this.isCanonical || this.isStructural))
+      throw new Error("Not canonical");
     if (this.is(0)) return this.engine.NegativeInfinity;
     if (this.operator === "Exp") {
       if (!base) return this.op1;
@@ -51457,7 +51532,7 @@ var JAVASCRIPT_FUNCTIONS = {
   Arsinh: "Math.asinh",
   Arctan: "Math.atan",
   Artanh: "Math.atanh",
-  Ceiling: "Math.ceil",
+  Ceil: "Math.ceil",
   Chop: "_SYS.chop",
   Cos: "Math.cos",
   Cosh: "Math.cosh",
@@ -51487,10 +51562,7 @@ var JAVASCRIPT_FUNCTIONS = {
   Floor: "Math.floor",
   Fract: ([x], compile) => {
     if (x === null) throw new Error("Fract: no argument");
-    return BaseCompiler.inlineExpression(
-      "${x} - Math.floor(${x})",
-      compile(x)
-    );
+    return BaseCompiler.inlineExpression("${x} - Math.floor(${x})", compile(x));
   },
   Gamma: "_SYS.gamma",
   GCD: "_SYS.gcd",
@@ -51503,7 +51575,7 @@ var JAVASCRIPT_FUNCTIONS = {
     if (args.length === 1) return `Math.log10(${compile(args[0])})`;
     return `(Math.log(${compile(args[0])}) / Math.log(${compile(args[1])}))`;
   },
-  LogGamma: "_SYS.lngamma",
+  GammaLn: "_SYS.lngamma",
   Lb: "Math.log2",
   Max: "Math.max",
   Mean: (args, compile) => {
@@ -51632,7 +51704,7 @@ var JAVASCRIPT_FUNCTIONS = {
     if (arg === null) throw new Error("Sech: no argument");
     return `1 / Math.cosh(${compile(arg)})`;
   },
-  Sgn: "Math.sign",
+  Sign: "Math.sign",
   Sin: "Math.sin",
   Sinh: "Math.sinh",
   Sqrt: "Math.sqrt",
@@ -51900,7 +51972,7 @@ var GLSL_FUNCTIONS = {
   Arccos: "acos",
   Arcsin: "asin",
   Arctan: "atan",
-  Ceiling: "ceil",
+  Ceil: "ceil",
   Clamp: "clamp",
   Cos: "cos",
   Degrees: "degrees",
@@ -51988,7 +52060,7 @@ var GLSL_FUNCTIONS = {
     return `acosh(1.0 / (${compile(x)}))`;
   },
   // Additional math functions
-  Sgn: "sign",
+  // Sign is already registered in the standard functions above
   Lb: "log2",
   Log: (args, compile) => {
     if (args.length === 0) throw new Error("Log: no argument");
@@ -52555,7 +52627,7 @@ function floor2(x) {
   const flo = Math.floor(xVal.lo);
   const fhi = Math.floor(xVal.hi);
   if (flo === fhi) return ok({ lo: flo, hi: fhi });
-  return { kind: "singular", at: flo + 1 };
+  return { kind: "singular", at: flo + 1, continuity: "right" };
 }
 function ceil2(x) {
   const unwrapped = unwrapOrPropagate(x);
@@ -52564,7 +52636,7 @@ function ceil2(x) {
   const clo = Math.ceil(xVal.lo);
   const chi = Math.ceil(xVal.hi);
   if (clo === chi) return ok({ lo: clo, hi: chi });
-  return { kind: "singular", at: clo };
+  return { kind: "singular", at: clo, continuity: "left" };
 }
 function round2(x) {
   const unwrapped = unwrapOrPropagate(x);
@@ -52573,7 +52645,7 @@ function round2(x) {
   const rlo = Math.round(xVal.lo);
   const rhi = Math.round(xVal.hi);
   if (rlo === rhi) return ok({ lo: rlo, hi: rhi });
-  return { kind: "singular", at: rlo + 0.5 };
+  return { kind: "singular", at: rlo + 0.5, continuity: "right" };
 }
 function fract(x) {
   const unwrapped = unwrapOrPropagate(x);
@@ -52584,7 +52656,7 @@ function fract(x) {
   if (flo === fhi) {
     return ok({ lo: xVal.lo - flo, hi: xVal.hi - flo });
   }
-  return { kind: "singular", at: flo + 1 };
+  return { kind: "singular", at: flo + 1, continuity: "right" };
 }
 function min2(a, b) {
   const unwrapped = unwrapOrPropagate(a, b);
@@ -52611,11 +52683,13 @@ function mod2(a, b) {
   if (containsZero(bVal)) {
     return { kind: "singular" };
   }
-  const period = Math.abs(bVal.lo === bVal.hi ? bVal.lo : Math.max(Math.abs(bVal.lo), Math.abs(bVal.hi)));
+  const period = Math.abs(
+    bVal.lo === bVal.hi ? bVal.lo : Math.max(Math.abs(bVal.lo), Math.abs(bVal.hi))
+  );
   const flo = Math.floor(aVal.lo / period);
   const fhi = Math.floor(aVal.hi / period);
   if (flo !== fhi) {
-    return { kind: "singular", at: (flo + 1) * period };
+    return { kind: "singular", at: (flo + 1) * period, continuity: "right" };
   }
   const modLo = aVal.lo - period * flo;
   const modHi = aVal.hi - period * flo;
@@ -53219,7 +53293,7 @@ var INTERVAL_JAVASCRIPT_FUNCTIONS = {
   Negate: (args, compile) => `_IA.negate(${compile(args[0])})`,
   // Elementary functions
   Abs: (args, compile) => `_IA.abs(${compile(args[0])})`,
-  Ceiling: (args, compile) => `_IA.ceil(${compile(args[0])})`,
+  Ceil: (args, compile) => `_IA.ceil(${compile(args[0])})`,
   Exp: (args, compile) => `_IA.exp(${compile(args[0])})`,
   Floor: (args, compile) => `_IA.floor(${compile(args[0])})`,
   Ln: (args, compile) => `_IA.ln(${compile(args[0])})`,
@@ -53272,7 +53346,7 @@ var INTERVAL_JAVASCRIPT_FUNCTIONS = {
     return `_IA.powInterval(${compile(arg)}, _IA.div(_IA.point(1), ${compile(exp3)}))`;
   },
   Round: (args, compile) => `_IA.round(${compile(args[0])})`,
-  Sgn: (args, compile) => `_IA.sign(${compile(args[0])})`,
+  Sign: (args, compile) => `_IA.sign(${compile(args[0])})`,
   Sqrt: (args, compile) => `_IA.sqrt(${compile(args[0])})`,
   Square: (args, compile) => `_IA.square(${compile(args[0])})`,
   // Trigonometric functions
@@ -53468,6 +53542,8 @@ const float IA_SINGULAR = 3.0;
 const float IA_PARTIAL_LO = 4.0;
 const float IA_PARTIAL_HI = 5.0;
 const float IA_PARTIAL_BOTH = 6.0;
+const float IA_SINGULAR_RIGHT = 7.0;
+const float IA_SINGULAR_LEFT = 8.0;
 
 // Interval result struct
 struct IntervalResult {
@@ -53501,12 +53577,20 @@ IntervalResult ia_singular(float at) {
   return IntervalResult(vec2(at, at), IA_SINGULAR);
 }
 
+IntervalResult ia_singular_right(float at) {
+  return IntervalResult(vec2(at, at), IA_SINGULAR_RIGHT);
+}
+
+IntervalResult ia_singular_left(float at) {
+  return IntervalResult(vec2(at, at), IA_SINGULAR_LEFT);
+}
+
 IntervalResult ia_partial(vec2 v, float clip) {
   return IntervalResult(v, clip);
 }
 
 bool ia_is_error(float status) {
-  return status == IA_EMPTY || status == IA_ENTIRE || status == IA_SINGULAR;
+  return status == IA_EMPTY || status == IA_ENTIRE || status == IA_SINGULAR || status == IA_SINGULAR_RIGHT || status == IA_SINGULAR_LEFT;
 }
 
 // Addition
@@ -53646,7 +53730,8 @@ IntervalResult ia_floor(vec2 x) {
     return ia_ok(vec2(flo, fhi));
   }
   // Interval spans an integer boundary - discontinuity at first integer > x.x
-  return ia_singular(flo + 1.0);
+  // floor is right-continuous
+  return ia_singular_right(flo + 1.0);
 }
 
 // Ceiling - has jump discontinuities at every integer
@@ -53657,7 +53742,8 @@ IntervalResult ia_ceil(vec2 x) {
     return ia_ok(vec2(clo, chi));
   }
   // Interval spans an integer boundary - discontinuity at ceil(x.x)
-  return ia_singular(clo);
+  // ceil is left-continuous
+  return ia_singular_left(clo);
 }
 
 // Round - has jump discontinuities at every half-integer
@@ -53671,7 +53757,8 @@ IntervalResult ia_round(vec2 x) {
     return ia_ok(vec2(rlo, rhi));
   }
   // Interval spans a half-integer boundary - discontinuity
-  return ia_singular(rlo + 0.5);
+  // round is right-continuous (with round-half-up convention)
+  return ia_singular_right(rlo + 0.5);
 }
 
 // Fract - sawtooth discontinuities at every integer
@@ -53684,7 +53771,8 @@ IntervalResult ia_fract(vec2 x) {
     return ia_ok(vec2(fract(x.x) - IA_EPS, fract(x.y) + IA_EPS));
   }
   // Interval spans an integer - sawtooth discontinuity
-  return ia_singular(flo + 1.0);
+  // fract is right-continuous (inherits from floor)
+  return ia_singular_right(flo + 1.0);
 }
 
 // Mod - periodic discontinuities at multiples of the modulus
@@ -53707,7 +53795,8 @@ IntervalResult ia_mod(vec2 x, vec2 y) {
       return ia_ok(vec2(min(mlo, mhi) - IA_EPS, max(mlo, mhi) + IA_EPS));
     }
     // Discontinuity at first multiple of period in the interval
-    return ia_singular((flo + 1.0) * period);
+    // mod has sawtooth discontinuities, right-continuous
+    return ia_singular_right((flo + 1.0) * period);
   }
 
   // General case: compose from existing operations
@@ -54417,7 +54506,7 @@ var INTERVAL_GLSL_FUNCTIONS = {
   Negate: (args, compile) => `ia_negate(${compile(args[0])})`,
   // Elementary functions
   Abs: (args, compile) => `ia_abs(${compile(args[0])})`,
-  Ceiling: (args, compile) => `ia_ceil(${compile(args[0])})`,
+  Ceil: (args, compile) => `ia_ceil(${compile(args[0])})`,
   Exp: (args, compile) => `ia_exp(${compile(args[0])})`,
   Floor: (args, compile) => `ia_floor(${compile(args[0])})`,
   Fract: (args, compile) => `ia_fract(${compile(args[0])})`,
@@ -54456,7 +54545,7 @@ var INTERVAL_GLSL_FUNCTIONS = {
     throw new Error("Interval GLSL does not support variable exponents");
   },
   Round: (args, compile) => `ia_round(${compile(args[0])})`,
-  Sgn: (args, compile) => `ia_sign(${compile(args[0])})`,
+  Sign: (args, compile) => `ia_sign(${compile(args[0])})`,
   Sqrt: (args, compile) => `ia_sqrt(${compile(args[0])})`,
   Square: (args, compile) => `ia_square(${compile(args[0])})`,
   // Trigonometric functions
@@ -56397,10 +56486,10 @@ function defToString(name, def, v) {
 // src/compute-engine.ts
 init_types6();
 init_base_compiler();
-var version = "0.35.3";
+var version = "0.35.5";
 globalThis[Symbol.for("io.cortexjs.compute-engine")] = {
   ComputeEngine: ComputeEngine.prototype.constructor,
-  version: "0.35.3"
+  version: "0.35.5"
 };
 export {
   BaseCompiler,