Update solver.py

solver.py

@@ -139,16 +139,18 @@ def process_expression(expr_str):
     except Exception as e:
         raise Exception(f"Error processing expression: {str(e)}")
 
+def to_latex(expr):
+    """Converts a SymPy expression into LaTeX format."""
+    return f"$$ {sp.latex(expr)} $$"
+
 def solve_equation(equation_str):
-    """Solves an equation and returns a detailed step-by-step solution."""
+    """Solves an equation and returns a detailed LaTeX-formatted step-by-step solution."""
     try:
         if '=' not in equation_str:
             return process_expression(equation_str)
 
-        # Split into left and right-hand sides
         left_side, right_side = [side.strip() for side in equation_str.split('=')]
         
-        # Parse expressions
         transformations = standard_transformations + (implicit_multiplication_application,)
         left_expr = sp.parse_expr(left_side, transformations=transformations)
         right_expr = sp.parse_expr(right_side, transformations=transformations)
@@ -158,24 +160,21 @@ def solve_equation(equation_str):
         solutions = solve(equation, x)
 
         steps = []
-        steps.append(f"**Step 1:** Original equation: \n{format_expression(left_expr)} = {format_expression(right_expr)}")
-        steps.append(f"**Step 2:** Move all terms to one side: \n{format_expression(equation)} = 0")
+        steps.append(f"**Step 1:** Original equation: \n{to_latex(left_expr)} = {to_latex(right_expr)}")
+        steps.append(f"**Step 2:** Move all terms to one side: \n{to_latex(equation)} = 0")
 
-        # Factoring if possible
         factored = sp.factor(equation)
         if factored != equation:
-            steps.append(f"**Step 3:** Factorizing the equation: \n{format_expression(factored)} = 0")
+            steps.append(f"**Step 3:** Factorizing the equation: \n{to_latex(factored)} = 0")
 
-        # Solve for x
         steps.append(f"**Step 4:** Solving for x:")
         for sol in solutions:
-            steps.append(f"   x = {format_expression(sol)}")
+            steps.append(f"   x = {to_latex(sol)}")
 
-        # Verification
         steps.append("**Step 5:** Verification:")
         for sol in solutions:
             verification = equation.subs(x, sol)
-            steps.append(f"   When x = {format_expression(sol)}, the equation evaluates to {format_expression(verification)}")
+            steps.append(f"   When x = {to_latex(sol)}, the equation evaluates to {to_latex(verification)}")
 
         return "\n".join(steps)
 
@@ -183,24 +182,21 @@ def solve_equation(equation_str):
         return f"Error: {str(e)}"
 
 def integrate_expression(expression_str):
-    """Computes the integral of a given expression and provides detailed steps."""
+    """Computes the integral of a given expression and provides detailed LaTeX-formatted steps."""
     try:
         x = Symbol('x')
         expr = sp.parse_expr(expression_str, transformations=standard_transformations + (implicit_multiplication_application,))
 
         steps = []
-        steps.append(f"**Step 1:** Original integral: \n∫ {format_expression(expr)} dx")
+        steps.append(f"**Step 1:** Original integral: \n$$ \\int {sp.latex(expr)} \\,dx $$")
 
-        # Check if substitution can simplify
         if '^' in expression_str:
-            steps.append("**Step 2:** Substituting variables if needed")
-            # Example: If we have x^n, we might use substitution
-            # More cases can be handled as needed
+            steps.append("**Step 2:** Checking if substitution is needed.")
 
         result = integrate(expr, x)
         steps.append(f"**Step 3:** Applying integration formula(s):")
-        steps.append(f"   ∫ f(x) dx = F(x) + C")
-        steps.append(f"**Step 4:** Solution: \n{format_expression(result)} + C")
+        steps.append(f"$$ \\int f(x) \\,dx = F(x) + C $$")
+        steps.append(f"**Step 4:** Solution: \n$$ {sp.latex(result)} + C $$")
 
         return "\n".join(steps)
 
@@ -208,22 +204,36 @@ def integrate_expression(expression_str):
         return f"Error: {str(e)}"
 
 def laplace_transform_expression(expression_str):
-    """Computes the Laplace transform of a given expression with detailed steps."""
+    """Computes the Laplace transform of a given expression with LaTeX-formatted steps."""
     try:
         t, s = sp.symbols('t s')
         expr = sp.parse_expr(expression_str, transformations=standard_transformations + (implicit_multiplication_application,))
 
         steps = []
-        steps.append(f"**Step 1:** Original function: \nL[{format_expression(expr)}](t)")
+        steps.append(f"**Step 1:** Original function: \n$$ \\mathcal{L}\\{{ {sp.latex(expr)} \\}}(t) $$")
 
-        # Compute Laplace transform
         L_transform = laplace_transform(expr, t, s, noconds=True)
 
         steps.append(f"**Step 2:** Applying Laplace Transform:")
-        steps.append("   L[f(t)] = ∫ e^(-st) f(t) dt, from 0 to ∞")
-        steps.append(f"**Step 3:** Solution: \n{format_expression(L_transform)}")
+        steps.append("$$ \\mathcal{L}\\{ f(t) \\} = \\int_{0}^{\\infty} e^{-st} f(t) \\,dt $$")
+        steps.append(f"**Step 3:** Solution: \n$$ {sp.latex(L_transform)} $$")
 
         return "\n".join(steps)
 
     except Exception as e:
         return f"Error: {str(e)}"
+
+def process_input(equation):
+    """Determine whether the input is an equation, an integral, or a Laplace transform."""
+    try:
+        if "laplace" in equation.lower():
+            solution = laplace_transform_expression(equation)
+        elif "integrate" in equation.lower():
+            solution = integrate_expression(equation)
+        else:
+            solution = solve_equation(equation)
+        
+        return solution
+
+    except Exception as e:
+        return f"Error processing input: {str(e)}"