feat: implement Gradio interfaces for quadratic equation solving and visualization; remove old interfaces

maths/equations/equations_interface.py

@@ -25,24 +25,6 @@ def quadratic_solver_wrapper(a, b, c, return_format):
     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
@@ -104,23 +86,3 @@ def plot_quadratic(a, b, c):
             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/equations/equations_tab.py

@@ -1,6 +1,10 @@
 import gradio as gr
-from maths.equations.equations_interface import equations_app, solve_quadratic_interface
-from maths.algebra.solve_linear_equation import solve_linear_equation_interface
-from maths.geometry.trigonometry_interface import solve_trig_equations_interface
+from maths.equations.solve_quadratic import solve_quadratic_interface, quadratic_visualizer_interface
 
-equations_tab = equations_app  # Only include the composite equations_app in the equations tab to avoid duplicate Gradio blocks
+# You can add more equation-related interfaces here as needed
+
+equations_tab = gr.TabbedInterface(
+    [solve_quadratic_interface, quadratic_visualizer_interface],
+    ["Quadratic Solver", "Quadratic Visualizer"],
+    title="Equations"
+)

maths/equations/solve_quadratic.py

@@ -5,6 +5,7 @@ import cmath
 from fractions import Fraction
 import math
 import sympy as sp
+import gradio as gr
 
 def solve_quadratic(a: float, b: float, c: float, return_format: str = "string"):
     if a == 0:
@@ -56,4 +57,118 @@ def solve_quadratic(a: float, b: float, c: float, return_format: str = "string")
     else:
         real_part = -b / (2*a)
         imag_part = (-delta)**0.5 / (2*a)
-        return f"Two complex roots: x1 = {real_part} + {imag_part}i, x2 = {real_part} - {imag_part}i\nVertex at: {vertex}"
+        return f"Two complex roots: x1 = {real_part} + {imag_part}i, x2 = {real_part} - {imag_part}i\nVertex at: {vertex}"
+
+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"
+)