refactor: reorganize algebra interfaces and remove unused quadratic solver

app.py

@@ -6,7 +6,7 @@ from maths.arithmetic.arithmetic_interface import (
 )
 from maths.algebra.algebra_interface import (
     solve_linear_equation_interface, evaluate_expression_interface,
-    solve_quadratic_interface, simplify_radical_interface, polynomial_interface # Assuming these
+    simplify_radical_interface, polynomial_interface # Assuming these
 )
 from maths.geometry.trigonometry_interface import (
     trig_interface, inverse_trig_interface, solve_trig_equations_interface, trig_identities_interface # Assuming these
@@ -33,6 +33,9 @@ from maths.differential_equations.differential_equations_interface import (
 from maths.operations_research.operations_research_interface import (
     branch_and_bound_interface, dual_simplex_interface, simplex_solver_interface
 )
+from maths.equations.equations_interface import (
+    equations_app, solve_quadratic_interface # equations_app is the tabbed interface, solve_quadratic_interface for direct use
+)
 
 # Categorize interfaces by topics
 
@@ -52,7 +55,7 @@ algebra_interfaces_list = [evaluate_expression_interface, simplify_radical_inter
 algebra_tab_names = ["Evaluate Expressions", "Radical Simplifier", "Polynomial Ops"]
 
 equations_interfaces_list = [
-    solve_linear_equation_interface, solve_quadratic_interface,
+    solve_linear_equation_interface, solve_quadratic_interface, # keep direct quadratic solver for single tab
     solve_trig_equations_interface
 ]
 equations_tab_names = [
@@ -102,7 +105,7 @@ operations_research_tab_names = ["Branch & Bound", "Dual Simplex", "Simplex Step
 arithmetic_tab = gr.TabbedInterface(arithmetic_interfaces_list, arithmetic_tab_names, title="Arithmetic")
 number_theory_tab = gr.TabbedInterface(number_theory_interfaces_list, number_theory_tab_names, title="Number Theory")
 algebra_tab = gr.TabbedInterface(algebra_interfaces_list, algebra_tab_names, title="Algebra")
-equations_tab = gr.TabbedInterface(equations_interfaces_list, equations_tab_names, title="Equations")
+equations_tab = equations_app  # Only include the composite equations_app in the equations tab to avoid duplicate Gradio blocks
 geometry_tab = gr.TabbedInterface(geometry_interfaces_list, geometry_tab_names, title="Geometry")
 calculus_tab = gr.TabbedInterface(calculus_interfaces_list, calculus_tab_names, title="Calculus")
 differential_equations_tab = gr.TabbedInterface(differential_equations_interfaces_list, differential_equations_tab_names, title="Differential Equations")

maths/algebra/algebra_interface.py

@@ -1,7 +1,6 @@
 import gradio as gr
 from maths.algebra.solve_linear_equation import solve_linear_equation
-from maths.algebra.evaluate_expression import evaluate_expression
-from maths.algebra.solve_quadratic import solve_quadratic
+from maths.algebra.evaluate_quadratic_expression import evaluate_quadratic_expression
 from maths.algebra.simplify_radical import simplify_radical
 from maths.algebra.polynomial_operations import polynomial_operations
 
@@ -18,7 +17,7 @@ solve_linear_equation_interface = gr.Interface(
 )
 
 evaluate_expression_interface = gr.Interface(
-    fn=evaluate_expression,
+    fn=evaluate_quadratic_expression,
     inputs=[
         gr.Number(label="a (coefficient of x²)"),
         gr.Number(label="b (coefficient of x)"),
@@ -30,64 +29,6 @@ evaluate_expression_interface = gr.Interface(
     description="Evaluate ax² + bx + c for a given value of x"
 )
 
-def quadratic_solver_wrapper(a, b, c, return_format):
-    """Wrapper function for the quadratic solver to format the output nicely for Gradio."""
-    result = solve_quadratic(a, b, c, return_format=return_format)
-    
-    if return_format == "dict":
-        # Format the dictionary output for display
-        if "error" in result:
-            return result["error"]
-        
-        roots = result["roots"]
-        vertex = result["vertex"]
-        
-        # Create a nicely formatted output
-        output = ""
-        
-        # Format the equation
-        sign_b = "+" if b >= 0 else ""
-        sign_c = "+" if c >= 0 else ""
-        output += f"Equation: {a}x² {sign_b} {b}x {sign_c} {c} = 0\n\n"
-        
-        # Format roots
-        if roots[1] is None:  # Linear equation case
-            output += f"Root: {roots[0]}\n"
-        else:
-            # Check if roots are complex
-            if isinstance(roots[0], complex) or isinstance(roots[1], complex):
-                output += f"Root 1: {roots[0]}\n"
-                output += f"Root 2: {roots[1]}\n"
-            else:
-                output += f"Root 1: {roots[0]}\n"
-                output += f"Root 2: {roots[1]}\n"
-        
-        # Format vertex
-        if vertex:
-            output += f"\nVertex: ({vertex[0]}, {vertex[1]})"
-            
-        return output
-    else:
-        # String format is already formatted well
-        return result
-
-solve_quadratic_interface = gr.Interface(
-    fn=quadratic_solver_wrapper,
-    inputs=[
-        gr.Number(label="a (coefficient of x²)"),
-        gr.Number(label="b (coefficient of x)"),
-        gr.Number(label="c (constant)"),
-        gr.Radio(
-            choices=["string", "dict"], 
-            value="dict",
-            label="Output Format",
-            info="'string' for text output, 'dict' for formatted output with roots and vertex"
-        )
-    ],
-    outputs="text",
-    title="Quadratic Equation Solver",
-    description="Solve ax² + bx + c = 0 and find vertex"
-)
 
 simplify_radical_interface = gr.Interface(
     fn=simplify_radical,
@@ -119,127 +60,12 @@ polynomial_interface = gr.Interface(
     description="Add, subtract, or multiply two polynomials. Enter coefficients in descending order of power."
 )
 
-# Add an interactive visualizer for quadratic functions
-def plot_quadratic(a, b, c):
-    """Plot the quadratic function f(x) = ax^2 + bx + c with its vertex and roots."""
-    import numpy as np
-    import matplotlib.pyplot as plt
-    
-    # Calculate vertex
-    vertex_x = -b / (2*a) if a != 0 else 0
-    vertex_y = c - (b**2 / (4*a)) if a != 0 else 0
-    
-    # Calculate roots (if they exist)
-    result = solve_quadratic(a, b, c, return_format="dict")
-    
-    # Create the plot
-    fig, ax = plt.subplots(figsize=(8, 6))
-    
-    # Calculate appropriate x range based on vertex and roots
-    if a != 0:
-        # Find appropriate range based on vertex and/or roots
-        if "roots" in result and result["roots"][0] is not None and result["roots"][1] is not None:
-            # Extract real parts of roots
-            root1 = result["roots"][0].real if hasattr(result["roots"][0], "real") else float(result["roots"][0])
-            root2 = result["roots"][1].real if hasattr(result["roots"][1], "real") else float(result["roots"][1])
-            x_min = min(root1, root2, vertex_x) - 2
-            x_max = max(root1, root2, vertex_x) + 2
-        else:
-            # No roots or only one root - use vertex
-            x_min = vertex_x - 5
-            x_max = vertex_x + 5
-            
-        x = np.linspace(x_min, x_max, 1000)
-        y = a * (x**2) + b * x + c
-        
-        # Plot the function
-        ax.plot(x, y, 'b-', label=f'f(x) = {a}x² + {b}x + {c}')
-        
-        # Plot the vertex
-        ax.plot(vertex_x, vertex_y, 'ro', label=f'Vertex: ({vertex_x:.2f}, {vertex_y:.2f})')
-        
-        # Plot the roots if they exist and are real
-        if "roots" in result:
-            roots = result["roots"]
-            if roots[0] is not None and (isinstance(roots[0], (int, float)) or 
-                                         (hasattr(roots[0], "imag") and roots[0].imag == 0)):
-                root1 = float(roots[0].real if hasattr(roots[0], "real") else roots[0])
-                ax.plot(root1, 0, 'go', label=f'Root 1: {root1:.2f}')
-                
-            if roots[1] is not None and (isinstance(roots[1], (int, float)) or 
-                                        (hasattr(roots[1], "imag") and roots[1].imag == 0)):
-                root2 = float(roots[1].real if hasattr(roots[1], "real") else roots[1]) 
-                ax.plot(root2, 0, 'go', label=f'Root 2: {root2:.2f}')
-            
-        # Plot x and y axes
-        ax.axhline(y=0, color='k', linestyle='-', alpha=0.3)
-        ax.axvline(x=0, color='k', linestyle='-', alpha=0.3)
-        
-        # Add grid
-        ax.grid(True, alpha=0.3)
-        
-        # Set labels and title
-        ax.set_xlabel('x')
-        ax.set_ylabel('f(x)')
-        ax.set_title(f'Graph of f(x) = {a}x² + {b}x + {c}')
-        
-        # Add legend
-        ax.legend()
-    else:
-        # Handle linear case or invalid case
-        if b != 0:  # Linear function
-            x = np.linspace(-5, 5, 100)
-            y = b * x + c
-            ax.plot(x, y, 'b-', label=f'f(x) = {b}x + {c} (Linear)')
-            
-            # Plot the root if it exists
-            root = -c/b
-            ax.plot(root, 0, 'go', label=f'Root: {root:.2f}')
-            
-            # Plot axes
-            ax.axhline(y=0, color='k', linestyle='-', alpha=0.3)
-            ax.axvline(x=0, color='k', linestyle='-', alpha=0.3)
-            
-            ax.grid(True, alpha=0.3)
-            ax.set_xlabel('x')
-            ax.set_ylabel('f(x)')
-            ax.set_title(f'Graph of f(x) = {b}x + {c} (Linear)')
-            ax.legend()
-        else:  # Constant function
-            x = np.linspace(-5, 5, 100)
-            y = c * np.ones_like(x)
-            ax.plot(x, y, 'b-', label=f'f(x) = {c} (Constant)')
-            
-            ax.axhline(y=0, color='k', linestyle='-', alpha=0.3)
-            ax.axvline(x=0, color='k', linestyle='-', alpha=0.3)
-            
-            ax.grid(True, alpha=0.3)
-            ax.set_xlabel('x')
-            ax.set_ylabel('f(x)')
-            ax.set_title(f'Graph of f(x) = {c} (Constant)')
-            ax.legend()
-    
-    return fig
-
-quadratic_visualizer_interface = gr.Interface(
-    fn=plot_quadratic,
-    inputs=[
-        gr.Number(label="a (coefficient of x²)", value=1),
-        gr.Number(label="b (coefficient of x)", value=0),
-        gr.Number(label="c (constant)", value=0)
-    ],
-    outputs=gr.Plot(),
-    title="Quadratic Function Visualizer",
-    description="Visualize the graph of a quadratic function f(x) = ax² + bx + c with its vertex and roots"
-)
 
 # Create the main Gradio application that combines all interfaces
 algebra_app = gr.TabbedInterface(
     [solve_linear_equation_interface, evaluate_expression_interface, 
-     solve_quadratic_interface, quadratic_visualizer_interface, 
      simplify_radical_interface, polynomial_interface],
-    ["Linear Solver", "Expression Evaluator", "Quadratic Solver", 
-     "Quadratic Visualizer", "Radical Simplifier", "Polynomials"]
+    ["Linear Solver", "Expression Evaluator",  "Radical Simplifier", "Polynomials"]
 )
 
 # Allow the Gradio interface to be run directly or imported

maths/algebra/{evaluate_expression.py → evaluate_quadratic_expression.py}

@@ -1,5 +1,5 @@
 """
 Evaluate the expression ax² + bx + c for a given value of x.
 """
-def evaluate_expression(a, b, c, x):
+def evaluate_quadratic_expression(a, b, c, x):
     return a * (x ** 2) + b * x + c

maths/equations/equations_interface.py

@@ -0,0 +1,126 @@
+# filepath: c:\Users\visha\Desktop\coding\counting\maths\equations\equations_interface.py
+import gradio as gr
+from maths.equations.solve_quadratic import solve_quadratic
+
+# Quadratic Equation Solver Interface
+def quadratic_solver_wrapper(a, b, c, return_format):
+    result = solve_quadratic(a, b, c, return_format=return_format)
+    if return_format == "dict":
+        if "error" in result:
+            return result["error"]
+        roots = result["roots"]
+        vertex = result["vertex"]
+        output = ""
+        sign_b = "+" if b >= 0 else ""
+        sign_c = "+" if c >= 0 else ""
+        output += f"Equation: {a}x² {sign_b} {b}x {sign_c} {c} = 0\n\n"
+        if roots[1] is None:
+            output += f"Root: {roots[0]}\n"
+        else:
+            output += f"Root 1: {roots[0]}\n"
+            output += f"Root 2: {roots[1]}\n"
+        if vertex:
+            output += f"\nVertex: ({vertex[0]}, {vertex[1]})"
+        return output
+    else:
+        return result
+
+solve_quadratic_interface = gr.Interface(
+    fn=quadratic_solver_wrapper,
+    inputs=[
+        gr.Number(label="a (coefficient of x²)"),
+        gr.Number(label="b (coefficient of x)"),
+        gr.Number(label="c (constant)"),
+        gr.Radio(
+            choices=["string", "dict", "surd"],
+            value="dict",
+            label="Output Format",
+            info="'string' for text output, 'dict' for formatted output, 'surd' for exact roots"
+        )
+    ],
+    outputs="text",
+    title="Quadratic Equation Solver",
+    description="Solve ax² + bx + c = 0 and find vertex"
+)
+
+def plot_quadratic(a, b, c):
+    import numpy as np
+    import matplotlib.pyplot as plt
+    result = solve_quadratic(a, b, c, return_format="dict")
+    vertex_x = -b / (2*a) if a != 0 else 0
+    vertex_y = c - (b**2 / (4*a)) if a != 0 else 0
+    fig, ax = plt.subplots(figsize=(8, 6))
+    if a != 0:
+        if "roots" in result and result["roots"][0] is not None and result["roots"][1] is not None:
+            root1 = result["roots"][0].real if hasattr(result["roots"][0], "real") else float(result["roots"][0])
+            root2 = result["roots"][1].real if hasattr(result["roots"][1], "real") else float(result["roots"][1])
+            x_min = min(root1, root2, vertex_x) - 2
+            x_max = max(root1, root2, vertex_x) + 2
+        else:
+            x_min = vertex_x - 5
+            x_max = vertex_x + 5
+        x = np.linspace(x_min, x_max, 1000)
+        y = a * (x**2) + b * x + c
+        ax.plot(x, y, 'b-', label=f'f(x) = {a}x² + {b}x + {c}')
+        ax.plot(vertex_x, vertex_y, 'ro', label=f'Vertex: ({vertex_x:.2f}, {vertex_y:.2f})')
+        if "roots" in result:
+            roots = result["roots"]
+            if roots[0] is not None and (isinstance(roots[0], (int, float)) or (hasattr(roots[0], "imag") and roots[0].imag == 0)):
+                root1 = float(roots[0].real if hasattr(roots[0], "real") else roots[0])
+                ax.plot(root1, 0, 'go', label=f'Root 1: {root1:.2f}')
+            if roots[1] is not None and (isinstance(roots[1], (int, float)) or (hasattr(roots[1], "imag") and roots[1].imag == 0)):
+                root2 = float(roots[1].real if hasattr(roots[1], "real") else roots[1])
+                ax.plot(root2, 0, 'go', label=f'Root 2: {root2:.2f}')
+        ax.axhline(y=0, color='k', linestyle='-', alpha=0.3)
+        ax.axvline(x=0, color='k', linestyle='-', alpha=0.3)
+        ax.grid(True, alpha=0.3)
+        ax.set_xlabel('x')
+        ax.set_ylabel('f(x)')
+        ax.set_title(f'Graph of f(x) = {a}x² + {b}x + {c}')
+        ax.legend()
+    else:
+        if b != 0:
+            x = np.linspace(-5, 5, 100)
+            y = b * x + c
+            ax.plot(x, y, 'b-', label=f'f(x) = {b}x + {c} (Linear)')
+            root = -c/b
+            ax.plot(root, 0, 'go', label=f'Root: {root:.2f}')
+            ax.axhline(y=0, color='k', linestyle='-', alpha=0.3)
+            ax.axvline(x=0, color='k', linestyle='-', alpha=0.3)
+            ax.grid(True, alpha=0.3)
+            ax.set_xlabel('x')
+            ax.set_ylabel('f(x)')
+            ax.set_title(f'Graph of f(x) = {b}x + {c} (Linear)')
+            ax.legend()
+        else:
+            x = np.linspace(-5, 5, 100)
+            y = c * np.ones_like(x)
+            ax.plot(x, y, 'b-', label=f'f(x) = {c} (Constant)')
+            ax.axhline(y=0, color='k', linestyle='-', alpha=0.3)
+            ax.axvline(x=0, color='k', linestyle='-', alpha=0.3)
+            ax.grid(True, alpha=0.3)
+            ax.set_xlabel('x')
+            ax.set_ylabel('f(x)')
+            ax.set_title(f'Graph of f(x) = {c} (Constant)')
+            ax.legend()
+    return fig
+
+quadratic_visualizer_interface = gr.Interface(
+    fn=plot_quadratic,
+    inputs=[
+        gr.Number(label="a (coefficient of x²)", value=1),
+        gr.Number(label="b (coefficient of x)", value=0),
+        gr.Number(label="c (constant)", value=0)
+    ],
+    outputs=gr.Plot(),
+    title="Quadratic Function Visualizer",
+    description="Visualize the graph of a quadratic function f(x) = ax² + bx + c with its vertex and roots"
+)
+
+equations_app = gr.TabbedInterface(
+    [solve_quadratic_interface, quadratic_visualizer_interface],
+    ["Quadratic Solver", "Quadratic Visualizer"]
+)
+
+if __name__ == "__main__":
+    equations_app.launch()

maths/{algebra → equations}/solve_quadratic.py

@@ -3,6 +3,8 @@ Solve the quadratic equation ax^2 + bx + c = 0.
 """
 import cmath
 from fractions import Fraction
+import math
+import sympy as sp
 
 def solve_quadratic(a: float, b: float, c: float, return_format: str = "string"):
     if a == 0:
@@ -18,6 +20,15 @@ def solve_quadratic(a: float, b: float, c: float, return_format: str = "string")
     vertex_y = c - (b**2 / (4 * a))
     vertex = (vertex_x, vertex_y)
     delta = b**2 - 4*a*c
+    # Surd form using sympy
+    if return_format == "surd":
+        x1 = (-b + sp.sqrt(delta)) / (2*a)
+        x2 = (-b - sp.sqrt(delta)) / (2*a)
+        return {
+            "roots": (sp.simplify(x1), sp.simplify(x2)),
+            "vertex": vertex,
+            "discriminant": delta
+        }
     if return_format == "dict":
         discriminant = cmath.sqrt(b**2 - 4*a*c)
         root1 = (-b + discriminant) / (2 * a)