simple-graph-query 2.7.2 → 2.8.1

package/dist/simple-graph-query.bundle.js

@@ -48590,7 +48590,7 @@ function bitwidthWraparound(value, bitwidth) {
 // this is a list of forge builtin functions we currently support; add to this
 // list as we support more
 const SUPPORTED_BINARY_BUILTINS = ["add", "subtract", "multiply", "divide", "remainder"];
-const SUPPORTED_UNARY_BUILTINS = ["abs", "sign"];
+const SUPPORTED_UNARY_BUILTINS = ["abs", "sign", "floor", "ceil"];
 const SUPPORTED_SET_BUILTINS = ["min", "max"];
 exports.SUPPORTED_BUILTINS = SUPPORTED_BINARY_BUILTINS.concat(SUPPORTED_UNARY_BUILTINS, SUPPORTED_SET_BUILTINS);
 /**
@@ -48987,6 +48987,46 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                 varNames.push(varName);
                 quantifiedSets.push(varQuantifiedSets[varName]);
             }
+            // `sum <decls> | <intExpr>`: accumulate the numeric body over every
+            // binding of the quantified variables. Unlike the boolean quantifiers
+            // below, the body evaluates to a number, so this needs its own loop --
+            // and it must not use the boolean numeric-comparison optimization, which
+            // skips body evaluation entirely.
+            if (ctx.quant().SUM_TOK()) {
+                const sumCombinations = getCombinations(quantifiedSets);
+                const sumEnv = { env: {}, type: "quantDecl" };
+                this.environmentStack.push(sumEnv);
+                let total = 0;
+                for (const tuple of sumCombinations) {
+                    if (isDisjoint) {
+                        const seen = new Set();
+                        let tupleDisjoint = true;
+                        for (const val of tuple) {
+                            if (seen.has(val)) {
+                                tupleDisjoint = false;
+                                break;
+                            }
+                            seen.add(val);
+                        }
+                        if (!tupleDisjoint) {
+                            continue;
+                        }
+                    }
+                    for (let j = 0; j < varNames.length; j++) {
+                        sumEnv.env[varNames[j]] = tuple[j];
+                    }
+                    const bodyValue = this.visit(barExpr);
+                    const bodyNumber = extractNumber(bodyValue);
+                    if (bodyNumber === undefined) {
+                        this.environmentStack.pop();
+                        throw new Error("Expected the expression after the bar in a `sum` to evaluate to a number!");
+                    }
+                    total += bodyNumber;
+                }
+                this.environmentStack.pop();
+                this.cacheResult(ctx, freeVarsKey, total);
+                return total;
+            }
             // Try to optimize numeric comparisons
             let product;
             let useOptimizedPath = false;
@@ -49133,7 +49173,8 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                     return value;
                 }
             }
-            // TODO: don't have support for SUM_TOK yet
+            // NOTE: SUM_TOK is handled above (it returns a number, not a boolean),
+            // before this boolean-quantifier result logic.
         }
         // TODO: fix this!
         const childrenResults = this.visitChildren(ctx);
@@ -50367,7 +50408,7 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                 result = arg1 * arg2;
                 break;
             case "divide":
-                result = Math.floor(arg1 / arg2); // Integer division
+                result = arg1 / arg2; // Real (floating-point) division
                 break;
             case "remainder":
                 result = arg1 % arg2;
@@ -50378,17 +50419,17 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
         return result;
     }
     evaluateUnaryOperation(operation, args) {
-        if (!isSingleValue(args) || !isNumber(args)) {
+        const v = extractNumber(args);
+        if (v === undefined) {
             throw new Error(`Expected 1 argument for ${operation} that evaluates to a number.`);
         }
-        let v = args;
         // Possible unary operations:
-        //abs[]: returns the absolute value of value
-        //sign[]: returns 1 if value is > 0, 0 if value is 0, and -1 if value is < 0
+        //abs[]:   returns the absolute value of value
+        //sign[]:  returns 1 if value is > 0, 0 if value is 0, and -1 if value is < 0
+        //floor[]: rounds value down to the nearest integer
+        //ceil[]:  rounds value up to the nearest integer
         if (operation === "abs") {
-            let res = Math.abs(v);
-            // Now adjust to the bitwidth
-            return res;
+            return Math.abs(v);
         }
         else if (operation === "sign") {
             if (v > 0) {
@@ -50401,6 +50442,12 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                 return 0;
             }
         }
+        else if (operation === "floor") {
+            return Math.floor(v);
+        }
+        else if (operation === "ceil") {
+            return Math.ceil(v);
+        }
         else {
             throw new Error(`Unsupported operation: ${operation}`);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "simple-graph-query",
-  "version": "2.7.2",
+  "version": "2.8.1",
   "description": "TypeScript evaluator for Forge expressions with browser-compatible UMD bundle",
   "main": "dist/simple-graph-query.bundle.js",
   "types": "dist/index.d.ts",