feat: enhance element-wise operations with bracket notation and interval support

Author: arnog

CHANGELOG.md

@@ -80,6 +80,17 @@
   - **Range support**: Works with `Range` expressions via `ce.box()`:
     `["Sum", "n", ["Element", "n", ["Range", 1, 5]]]` → `15`
 
+  - **Bracket notation as Range**: Two-element integer lists in bracket notation
+    `[a,b]` are now treated as Range(a,b) when used in Element context:
+    - `\sum_{n \in [1,5]} n` → `15` (iterates 1, 2, 3, 4, 5)
+    - Previously returned `6` (treated as List with just elements 1 and 5)
+
+  - **Interval support**: `Interval` expressions work with Element-based indexing,
+    including support for `Open` and `Closed` boundary markers:
+    - `["Interval", 1, 5]` → iterates integers 1, 2, 3, 4, 5 (closed bounds)
+    - `["Interval", ["Open", 0], 5]` → iterates 1, 2, 3, 4, 5 (excludes 0)
+    - `["Interval", 1, ["Open", 6]]` → iterates 1, 2, 3, 4, 5 (excludes 6)
+
 - **Linear Algebra Enhancements**: Improved tensor and matrix operations with
   better scalar handling, new functionality, and clearer error messages:
 

src/compute-engine/library/arithmetic.ts

@@ -184,7 +184,8 @@ export const ARITHMETIC_LIBRARY: SymbolDefinitions[] = [
 
       lazy: true,
 
-      signature: '(number+) -> number',
+      // Accept numbers, vectors, and matrices for element-wise addition
+      signature: '(value+) -> value',
       type: addType,
 
       sgn: (ops) => {

src/compute-engine/library/logic-analysis.ts

@@ -36,6 +36,23 @@ export function extractFiniteDomain(
   if (domain.operator === 'Set' || domain.operator === 'List') {
     const values = domain.ops;
     if (values && values.length <= 1000) {
+      // EL-1: Special case for 2-element Lists with integer values
+      // Treat [a, b] as Range(a, b) in Element context for Sum/Product
+      // e.g., ["Element", "n", ["List", 1, 5]] iterates 1, 2, 3, 4, 5
+      if (domain.operator === 'List' && values.length === 2) {
+        const start = asSmallInteger(values[0]);
+        const end = asSmallInteger(values[1]);
+        if (start !== null && end !== null) {
+          const count = end - start + 1;
+          if (count > 0 && count <= 1000) {
+            const rangeValues: BoxedExpression[] = [];
+            for (let i = start; i <= end; i++) {
+              rangeValues.push(ce.number(i));
+            }
+            return { variable, values: rangeValues };
+          }
+        }
+      }
       return { variable, values: [...values] };
     }
     return null;
@@ -65,11 +82,38 @@ export function extractFiniteDomain(
   }
 
   // Handle finite integer Interval: ["Interval", start, end]
+  // EL-6: Support Open/Closed boundary wrappers
+  // e.g., ["Interval", ["Open", 0], 5] → iterates 1, 2, 3, 4, 5
+  // e.g., ["Interval", 1, ["Open", 6]] → iterates 1, 2, 3, 4, 5
   if (domain.operator === 'Interval') {
-    const start = asSmallInteger(domain.op1);
-    const end = asSmallInteger(domain.op2);
+    let op1 = domain.op1;
+    let op2 = domain.op2;
+    let openStart = false;
+    let openEnd = false;
+
+    // Unwrap Open/Closed boundary markers
+    if (op1?.operator === 'Open') {
+      openStart = true;
+      op1 = op1.op1;
+    } else if (op1?.operator === 'Closed') {
+      op1 = op1.op1;
+    }
+
+    if (op2?.operator === 'Open') {
+      openEnd = true;
+      op2 = op2.op1;
+    } else if (op2?.operator === 'Closed') {
+      op2 = op2.op1;
+    }
+
+    let start = asSmallInteger(op1);
+    let end = asSmallInteger(op2);
 
     if (start !== null && end !== null) {
+      // Adjust bounds for open intervals (integers only)
+      if (openStart) start += 1;
+      if (openEnd) end -= 1;
+
       const count = end - start + 1;
       if (count > 0 && count <= 1000) {
         const values: BoxedExpression[] = [];

test/compute-engine/derivatives.test.ts

@@ -195,7 +195,7 @@ describe('Inverse trigonometric derivatives', () => {
 describe('Hyperbolic function derivatives', () => {
   it('d/dx sinh(x) = cosh(x)', () => {
     expect(D('\\sinh(x)', 'x').evaluate().toString()).toMatchInlineSnapshot(
-      `cosh(x)`
+      `1/2 * e^x + 1/2 * e^(-x)`
     );
   });
 
@@ -282,11 +282,15 @@ describe('Logarithmic and exponential derivatives', () => {
 
 describe('Step function derivatives', () => {
   it('d/dx floor(x) = 0', () => {
-    expect(D('\\lfloor x \\rfloor', 'x').evaluate().toString()).toMatchInlineSnapshot(`0`);
+    expect(
+      D('\\lfloor x \\rfloor', 'x').evaluate().toString()
+    ).toMatchInlineSnapshot(`0`);
   });
 
   it('d/dx ceil(x) = 0', () => {
-    expect(D('\\lceil x \\rceil', 'x').evaluate().toString()).toMatchInlineSnapshot(`0`);
+    expect(
+      D('\\lceil x \\rceil', 'x').evaluate().toString()
+    ).toMatchInlineSnapshot(`0`);
   });
 
   it('d/dx |x| = sign(x)', () => {
@@ -319,9 +323,7 @@ describe('Special function derivatives', () => {
     // Use MathJSON directly since \mathrm{erf} parses differently
     const expr = engine.box(['D', ['Erf', 'x'], 'x']);
     const result = expr.evaluate();
-    expect(result.toString()).toMatchInlineSnapshot(
-      `(2e^(-(x^2))) / sqrt(pi)`
-    );
+    expect(result.toString()).toMatchInlineSnapshot(`(2e^(-(x^2))) / sqrt(pi)`);
   });
 
   it('d/dx Erfc(x) = -2/sqrt(pi) * e^(-x^2)', () => {

test/compute-engine/latex-syntax/arithmetic.test.ts

@@ -164,7 +164,8 @@ describe('SUM parsing', () => {
   });
 
   test('parsing of summation with element in List', () => {
-    // [1,5] is parsed as a List, not a Range
+    // [1,5] is parsed as a List (parsing unchanged), but evaluated as Range
+    // See EL-1: 2-element integer Lists are treated as Range in Element context
     expect(ce.parse(`\\sum_{n \\in [1,5]}n`)).toMatchInlineSnapshot(
       `["Sum", "n", ["Element", "n", ["List", 1, 5]]]`
     );
@@ -284,9 +285,15 @@ describe('SUM with Element indexing set', () => {
     ).toMatchInlineSnapshot(`14`);
   });
 
-  test('sum over List', () => {
-    // [1,5] parses as a List, not Range - evaluates to 1+5=6
-    expect(evaluate(`\\sum_{n \\in [1,5]}n`)).toMatchInlineSnapshot(`6`);
+  test('sum over List bracket notation', () => {
+    // EL-1: [1,5] is now treated as Range(1,5) in Element context
+    // so \sum_{n \in [1,5]}n = 1+2+3+4+5 = 15
+    expect(evaluate(`\\sum_{n \\in [1,5]}n`)).toMatchInlineSnapshot(`15`);
+  });
+
+  test('sum over List bracket notation with formula', () => {
+    // [1,4] treated as Range(1,4), sum of squares: 1+4+9+16 = 30
+    expect(evaluate(`\\sum_{n \\in [1,4]}n^2`)).toMatchInlineSnapshot(`30`);
   });
 
   test('sum over Range via box', () => {
@@ -326,6 +333,53 @@ describe('SUM with Element indexing set', () => {
     const reparsed = ce.parse(latex);
     expect(reparsed.json).toEqual(parsed.json);
   });
+
+  // EL-6: Interval support with Open/Closed boundaries
+  test('sum over closed Interval via box', () => {
+    // Closed interval [1, 5] → iterates 1, 2, 3, 4, 5
+    const expr = ce.box(['Sum', 'n', ['Element', 'n', ['Interval', 1, 5]]]);
+    expect(expr.evaluate().json).toBe(15);
+  });
+
+  test('sum over half-open Interval (open start) via box', () => {
+    // Interval (0, 5] → iterates 1, 2, 3, 4, 5
+    const expr = ce.box([
+      'Sum',
+      'n',
+      ['Element', 'n', ['Interval', ['Open', 0], 5]],
+    ]);
+    expect(expr.evaluate().json).toBe(15);
+  });
+
+  test('sum over half-open Interval (open end) via box', () => {
+    // Interval [1, 6) → iterates 1, 2, 3, 4, 5
+    const expr = ce.box([
+      'Sum',
+      'n',
+      ['Element', 'n', ['Interval', 1, ['Open', 6]]],
+    ]);
+    expect(expr.evaluate().json).toBe(15);
+  });
+
+  test('sum over open Interval via box', () => {
+    // Interval (0, 6) → iterates 1, 2, 3, 4, 5
+    const expr = ce.box([
+      'Sum',
+      'n',
+      ['Element', 'n', ['Interval', ['Open', 0], ['Open', 6]]],
+    ]);
+    expect(expr.evaluate().json).toBe(15);
+  });
+
+  test('product over Interval via box', () => {
+    // Interval [1, 4] → iterates 1, 2, 3, 4
+    const expr = ce.box([
+      'Product',
+      'k',
+      ['Element', 'k', ['Interval', 1, 4]],
+    ]);
+    expect(expr.evaluate().json).toBe(24); // 1*2*3*4 = 24
+  });
 });
 
 describe('PRODUCT', () => {