| """ |
| Symbolic Mathematics Engine — SymPy-based exact computation. |
| |
| Extracted from main.py L585-L643. Provides differentiation, integration, |
| equation solving, simplification, and matrix operations using SymPy. |
| All methods are stateless (static) and safe for concurrent use. |
| """ |
|
|
| import re |
| import ast |
| import logging |
| from typing import Dict, Any, Optional |
|
|
| logger = logging.getLogger("math_assistant.symbolic") |
|
|
|
|
| class SymbolicMathEngine: |
| """SymPy-powered symbolic math solver for exact computation.""" |
|
|
| @staticmethod |
| def differentiate(expression: str, variable: str = "x") -> Optional[str]: |
| """Compute the derivative of an expression with respect to a variable.""" |
| try: |
| import sympy as sp |
| var = sp.Symbol(variable) |
| expr = sp.sympify(re.sub(r'\^', '**', expression.strip())) |
| return f"d/d{variable}[{expression}] = {sp.simplify(sp.diff(expr, var))}" |
| except Exception: |
| return None |
|
|
| @staticmethod |
| def integrate(expression: str, variable: str = "x") -> Optional[str]: |
| """Compute the indefinite integral of an expression.""" |
| try: |
| import sympy as sp |
| var = sp.Symbol(variable) |
| expr = sp.sympify(re.sub(r'\^', '**', expression.strip())) |
| return f"integral({expression}) d{variable} = {sp.integrate(expr, var)} + C" |
| except Exception: |
| return None |
|
|
| @staticmethod |
| def solve_equation(equation: str, variable: str = "x") -> Optional[str]: |
| """Solve an equation for a given variable.""" |
| try: |
| import sympy as sp |
| var = sp.Symbol(variable) |
| eq_str = re.sub(r'\^', '**', equation.strip()) |
| if "=" in eq_str: |
| lhs, rhs = eq_str.split("=", 1) |
| eq = sp.Eq(sp.sympify(lhs), sp.sympify(rhs)) |
| else: |
| eq = sp.sympify(eq_str) |
| return f"Solutions for {variable}: {sp.solve(eq, var)}" |
| except Exception: |
| return None |
|
|
| @staticmethod |
| def try_solve(expression: str) -> Optional[str]: |
| """Attempt to simplify or solve a general expression.""" |
| try: |
| import sympy as sp |
| x, y, z, t = sp.symbols('x y z t') |
| expr_str = re.sub(r'\^', '**', expression.strip()) |
| result = sp.simplify(sp.sympify(expr_str, locals={ |
| 'x': x, 'y': y, 'z': z, 't': t, |
| 'sin': sp.sin, 'cos': sp.cos, 'exp': sp.exp, |
| 'log': sp.log, 'sqrt': sp.sqrt, 'pi': sp.pi})) |
| return str(result) |
| except Exception: |
| return None |
|
|
| @staticmethod |
| def matrix_operations(matrix_str: str) -> Optional[Dict[str, Any]]: |
| """Compute determinant, rank, eigenvalues, and trace of a matrix.""" |
| try: |
| import sympy as sp |
| M = sp.Matrix(ast.literal_eval(matrix_str)) |
| return { |
| "determinant": str(M.det()), |
| "rank": M.rank(), |
| "eigenvalues": str(M.eigenvals()), |
| "trace": str(M.trace()), |
| } |
| except Exception: |
| return None |
|
|
