Update solver.py

solver.py

@@ -98,7 +98,6 @@ def process_expression(expr_str):
     try:
         processed_expr = preprocess_equation(expr_str)
         x = Symbol('x')
-        
 
         if expr_str.startswith('∫'):  # Integration
             expr_to_integrate = processed_expr[1:].strip()
@@ -139,101 +138,84 @@ 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 LaTeX-formatted step-by-step solution."""
+    """Solve the given equation and return the solution."""
     try:
         if '=' not in equation_str:
             return process_expression(equation_str)
 
+        # Preprocess equation
+        equation_str = preprocess_equation(equation_str)
+
+        # Split equation into left and right parts
         left_side, right_side = [side.strip() for side in equation_str.split('=')]
-        
+
+        # Parse both sides with implicit multiplication
         transformations = standard_transformations + (implicit_multiplication_application,)
-        left_expr = sp.parse_expr(left_side, transformations=transformations)
-        right_expr = sp.parse_expr(right_side, transformations=transformations)
+        left_expr = parse_expr(left_side, transformations=transformations)
+        right_expr = parse_expr(right_side, transformations=transformations)
         equation = left_expr - right_expr
 
+        # Solve the equation
         x = Symbol('x')
-        solutions = solve(equation, x)
-
-        steps = []
-        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")
-
-        factored = sp.factor(equation)
-        if factored != equation:
-            steps.append(f"**Step 3:** Factorizing the equation: \n{to_latex(factored)} = 0")
+        solution = solve(equation, x)
 
-        steps.append(f"**Step 4:** Solving for x:")
-        for sol in solutions:
-            steps.append(f"   x = {to_latex(sol)}")
-
-        steps.append("**Step 5:** Verification:")
-        for sol in solutions:
-            verification = equation.subs(x, sol)
-            steps.append(f"   When x = {to_latex(sol)}, the equation evaluates to {to_latex(verification)}")
-
-        return "\n".join(steps)
+        # Format solution
+        if len(solution) == 0:
+            return "No solution exists"
+        elif len(solution) == 1:
+            return f"x = {format_expression(solution[0])}"
+        else:
+            return "x = " + ", ".join([format_expression(sol) for sol in solution])
 
     except Exception as e:
-        return f"Error: {str(e)}"
+        raise Exception(f"Invalid equation format: {str(e)}")
 
-def integrate_expression(expression_str):
-    """Computes the integral of a given expression and provides detailed LaTeX-formatted steps."""
+def generate_steps(equation_str):
+    """Generate step-by-step solution for the equation or expression."""
+    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$$ \\int {sp.latex(expr)} \\,dx $$")
-
-        if '^' in expression_str:
-            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"$$ \\int f(x) \\,dx = F(x) + C $$")
-        steps.append(f"**Step 4:** Solution: \n$$ {sp.latex(result)} + C $$")
+        if '=' not in equation_str:
+            steps.append(f"1. Original expression: {equation_str}")
+            result = process_expression(equation_str)
+            steps.append(f"2. Result: {result}")
+            return steps
 
-        return "\n".join(steps)
+        # Preprocess equation
+        processed_eq = preprocess_equation(equation_str)
 
-    except Exception as e:
-        return f"Error: {str(e)}"
+        # Split equation into left and right parts
+        left_side, right_side = [side.strip() for side in processed_eq.split('=')]
 
-def laplace_transform_expression(expression_str):
-    """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,))
+        # Parse expressions with implicit multiplication
+        transformations = standard_transformations + (implicit_multiplication_application,)
+        left_expr = parse_expr(left_side, transformations=transformations)
+        right_expr = parse_expr(right_side, transformations=transformations)
 
-        steps = []
-        steps.append(f"**Step 1:** Original function: \n$$ \\mathcal{L}\\{{ {sp.latex(expr)} \\}}(t) $$")
+        # Step 1: Show original equation
+        steps.append(f"1. Original equation: {format_expression(left_expr)} = {format_expression(right_expr)}")
 
-        L_transform = laplace_transform(expr, t, s, noconds=True)
+        # Step 2: Move all terms to left side
+        equation = left_expr - right_expr
+        steps.append(f"2. Move all terms to left side: {format_expression(equation)} = 0")
 
-        steps.append(f"**Step 2:** Applying Laplace 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)} $$")
+        # Step 3: Factor if possible
+        factored = sp.factor(equation)
+        if factored != equation:
+            steps.append(f"3. Factor the equation: {format_expression(factored)} = 0")
 
-        return "\n".join(steps)
+        # Step 4: Solve
+        x = Symbol('x')
+        solution = solve(equation, x)
+        steps.append(f"4. Solve for x: x = {', '.join([format_expression(sol) for sol in solution])}")
 
-    except Exception as e:
-        return f"Error: {str(e)}"
+        # Step 5: Verify solutions
+        steps.append("5. Verify solutions:")
+        for sol in solution:
+            result = equation.subs(x, sol)
+            steps.append(f"   When x = {format_expression(sol)}, equation equals {format_expression(result)}")
 
-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
+        return steps
 
     except Exception as e:
-        return f"Error processing input: {str(e)}"
+        raise Exception(f"Error generating steps: {str(e)}")