Enhance quadratic solver and interfaces:

- Update `solve_quadratic` to support output formatting (string/dict) and include vertex calculation.
- Add `quadratic_solver_wrapper` for Gradio interface to format results.
- Introduce `plot_quadratic` function for visualizing quadratic functions with roots and vertex.
- Modify Gradio interfaces to use new functionalities and improve user interaction.
- Change flagging mode to manual for ODE interfaces in differential equations and operations research.

maths/middleschool/algebra.py

@@ -1,6 +1,8 @@
 """
 Basic algebra operations for middle school level.
 """
+import cmath
+from fractions import Fraction
 
 def solve_linear_equation(a, b):
     """
@@ -20,7 +22,7 @@ def evaluate_expression(a, b, c, x):
     return a * (x ** 2) + b * x + c
 
 
-def solve_quadratic(a: float, b: float, c: float) -> str:
+def solve_quadratic(a: float, b: float, c: float, return_format: str = "string"):
     """
     Solve the quadratic equation ax^2 + bx + c = 0.
 
@@ -28,29 +30,66 @@ def solve_quadratic(a: float, b: float, c: float) -> str:
         a: Coefficient of x^2.
         b: Coefficient of x.
         c: Constant term.
+        return_format: Format of return value - "string" for human-readable string
+                      or "dict" for dictionary with roots and vertex.
 
     Returns:
-        A string representing the solutions.
+        Either a string representing the solutions or a dictionary with roots and vertex.
     """
     if a == 0:
         if b == 0:
-            return "Not a valid equation (a and b cannot both be zero)." if c != 0 else "Infinite solutions (0 = 0)"
+            result = "Not a valid equation (a and b cannot both be zero)." if c != 0 else "Infinite solutions (0 = 0)"
+            return result if return_format == "string" else {"error": result}
         # Linear equation: bx + c = 0 -> x = -c/b
-        return f"Linear equation: x = {-c/b}"
-
+        root = -c/b
+        if return_format == "string":
+            return f"Linear equation: x = {root}"
+        else:
+            return {"roots": (root, None), "vertex": None}
+
+    # Calculate vertex
+    vertex_x = -b / (2 * a)
+    vertex_y = c - (b**2 / (4 * a))
+    vertex = (vertex_x, vertex_y)
+    
+    # Calculate discriminant and roots
     delta = b**2 - 4*a*c
-
+    
+    if return_format == "dict":
+        # Use cmath for complex roots
+        discriminant = cmath.sqrt(b**2 - 4*a*c)
+        root1 = (-b + discriminant) / (2 * a)
+        root2 = (-b - discriminant) / (2 * a)
+        
+        # Convert to fraction if possible
+        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}
+    
+    # For string format, handle different cases
     if delta > 0:
         x1 = (-b + delta**0.5) / (2*a)
         x2 = (-b - delta**0.5) / (2*a)
-        return f"Two distinct real roots: x1 = {x1}, x2 = {x2}"
+        # Try to convert to fractions for cleaner display
+        try:
+            x1_frac = Fraction(x1).limit_denominator()
+            x2_frac = Fraction(x2).limit_denominator()
+            return f"Two distinct real roots: x1 = {x1_frac}, x2 = {x2_frac}\nVertex at: {vertex}"
+        except:
+            return f"Two distinct real roots: x1 = {x1}, x2 = {x2}\nVertex at: {vertex}"
     elif delta == 0:
         x1 = -b / (2*a)
-        return f"One real root (repeated): x = {x1}"
+        try:
+            x1_frac = Fraction(x1).limit_denominator()
+            return f"One real root (repeated): x = {x1_frac}\nVertex at: {vertex}"
+        except:
+            return f"One real root (repeated): x = {x1}\nVertex at: {vertex}"
     else: # delta < 0
         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"
+        return f"Two complex roots: x1 = {real_part} + {imag_part}i, x2 = {real_part} - {imag_part}i\nVertex at: {vertex}"
 
 
 def simplify_radical(number: int) -> str:

maths/middleschool/algebra_interface.py

@@ -1,5 +1,8 @@
 import gradio as gr
-from maths.middleschool.algebra import solve_linear_equation, evaluate_expression, solve_quadratic, simplify_radical, polynomial_operations
+from maths.middleschool.algebra import (
+    solve_linear_equation, evaluate_expression, solve_quadratic, 
+    simplify_radical, polynomial_operations
+)
 
 # Middle School Math Tab
 solve_linear_equation_interface = gr.Interface(
@@ -26,16 +29,63 @@ 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=solve_quadratic,
+    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.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"
+    description="Solve ax² + bx + c = 0 and find vertex"
 )
 
 simplify_radical_interface = gr.Interface(
@@ -67,3 +117,130 @@ polynomial_interface = gr.Interface(
     title="Polynomial Operations",
     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"]
+)
+
+# Allow the Gradio interface to be run directly or imported
+if __name__ == "__main__":
+    algebra_app.launch()

maths/university/differential_equations_interface.py

@@ -117,7 +117,7 @@ first_order_ode_interface = gr.Interface(
                 "WARNING: Uses eval() for the ODE function string - potential security risk. " \
                 "For systems, `y` in lambda is `[y1, y2, ...]`, return `[dy1/dt, dy2/dt, ...]`. " \
                 "Example (Damped Oscillator): ODE: lambda t, y: [y[1], -0.5*y[1] - y[0]], y0: 1,0, Timespan: 0,20",
-    allow_flagging="never"
+    flagging_mode="manual"
 )
 
 # --- Gradio Interface for Second-Order ODEs ---
@@ -150,7 +150,7 @@ second_order_ode_interface = gr.Interface(
     description="Solves d²y/dt² = f(t, y, dy/dt). " \
                 "WARNING: Uses eval() for the ODE function string - potential security risk. " \
                 "Example (Pendulum): ODE: lambda t, y, dy_dt: -9.81/1.0 * math.sin(y), y0: math.pi/4, dy0/dt: 0, Timespan: 0,10",
-    allow_flagging="never"
+    flagging_mode="manual"
 )
 
 # Example usage for testing (can be removed)

maths/university/operations_research/operations_research_interface.py

@@ -230,7 +230,7 @@ branch_and_bound_interface = gr.Interface(
             True #maximize
         ]
     ],
-    allow_flagging="never"
+    flagging_mode="manual"
 )
 
 # --- Simplex Solver (with Steps) Interface ---
@@ -357,7 +357,7 @@ simplex_solver_interface = gr.Interface(
             "0,None;0,None" # x1-x2 <=1, -x1+x2 <=1
         ]
     ],
-    allow_flagging="never"
+    flagging_mode="manual"
 )
 
 # --- Dual Simplex Interface ---
@@ -477,5 +477,5 @@ dual_simplex_interface = gr.Interface(
             "max", "1,1", "-2,-1;-1,-2", "<=,<=", "-10,-10"
         ]
     ],
-    allow_flagging="never"
+    flagging_mode="manual"
 )