simple-graph-query 2.7.2 → 2.8.2

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);
@@ -49461,25 +49502,21 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                     break;
                 case "in":
                 case "ni": {
-                    let membershipResult;
-                    // this should be true if the left value is equal to the right value,
-                    // or a subset of it
-                    if (isTupleArray(leftChildValue) && isTupleArray(rightChildValue)) {
-                        if (areTupleArraysEqual(leftChildValue, rightChildValue)) {
-                            membershipResult = true;
-                        }
-                        else {
-                            // check if left is subset of right
-                            membershipResult = isTupleArraySubset(leftChildValue, rightChildValue);
-                        }
-                    }
-                    else if (isTupleArray(rightChildValue)) {
-                        membershipResult = rightChildValue.some((tuple) => tuple.length === 1 && tuple[0] === leftChildValue);
-                    }
-                    else {
-                        // left is a tuple array but right is a single value, so false
-                        membershipResult = false;
-                    }
+                    // In Alloy/Forge everything is a relation, and a scalar is just a
+                    // singleton set. Lift any scalar operand to a singleton tuple so `in`
+                    // is uniformly subset:
+                    //   a in b     ({a} ⊆ {b})  -> equality when both are scalars
+                    //   a in {..}  ({a} ⊆ set)  -> membership
+                    //   {..} in b  (set ⊆ {b})  -> subset of a singleton
+                    // isTupleArraySubset already returns true for equal sets and for an
+                    // empty left-hand set, so a single subset check covers every case.
+                    const leftSet = isSingleValue(leftChildValue)
+                        ? [[leftChildValue]]
+                        : leftChildValue;
+                    const rightSet = isSingleValue(rightChildValue)
+                        ? [[rightChildValue]]
+                        : rightChildValue;
+                    const membershipResult = isTupleArraySubset(leftSet, rightSet);
                     results = ctx.compareOp()?.text === "ni" ? !membershipResult : membershipResult;
                     break;
                 }
@@ -50367,7 +50404,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 +50415,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 +50438,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.2",
   "description": "TypeScript evaluator for Forge expressions with browser-compatible UMD bundle",
   "main": "dist/simple-graph-query.bundle.js",
   "types": "dist/index.d.ts",