simple-graph-query 2.2.0 → 2.2.1

package/dist/NumericConstraintOptimizer.d.ts

@@ -0,0 +1,39 @@
+import { ExprContext } from "./forge-antlr/ForgeParser";
+import { Tuple } from "./ForgeExprEvaluator";
+/**
+ * Analyzes set comprehension constraints to detect simple numeric comparison patterns
+ * that can be optimized by generating only valid combinations instead of filtering.
+ */
+export interface NumericConstraintPattern {
+    type: 'less_than' | 'greater_than' | 'less_equal' | 'greater_equal' | 'not_equal' | 'none';
+    leftVar: string;
+    rightVar: string;
+}
+/**
+ * Detects if a constraint expression is a simple numeric comparison between two variables.
+ * Currently detects patterns like: a < b, a > b, a <= b, a >= b, a != b
+ *
+ * Note: Uses string matching on expression text which is simple but may miss expressions
+ * with extra whitespace or parentheses. This is intentionally conservative - we prefer
+ * to fall back to the standard approach rather than risk incorrect optimization.
+ *
+ * @param constraintExpr The constraint expression to analyze
+ * @param varNames The variable names in scope
+ * @returns Pattern info if detected, null otherwise
+ */
+export declare function detectNumericComparisonPattern(constraintExpr: ExprContext, varNames: string[]): NumericConstraintPattern | null;
+/**
+ * Checks if all values in the sets are numbers (or tuples containing single numbers).
+ * This is required for numeric comparison optimization to be applicable.
+ */
+export declare function areAllNumericSets(sets: Tuple[][]): boolean;
+/**
+ * Generates optimized combinations for numeric comparison constraints.
+ * Instead of generating all combinations and filtering, generates only valid ones.
+ *
+ * @param varNames Variable names in order
+ * @param quantifiedSets The sets each variable ranges over
+ * @param pattern The detected numeric comparison pattern
+ * @returns Only the tuples that satisfy the constraint
+ */
+export declare function generateOptimizedNumericCombinations(varNames: string[], quantifiedSets: Tuple[][], pattern: NumericConstraintPattern): Tuple[];

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

@@ -48441,6 +48441,7 @@ exports.areTupleArraysEqual = areTupleArraysEqual;
 const AbstractParseTreeVisitor_1 = __webpack_require__(/*! antlr4ts/tree/AbstractParseTreeVisitor */ "./node_modules/antlr4ts/tree/AbstractParseTreeVisitor.js");
 const lodash_1 = __webpack_require__(/*! lodash */ "./node_modules/lodash/lodash.js");
 const ForgeExprFreeVariableFinder_1 = __webpack_require__(/*! ./ForgeExprFreeVariableFinder */ "./src/ForgeExprFreeVariableFinder.ts");
+const NumericConstraintOptimizer_1 = __webpack_require__(/*! ./NumericConstraintOptimizer */ "./src/NumericConstraintOptimizer.ts");
 ///// HELPER FUNCTIONS /////
 function isSingleValue(value) {
     return (typeof value === "string" ||
@@ -48959,7 +48960,26 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                 varNames.push(varName);
                 quantifiedSets.push(varQuantifiedSets[varName]);
             }
-            const product = getCombinations(quantifiedSets);
+            // Try to optimize numeric comparisons
+            let product;
+            let useOptimizedPath = false;
+            if (!isDisjoint && varNames.length >= 2 && (0, NumericConstraintOptimizer_1.areAllNumericSets)(quantifiedSets)) {
+                // Try to detect and optimize numeric comparison patterns
+                const pattern = (0, NumericConstraintOptimizer_1.detectNumericComparisonPattern)(barExpr, varNames);
+                if (pattern && pattern.type !== 'none') {
+                    // Use optimized combination generation
+                    product = (0, NumericConstraintOptimizer_1.generateOptimizedNumericCombinations)(varNames, quantifiedSets, pattern);
+                    useOptimizedPath = true;
+                }
+                else {
+                    // Fall back to standard cartesian product
+                    product = getCombinations(quantifiedSets);
+                }
+            }
+            else {
+                // Fall back to standard cartesian product
+                product = getCombinations(quantifiedSets);
+            }
             const result = [];
             let foundTrue = false;
             let foundFalse = false;
@@ -48990,10 +49010,19 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                 for (let j = 0; j < varNames.length; j++) {
                     quantDeclEnv.env[varNames[j]] = tuple[j];
                 }
-                // now, we want to evaluate the barExpr
-                const barExprValue = this.visit(barExpr);
-                if (!isBoolean(barExprValue)) {
-                    throw new Error("Expected the expression after the bar to be a boolean!");
+                // If we used the optimized path, we can skip constraint evaluation
+                // since the combinations already satisfy the constraint
+                let barExprValue;
+                if (useOptimizedPath) {
+                    barExprValue = true;
+                }
+                else {
+                    // now, we want to evaluate the barExpr
+                    const evalResult = this.visit(barExpr);
+                    if (!isBoolean(evalResult)) {
+                        throw new Error("Expected the expression after the bar to be a boolean!");
+                    }
+                    barExprValue = evalResult;
                 }
                 if (barExprValue) {
                     result.push(tuple);
@@ -49973,7 +50002,28 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                 varNames.push(varName);
                 quantifiedSets.push(varQuantifiedSets[varName]);
             }
-            const product = getCombinations(quantifiedSets);
+            // Try to optimize numeric comparisons (same optimization as in quantifiers)
+            // Note: Set comprehensions don't support the 'disj' keyword, so we don't check for it here.
+            // Quantifiers do support 'disj', so they check !isDisjoint before optimizing.
+            let product;
+            let useOptimizedPath = false;
+            if (varNames.length >= 2 && (0, NumericConstraintOptimizer_1.areAllNumericSets)(quantifiedSets)) {
+                // Try to detect and optimize numeric comparison patterns
+                const pattern = (0, NumericConstraintOptimizer_1.detectNumericComparisonPattern)(barExpr, varNames);
+                if (pattern && pattern.type !== 'none') {
+                    // Use optimized combination generation
+                    product = (0, NumericConstraintOptimizer_1.generateOptimizedNumericCombinations)(varNames, quantifiedSets, pattern);
+                    useOptimizedPath = true;
+                }
+                else {
+                    // Fall back to standard cartesian product
+                    product = getCombinations(quantifiedSets);
+                }
+            }
+            else {
+                // Fall back to standard cartesian product
+                product = getCombinations(quantifiedSets);
+            }
             const result = [];
             // Optimize: create environment once and reuse it
             const quantDeclEnv = {
@@ -49987,10 +50037,19 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                 for (let j = 0; j < varNames.length; j++) {
                     quantDeclEnv.env[varNames[j]] = tuple[j];
                 }
-                // now, we want to evaluate the barExpr
-                const barExprValue = this.visit(barExpr);
-                if (!isBoolean(barExprValue)) {
-                    throw new Error("Expected the expression after the bar to be a boolean value!");
+                // If we used the optimized path, we can skip constraint evaluation
+                // since the combinations already satisfy the constraint
+                let barExprValue;
+                if (useOptimizedPath) {
+                    barExprValue = true;
+                }
+                else {
+                    // now, we want to evaluate the barExpr
+                    const evalResult = this.visit(barExpr);
+                    if (!isBoolean(evalResult)) {
+                        throw new Error("Expected the expression after the bar to be a boolean value!");
+                    }
+                    barExprValue = evalResult;
                 }
                 if (barExprValue) {
                     // will error if not boolean val, which we want
@@ -50657,6 +50716,200 @@ class ForgeExprFreeVariableFinder extends AbstractParseTreeVisitor_1.AbstractPar
 exports.ForgeExprFreeVariableFinder = ForgeExprFreeVariableFinder;
 
 
+/***/ }),
+
+/***/ "./src/NumericConstraintOptimizer.ts":
+/*!*******************************************!*\
+  !*** ./src/NumericConstraintOptimizer.ts ***!
+  \*******************************************/
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.detectNumericComparisonPattern = detectNumericComparisonPattern;
+exports.areAllNumericSets = areAllNumericSets;
+exports.generateOptimizedNumericCombinations = generateOptimizedNumericCombinations;
+/**
+ * Detects if a constraint expression is a simple numeric comparison between two variables.
+ * Currently detects patterns like: a < b, a > b, a <= b, a >= b, a != b
+ *
+ * Note: Uses string matching on expression text which is simple but may miss expressions
+ * with extra whitespace or parentheses. This is intentionally conservative - we prefer
+ * to fall back to the standard approach rather than risk incorrect optimization.
+ *
+ * @param constraintExpr The constraint expression to analyze
+ * @param varNames The variable names in scope
+ * @returns Pattern info if detected, null otherwise
+ */
+function detectNumericComparisonPattern(constraintExpr, varNames) {
+    // Parse the expression text to look for simple comparison patterns
+    const exprText = constraintExpr.text;
+    // Check if this is a simple binary comparison between two variables
+    // Pattern: <varName1><compareOp><varName2> (no whitespace in text representation)
+    // Note: The AST text property concatenates tokens without whitespace
+    // Try to extract comparison operator and operands
+    for (const leftVar of varNames) {
+        for (const rightVar of varNames) {
+            if (leftVar === rightVar)
+                continue;
+            // Check for different comparison operators (whitespace already removed in text)
+            if (exprText === `${leftVar}<${rightVar}`) {
+                return { type: 'less_than', leftVar, rightVar };
+            }
+            if (exprText === `${leftVar}>${rightVar}`) {
+                return { type: 'greater_than', leftVar, rightVar };
+            }
+            if (exprText === `${leftVar}<=${rightVar}`) {
+                return { type: 'less_equal', leftVar, rightVar };
+            }
+            if (exprText === `${leftVar}>=${rightVar}`) {
+                return { type: 'greater_equal', leftVar, rightVar };
+            }
+            if (exprText === `${leftVar}!=${rightVar}`) {
+                return { type: 'not_equal', leftVar, rightVar };
+            }
+            // Also check for negated equality: not a = b
+            if (exprText === `not${leftVar}=${rightVar}`) {
+                return { type: 'not_equal', leftVar, rightVar };
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Checks if all values in the sets are numbers (or tuples containing single numbers).
+ * This is required for numeric comparison optimization to be applicable.
+ */
+function areAllNumericSets(sets) {
+    for (const set of sets) {
+        for (const tuple of set) {
+            if (tuple.length !== 1)
+                return false;
+            if (typeof tuple[0] !== 'number')
+                return false;
+        }
+    }
+    return true;
+}
+/**
+ * Extracts numbers from tuples that contain single numbers.
+ * Precondition: This should only be called after areAllNumericSets validation.
+ */
+function extractNumbers(tuples) {
+    return tuples.map(t => t[0]);
+}
+/**
+ * Generates optimized combinations for numeric comparison constraints.
+ * Instead of generating all combinations and filtering, generates only valid ones.
+ *
+ * @param varNames Variable names in order
+ * @param quantifiedSets The sets each variable ranges over
+ * @param pattern The detected numeric comparison pattern
+ * @returns Only the tuples that satisfy the constraint
+ */
+function generateOptimizedNumericCombinations(varNames, quantifiedSets, pattern) {
+    // Map variable names to their indices and value sets
+    const varIndexMap = new Map();
+    varNames.forEach((name, idx) => {
+        varIndexMap.set(name, idx);
+    });
+    const leftIdx = varIndexMap.get(pattern.leftVar);
+    const rightIdx = varIndexMap.get(pattern.rightVar);
+    if (leftIdx === undefined || rightIdx === undefined) {
+        // Pattern variables don't match our variable set - this shouldn't happen
+        // if detectNumericComparisonPattern is working correctly, but throw an error
+        // to prevent incorrect results (caller should have validated pattern matches variables)
+        throw new Error(`Internal error: Pattern variables ${pattern.leftVar}, ${pattern.rightVar} not found in variable list`);
+    }
+    // Extract numeric values
+    const leftNumbers = extractNumbers(quantifiedSets[leftIdx]);
+    const rightNumbers = extractNumbers(quantifiedSets[rightIdx]);
+    // For other variables, we still need all combinations
+    const otherVars = [];
+    const otherSets = [];
+    for (let i = 0; i < varNames.length; i++) {
+        if (i !== leftIdx && i !== rightIdx) {
+            otherVars.push(i);
+            otherSets.push(extractNumbers(quantifiedSets[i]));
+        }
+    }
+    const result = [];
+    // Generate combinations based on the comparison type
+    const generatePairs = (compareFunc) => {
+        for (const leftVal of leftNumbers) {
+            for (const rightVal of rightNumbers) {
+                if (compareFunc(leftVal, rightVal)) {
+                    // This pair satisfies the constraint
+                    // Now combine with all other variables if any
+                    if (otherVars.length === 0) {
+                        // Simple case: only two variables
+                        const tuple = new Array(varNames.length);
+                        tuple[leftIdx] = leftVal;
+                        tuple[rightIdx] = rightVal;
+                        result.push(tuple);
+                    }
+                    else {
+                        // Need to generate cartesian product with other variables
+                        const otherCombos = cartesianProduct(otherSets);
+                        for (const otherCombo of otherCombos) {
+                            const tuple = new Array(varNames.length);
+                            tuple[leftIdx] = leftVal;
+                            tuple[rightIdx] = rightVal;
+                            for (let i = 0; i < otherVars.length; i++) {
+                                tuple[otherVars[i]] = otherCombo[i];
+                            }
+                            result.push(tuple);
+                        }
+                    }
+                }
+            }
+        }
+    };
+    switch (pattern.type) {
+        case 'less_than':
+            generatePairs((a, b) => a < b);
+            break;
+        case 'greater_than':
+            generatePairs((a, b) => a > b);
+            break;
+        case 'less_equal':
+            generatePairs((a, b) => a <= b);
+            break;
+        case 'greater_equal':
+            generatePairs((a, b) => a >= b);
+            break;
+        case 'not_equal':
+            generatePairs((a, b) => a !== b);
+            break;
+        default:
+            // Unknown pattern, return empty (will fall back to standard approach)
+            return [];
+    }
+    return result;
+}
+/**
+ * Helper to generate cartesian product of number arrays
+ */
+function cartesianProduct(arrays) {
+    if (arrays.length === 0)
+        return [[]];
+    if (arrays.some(arr => arr.length === 0))
+        return [];
+    let result = [[]];
+    for (const arr of arrays) {
+        const newResult = [];
+        for (const existing of result) {
+            for (const value of arr) {
+                newResult.push([...existing, value]);
+            }
+        }
+        result = newResult;
+    }
+    return result;
+}
+
+
 /***/ }),
 
 /***/ "./src/errorListener.ts":

package/package.json

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