feat: implement trigonometric equation solving in solve() method with corresponding tests

Author: arnog

CHANGELOG.md

@@ -50,6 +50,16 @@
   - `1 + cot²(x)` → `csc²(x)` and `csc²(x) - 1` → `cot²(x)`
   - `a·sin²(x) + a·cos²(x)` → `a` (with coefficient)
 
+- **Trigonometric Equation Solving**: The `solve()` method now handles basic
+  trigonometric equations:
+  - `sin(x) = a` → `x = arcsin(a)` and `x = π - arcsin(a)` (two solutions)
+  - `cos(x) = a` → `x = arccos(a)` and `x = -arccos(a)` (two solutions)
+  - `tan(x) = a` → `x = arctan(a)` (one solution per period)
+  - `cot(x) = a` → `x = arccot(a)`
+  - Supports coefficient form: `a·sin(x) + b = 0`
+  - Domain validation: returns no solutions when |a| > 1 for sin/cos
+  - Automatic deduplication of equivalent solutions (e.g., `cos(x) = 1` → single solution `0`)
+
 - **([#133](https://github.com/cortex-js/compute-engine/issues/133)) Element-based
   Indexing Sets for Sum/Product**: Added support for `\in` notation in summation
   and product subscripts:

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

@@ -332,6 +332,187 @@ export const UNIVARIATE_ROOTS: Rule[] = [
     useVariations: true,
     condition: filter,
   },
+
+  //
+  // Trigonometric equations
+  //
+  // Note: These return principal values only. For general solutions,
+  // add 2πn for sin/cos or πn for tan (where n ∈ ℤ).
+  //
+
+  // a·sin(x) + b = 0  =>  x = arcsin(-b/a)
+  // Valid when -1 ≤ -b/a ≤ 1
+  {
+    match: ['Add', ['Multiply', '__a', ['Sin', '_x']], '__b'],
+    replace: ['Arcsin', ['Divide', ['Negate', '__b'], '__a']],
+    useVariations: true,
+    condition: (sub) => {
+      if (!filter(sub)) return false;
+      // Check that -b/a is in [-1, 1] for real solutions
+      const a = sub.__a;
+      const b = sub.__b;
+      if (!a || a.is(0)) return false;
+      const ratio = b.div(a).neg();
+      const val = ratio.numericValue;
+      if (val === null) return true; // Allow symbolic ratios
+      if (typeof val === 'number') return Math.abs(val) <= 1;
+      return true;
+    },
+  },
+
+  // Second solution for sin: x = π - arcsin(-b/a)
+  {
+    match: ['Add', ['Multiply', '__a', ['Sin', '_x']], '__b'],
+    replace: ['Subtract', 'Pi', ['Arcsin', ['Divide', ['Negate', '__b'], '__a']]],
+    useVariations: true,
+    condition: (sub) => {
+      if (!filter(sub)) return false;
+      const a = sub.__a;
+      const b = sub.__b;
+      if (!a || a.is(0)) return false;
+      const ratio = b.div(a).neg();
+      const val = ratio.numericValue;
+      if (val === null) return true;
+      if (typeof val === 'number') return Math.abs(val) <= 1;
+      return true;
+    },
+  },
+
+  // sin(x) + b = 0  =>  x = arcsin(-b)  (when a = 1)
+  {
+    match: ['Add', ['Sin', '_x'], '__b'],
+    replace: ['Arcsin', ['Negate', '__b']],
+    useVariations: true,
+    condition: (sub) => {
+      if (!filter(sub)) return false;
+      const b = sub.__b;
+      const val = b.numericValue;
+      if (val === null) return true;
+      if (typeof val === 'number') return Math.abs(val) <= 1;
+      return true;
+    },
+  },
+
+  // Second solution for sin(x) + b = 0: x = π - arcsin(-b)
+  {
+    match: ['Add', ['Sin', '_x'], '__b'],
+    replace: ['Subtract', 'Pi', ['Arcsin', ['Negate', '__b']]],
+    useVariations: true,
+    condition: (sub) => {
+      if (!filter(sub)) return false;
+      const b = sub.__b;
+      const val = b.numericValue;
+      if (val === null) return true;
+      if (typeof val === 'number') return Math.abs(val) <= 1;
+      return true;
+    },
+  },
+
+  // a·cos(x) + b = 0  =>  x = arccos(-b/a)
+  // Valid when -1 ≤ -b/a ≤ 1
+  {
+    match: ['Add', ['Multiply', '__a', ['Cos', '_x']], '__b'],
+    replace: ['Arccos', ['Divide', ['Negate', '__b'], '__a']],
+    useVariations: true,
+    condition: (sub) => {
+      if (!filter(sub)) return false;
+      const a = sub.__a;
+      const b = sub.__b;
+      if (!a || a.is(0)) return false;
+      const ratio = b.div(a).neg();
+      const val = ratio.numericValue;
+      if (val === null) return true;
+      if (typeof val === 'number') return Math.abs(val) <= 1;
+      return true;
+    },
+  },
+
+  // Second solution for cos: x = -arccos(-b/a)  (since cos(-x) = cos(x))
+  {
+    match: ['Add', ['Multiply', '__a', ['Cos', '_x']], '__b'],
+    replace: ['Negate', ['Arccos', ['Divide', ['Negate', '__b'], '__a']]],
+    useVariations: true,
+    condition: (sub) => {
+      if (!filter(sub)) return false;
+      const a = sub.__a;
+      const b = sub.__b;
+      if (!a || a.is(0)) return false;
+      const ratio = b.div(a).neg();
+      const val = ratio.numericValue;
+      if (val === null) return true;
+      if (typeof val === 'number') return Math.abs(val) <= 1;
+      return true;
+    },
+  },
+
+  // cos(x) + b = 0  =>  x = arccos(-b)  (when a = 1)
+  {
+    match: ['Add', ['Cos', '_x'], '__b'],
+    replace: ['Arccos', ['Negate', '__b']],
+    useVariations: true,
+    condition: (sub) => {
+      if (!filter(sub)) return false;
+      const b = sub.__b;
+      const val = b.numericValue;
+      if (val === null) return true;
+      if (typeof val === 'number') return Math.abs(val) <= 1;
+      return true;
+    },
+  },
+
+  // Second solution for cos(x) + b = 0: x = -arccos(-b)
+  {
+    match: ['Add', ['Cos', '_x'], '__b'],
+    replace: ['Negate', ['Arccos', ['Negate', '__b']]],
+    useVariations: true,
+    condition: (sub) => {
+      if (!filter(sub)) return false;
+      const b = sub.__b;
+      const val = b.numericValue;
+      if (val === null) return true;
+      if (typeof val === 'number') return Math.abs(val) <= 1;
+      return true;
+    },
+  },
+
+  // a·tan(x) + b = 0  =>  x = arctan(-b/a)
+  // Tan has no domain restriction for the ratio
+  {
+    match: ['Add', ['Multiply', '__a', ['Tan', '_x']], '__b'],
+    replace: ['Arctan', ['Divide', ['Negate', '__b'], '__a']],
+    useVariations: true,
+    condition: (sub) => {
+      if (!filter(sub)) return false;
+      return !sub.__a.is(0);
+    },
+  },
+
+  // tan(x) + b = 0  =>  x = arctan(-b)  (when a = 1)
+  {
+    match: ['Add', ['Tan', '_x'], '__b'],
+    replace: ['Arctan', ['Negate', '__b']],
+    useVariations: true,
+    condition: filter,
+  },
+
+  // a·cot(x) + b = 0  =>  x = arccot(-b/a)
+  {
+    match: ['Add', ['Multiply', '__a', ['Cot', '_x']], '__b'],
+    replace: ['Arccot', ['Divide', ['Negate', '__b'], '__a']],
+    useVariations: true,
+    condition: (sub) => {
+      if (!filter(sub)) return false;
+      return !sub.__a.is(0);
+    },
+  },
+
+  // cot(x) + b = 0  =>  x = arccot(-b)
+  {
+    match: ['Add', ['Cot', '_x'], '__b'],
+    replace: ['Arccot', ['Negate', '__b']],
+    useVariations: true,
+    condition: filter,
+  },
 ];
 
 /**
@@ -626,7 +807,7 @@ function validateRoots(
   x: string,
   roots: ReadonlyArray<BoxedExpression>
 ): BoxedExpression[] {
-  return roots.filter((root) => {
+  const validRoots = roots.filter((root) => {
     // Evaluate the expression at the root
     const value = expr.subs({ [x]: root }).canonical.evaluate();
     if (value === null) return false;
@@ -638,4 +819,15 @@ function validateRoots(
     // The former accounts for tolerance, the latter does not
     return value.isEqual(0);
   });
+
+  // Deduplicate roots (e.g., arccos(1) and -arccos(1) both equal 0)
+  const uniqueRoots: BoxedExpression[] = [];
+  for (const root of validRoots) {
+    const isDuplicate = uniqueRoots.some(
+      (existing) => existing.isSame(root) || existing.isEqual(root)
+    );
+    if (!isDuplicate) uniqueRoots.push(root);
+  }
+
+  return uniqueRoots;
 }

test/compute-engine/solve.test.ts

@@ -319,3 +319,96 @@ describe('SOLVING SQRT AND LN EQUATIONS', () => {
     expect(result?.[0]).toMatch(/^7\.389/);
   });
 });
+
+// Tests for trigonometric equations
+describe('SOLVING TRIGONOMETRIC EQUATIONS', () => {
+  test('should solve sin(x) = 0', () => {
+    const e = expr('\\sin(x) = 0');
+    const result = e.solve('x')?.map((x) => x.json);
+    // Principal solutions: 0 and π
+    expect(result).toMatchInlineSnapshot(`
+      [
+        0,
+        Pi,
+      ]
+    `);
+  });
+
+  test('should solve sin(x) = 1/2', () => {
+    const e = expr('\\sin(x) = 1/2');
+    const result = e.solve('x')?.map((x) => x.N().json);
+    // Principal solutions: π/6 ≈ 0.5236 and 5π/6 ≈ 2.618
+    expect(result?.length).toBe(2);
+    expect((result?.[0] as { num: string }).num).toMatch(/^0\.523/);
+  });
+
+  test('should solve cos(x) = 0', () => {
+    const e = expr('\\cos(x) = 0');
+    const result = e.solve('x')?.map((x) => x.N().json);
+    // Principal solutions: π/2 ≈ 1.571 and -π/2 ≈ -1.571
+    expect(result?.length).toBe(2);
+    expect((result?.[0] as { num: string }).num).toMatch(/^1\.570/);
+  });
+
+  test('should solve cos(x) = 1', () => {
+    const e = expr('\\cos(x) = 1');
+    const result = e.solve('x')?.map((x) => x.json);
+    // Principal solution: 0 (deduplicated from arccos(1) and -arccos(1))
+    expect(result).toMatchInlineSnapshot(`
+      [
+        0,
+      ]
+    `);
+  });
+
+  test('should solve tan(x) = 1', () => {
+    const e = expr('\\tan(x) = 1');
+    const result = e.solve('x')?.map((x) => x.N().json);
+    // Principal solution: π/4 ≈ 0.7854
+    expect(result?.length).toBe(1);
+    expect((result?.[0] as { num: string }).num).toMatch(/^0\.785/);
+  });
+
+  test('should solve tan(x) = 0', () => {
+    const e = expr('\\tan(x) = 0');
+    const result = e.solve('x')?.map((x) => x.json);
+    // Principal solution: 0
+    expect(result).toMatchInlineSnapshot(`
+      [
+        0,
+      ]
+    `);
+  });
+
+  test('should solve 2sin(x) - 1 = 0', () => {
+    const e = expr('2\\sin(x) - 1 = 0');
+    const result = e.solve('x')?.map((x) => x.N().json);
+    // Same as sin(x) = 1/2
+    expect(result?.length).toBe(2);
+    expect((result?.[0] as { num: string }).num).toMatch(/^0\.523/);
+  });
+
+  test('should solve 3cos(x) + 3 = 0', () => {
+    const e = expr('3\\cos(x) + 3 = 0');
+    const result = e.solve('x')?.map((x) => x.N().json);
+    // cos(x) = -1, solution: π ≈ 3.1416 and -π
+    expect(result?.length).toBe(2);
+    // Check one is π and one is -π
+    const values = result?.map((r) => parseFloat((r as { num: string }).num));
+    expect(values?.some((v) => Math.abs(v - Math.PI) < 0.001)).toBe(true);
+  });
+
+  test('should return empty for sin(x) = 2 (no real solution)', () => {
+    const e = expr('\\sin(x) = 2');
+    const result = e.solve('x');
+    // sin(x) can only be in [-1, 1]
+    expect(result).toEqual([]);
+  });
+
+  test('should return empty for cos(x) = -2 (no real solution)', () => {
+    const e = expr('\\cos(x) = -2');
+    const result = e.solve('x');
+    // cos(x) can only be in [-1, 1]
+    expect(result).toEqual([]);
+  });
+});