feat: add Gradio interfaces for cubic and polynomial equation solving; update quadratic solver to use numpy

maths/equations/equations_tab.py

@@ -1,10 +1,11 @@
 import gradio as gr
 from maths.equations.solve_quadratic import solve_quadratic_interface, quadratic_visualizer_interface
+from maths.equations.solve_cubic import cubic_solver_interface
+from maths.equations.solve_poly import poly_solver_interface
 
-# You can add more equation-related interfaces here as needed
 
 equations_tab = gr.TabbedInterface(
-    [solve_quadratic_interface, quadratic_visualizer_interface],
-    ["Quadratic Solver", "Quadratic Visualizer"],
+    [solve_quadratic_interface, quadratic_visualizer_interface, cubic_solver_interface, poly_solver_interface],
+    ["Quadratic Solver", "Quadratic Visualizer", "Cubic Solver", "Polynomial Solver"],
     title="Equations"
 )

maths/equations/solve_cubic.py

@@ -0,0 +1,46 @@
+import gradio as gr
+import numpy as np
+
+def solve_cubic(a, b, c, d):
+    """
+    Solve cubic equation: a*x^3 + b*x^2 + c*x + d = 0
+    Returns a tuple of three roots (complex or real).
+    """
+    if a == 0:
+        # Degenerates to quadratic
+        from .solve_quadratic import solve_quadratic
+        result = solve_quadratic(b, c, d, return_format="dict")
+        roots = result["roots"]
+        return (roots[0], roots[1], None)
+    # Use numpy.roots for cubic
+    roots = np.roots([a, b, c, d])
+    # Ensure three roots (may be complex)
+    if len(roots) < 3:
+        roots = tuple(list(roots) + [None]*(3-len(roots)))
+    else:
+        roots = tuple(roots)
+    return roots
+
+def cubic_solver_wrapper(a, b, c, d):
+    roots = solve_cubic(a, b, c, d)
+    output = f"Equation: {a}x³ + {b}x² + {c}x + {d} = 0\n\n"
+    for i, root in enumerate(roots):
+        if root is not None:
+            if np.isreal(root):
+                output += f"Root {i+1}: {root.real}\n"
+            else:
+                output += f"Root {i+1}: {root}\n"
+    return output
+
+cubic_solver_interface = gr.Interface(
+    fn=cubic_solver_wrapper,
+    inputs=[
+        gr.Number(label="a (coefficient of x³)"),
+        gr.Number(label="b (coefficient of x²)"),
+        gr.Number(label="c (coefficient of x)"),
+        gr.Number(label="d (constant)")
+    ],
+    outputs="text",
+    title="Cubic Equation Solver",
+    description="Solve ax³ + bx² + cx + d = 0"
+)

maths/equations/solve_poly.py

@@ -0,0 +1,40 @@
+import numpy as np
+
+def solve_polynomial(coeffs):
+    """
+    Find roots of a polynomial with given coefficients.
+    coeffs: list or array-like, highest degree first (e.g., [a, b, c, d, ...])
+    Returns a numpy array of roots (complex or real).
+    """
+    if not coeffs or all(c == 0 for c in coeffs):
+        raise ValueError("Coefficient list must not be empty or all zeros.")
+    return np.roots(coeffs)
+
+def polynomial_solver_interface(coeffs):
+    """
+    Gradio wrapper for solving higher order polynomials.
+    coeffs: comma-separated string of coefficients, highest degree first.
+    """
+    import numpy as np
+    try:
+        coeff_list = [float(c) for c in coeffs.split(",") if c.strip() != ""]
+        if not coeff_list:
+            return "Please enter at least one coefficient."
+        roots = solve_polynomial(coeff_list)
+        output = f"Polynomial coefficients: {coeff_list}\n\n"
+        for i, root in enumerate(roots):
+            if np.isreal(root):
+                output += f"Root {i+1}: {root.real}\n"
+            else:
+                output += f"Root {i+1}: {root}\n"
+        return output
+    except Exception as e:
+        return f"Error: {e}"
+
+poly_solver_interface = gr.Interface(
+    fn=polynomial_solver_interface,
+    inputs=gr.Textbox(label="Coefficients (comma-separated, highest degree first)", placeholder="e.g. 1, 0, -2, -8"),
+    outputs="text",
+    title="Polynomial Equation Solver",
+    description="Find roots of any polynomial. Enter coefficients separated by commas (highest degree first)."
+)

maths/equations/solve_quadratic.py

@@ -3,9 +3,9 @@ Solve the quadratic equation ax^2 + bx + c = 0.
 """
 import cmath
 from fractions import Fraction
-import math
 import sympy as sp
 import gradio as gr
+import numpy as np
 
 def solve_quadratic(a: float, b: float, c: float, return_format: str = "string"):
     if a == 0:
@@ -31,13 +31,21 @@ def solve_quadratic(a: float, b: float, c: float, return_format: str = "string")
             "discriminant": delta
         }
     if return_format == "dict":
-        discriminant = cmath.sqrt(b**2 - 4*a*c)
-        root1 = (-b + discriminant) / (2 * a)
-        root2 = (-b - discriminant) / (2 * a)
-        if root1.imag == 0 and root2.imag == 0:
-            root1 = Fraction(root1.real).limit_denominator()
-            root2 = Fraction(root2.real).limit_denominator()
-        return {"roots": (root1, root2), "vertex": vertex}
+        # Use numpy.roots for quadratic
+        roots = np.roots([a, b, c])
+        # Ensure two roots (may be complex)
+        if len(roots) == 1:
+            roots = (roots[0], None)
+        else:
+            roots = tuple(roots)
+        # Try to convert to Fraction if real
+        roots_fmt = []
+        for r in roots:
+            if r is not None and np.isreal(r):
+                roots_fmt.append(Fraction(r.real).limit_denominator())
+            else:
+                roots_fmt.append(r)
+        return {"roots": tuple(roots_fmt), "vertex": vertex}
     if delta > 0:
         x1 = (-b + delta**0.5) / (2*a)
         x2 = (-b - delta**0.5) / (2*a)