fix: fixed #258

Author: arnog

CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ### Bug Fixes
 
+- **([#258](https://github.com/cortex-js/compute-engine/issues/258))
+  Pattern Matching**: Fixed `BoxedExpression.match()` returning `null` when
+  matching a `Rational` pattern against expressions like `['Rational', 'x', 2]`.
+  The issue occurred because symbolic rationals with numeric denominators are
+  canonicalized to `Multiply` expressions (e.g., `x * 1/2`), which didn't match
+  `Divide` or `Rational` patterns. The pattern matching now correctly recognizes
+  these forms.
+
 - **([#264](https://github.com/cortex-js/compute-engine/issues/264))
   Serialization**: Fixed LaTeX serialization of quantified expressions
   (`ForAll`, `Exists`, `ExistsUnique`, `NotForAll`, `NotExists`). Previously,

src/compute-engine/boxed-expression/match.ts

@@ -131,6 +131,59 @@ function matchOnce(
 
     const operator = pattern.operator;
 
+    // Special case: Match a BoxedNumber rational against a Divide pattern
+    // This allows patterns like ['Divide', '_num', '_den'] to match rationals like 3/2
+    if (
+      operator === 'Divide' &&
+      expr.numericValue !== null &&
+      !expr.denominator.is(1)
+    ) {
+      // Create a synthetic Divide expression to match against
+      const divideExpr = ce.function(
+        'Divide',
+        [expr.numerator, expr.denominator],
+        { canonical: false, structural: true }
+      );
+      return matchArguments(divideExpr, pattern.ops, substitution, options);
+    }
+
+    // Special case: Match Multiply(Rational(1, n), x) against a Divide pattern
+    // This handles cases like x/2 which is canonicalized as x * (1/2)
+    if (operator === 'Divide' && expr.operator === 'Multiply') {
+      const ops = expr.ops!;
+      for (let i = 0; i < ops.length; i++) {
+        const op = ops[i];
+
+        // Check if op is a rational number with numerator 1 (i.e., 1/n form)
+        if (
+          op.numericValue !== null &&
+          op.numerator.is(1) &&
+          !op.denominator.is(1)
+        ) {
+          // Collect all other operands
+          const others = ops.filter((_, j) => j !== i);
+          const numerator =
+            others.length === 1
+              ? others[0]
+              : ce.function('Multiply', others, { canonical: false });
+
+          // Create a synthetic Divide expression to match against
+          const divideExpr = ce.function(
+            'Divide',
+            [numerator, op.denominator],
+            { canonical: false, structural: true }
+          );
+          const result = matchArguments(
+            divideExpr,
+            pattern.ops,
+            substitution,
+            options
+          );
+          if (result !== null) return result;
+        }
+      }
+    }
+
     if (operator.startsWith('_')) {
       //
       // 1. The pattern operator is a wildcard

test/compute-engine/patterns.test.ts

@@ -995,6 +995,78 @@ describe('NON EXACT WILDCARDS', () => {
   });
 });
 
+// GitHub Issue #258: BoxedExpression.match() with a Rational pattern
+describe('RATIONAL PATTERN MATCHING', () => {
+  it('should match Rational(3, 2) with Rational pattern', () => {
+    // Rational with two integers becomes a BoxedNumber
+    const result = match(['Rational', '_num', '_den'], ['Rational', 3, 2]);
+    expect(result).toMatchInlineSnapshot(`
+      {
+        _den: 2,
+        _num: 3,
+      }
+    `);
+  });
+
+  it('should match Rational(x, 2) with Rational pattern', () => {
+    // Rational with symbolic numerator is canonicalized as Multiply(x, Rational(1, 2))
+    const result = match(['Rational', '_num', '_den'], ['Rational', 'x', 2]);
+    expect(result).toMatchInlineSnapshot(`
+      {
+        _den: 2,
+        _num: x,
+      }
+    `);
+  });
+
+  it('should match Rational(x, 9) with Rational pattern', () => {
+    // Rational(x, Power(3, 2)) is canonicalized as Multiply(x, Rational(1, 9))
+    const result = match(
+      ['Rational', '_num', '_den'],
+      ['Rational', 'x', ['Power', 3, 2]]
+    );
+    expect(result).toMatchInlineSnapshot(`
+      {
+        _den: 9,
+        _num: x,
+      }
+    `);
+  });
+
+  it('should match Rational(3, y) with Rational pattern', () => {
+    // Rational with symbolic denominator becomes Divide(3, y)
+    const result = match(['Rational', '_num', '_den'], ['Rational', 3, 'y']);
+    expect(result).toMatchInlineSnapshot(`
+      {
+        _den: y,
+        _num: 3,
+      }
+    `);
+  });
+
+  it('should match Rational(x, y) with Rational pattern', () => {
+    // Rational with two symbols becomes Divide(x, y)
+    const result = match(['Rational', '_num', '_den'], ['Rational', 'x', 'y']);
+    expect(result).toMatchInlineSnapshot(`
+      {
+        _den: y,
+        _num: x,
+      }
+    `);
+  });
+
+  it('should match Divide pattern against Multiply with reciprocal', () => {
+    // x/2 is canonicalized as Multiply(Rational(1, 2), x)
+    const result = match(['Divide', '_num', '_den'], ['Rational', 'x', 2]);
+    expect(result).toMatchInlineSnapshot(`
+      {
+        _den: 2,
+        _num: x,
+      }
+    `);
+  });
+});
+
 describe('PATTERN VALIDATION', () => {
   // Test validatePattern directly with non-canonical patterns
   // (canonical forms may reorder operands for commutative operators)