feat: add Gradio interfaces for trigonometric functions and remove old trigonometry interface

maths/differential_equations/differential_equations_interface.py

@@ -1,106 +0,0 @@
-"""
-Gradio Interface for Differential Equations solvers.
-
-SECURITY WARNING: These interfaces use eval() to parse user-provided Python lambda strings
-for defining ODE functions. This is a potential security risk if arbitrary code is entered.
-Use with caution and only with trusted inputs, especially if deploying this application
-outside a controlled environment.
-"""
-import gradio as gr
-import numpy as np
-import matplotlib.pyplot as plt # For displaying plots if not returned directly by solver
-from typing import Callable, Tuple, List, Dict, Any, Union
-import ast # For safer string literal evaluation if needed for parameters
-import math # To make math functions available in eval scope for ODEs
-
-# Import the solver functions
-from maths.differential_equations.solve_first_order_ode import solve_first_order_ode
-from maths.differential_equations.solve_second_order_ode import solve_second_order_ode
-from maths.differential_equations.ode_interface_utils import parse_float_list, parse_time_span, string_to_ode_func
-
-# --- Helper Functions ---
-
-# (Keep the helper functions here if needed, otherwise they can be removed as they are now in ode_interface_utils.py)
-
-# --- Gradio Interface for First-Order ODEs ---
-# first_order_ode_interface = gr.Interface(
-#     fn=lambda ode_str, t_span_str, y0_str, t_eval_count, method: solve_first_order_ode(
-#         string_to_ode_func(ode_str, ('t', 'y')),
-#         parse_time_span(t_span_str),
-#         parse_float_list(y0_str), # y0 can be a list for systems
-#         int(t_eval_count),
-#         method
-#     ),
-#     inputs=[
-#         gr.Textbox(label="ODE Function (lambda t, y: ...)",
-#                    placeholder="e.g., lambda t, y: -y*t  OR for system lambda t, y: [y[1], -0.1*y[1] - y[0]]",
-#                    info="Define dy/dt or a system [dy1/dt, dy2/dt,...]. `y` is a list/array for systems."),
-#         gr.Textbox(label="Time Span (t_start, t_end)", placeholder="e.g., 0,10"),
-#         gr.Textbox(label="Initial Condition(s) y(t_start)", placeholder="e.g., 1 OR for system 1,0"),
-#         gr.Slider(minimum=10, maximum=1000, value=100, step=10, label="Evaluation Points Count"),
-#         gr.Radio(choices=['RK45', 'LSODA', 'BDF', 'RK23', 'DOP853'], value='RK45', label="Solver Method")
-#     ],
-#     outputs=[
-#         gr.Image(label="Solution Plot", type="filepath", show_label=True, visible=lambda res: res['success'] and res['plot_path'] is not None),
-#         gr.Textbox(label="Solver Message"),
-#         gr.Textbox(label="Success Status"),
-#         gr.JSON(label="Raw Data (t, y values)", visible=lambda res: res['success']) # For users to copy if needed
-#     ],
-#     title="First-Order ODE Solver",
-#     description="Solves dy/dt = f(t,y) or a system of first-order ODEs. " \
-#                 "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",
-#     flagging_mode="manual"
-# )
-
-# # --- Gradio Interface for Second-Order ODEs ---
-# second_order_ode_interface = gr.Interface(
-#     fn=lambda ode_str, t_span_str, y0_val_str, dy0_dt_val_str, t_eval_count, method: solve_second_order_ode(
-#         string_to_ode_func(ode_str, ('t', 'y', 'dy_dt')), # Note: dy_dt is one variable name here
-#         parse_time_span(t_span_str),
-#         parse_float_list(y0_val_str, expected_len=1)[0], # y0 is a single float
-#         parse_float_list(dy0_dt_val_str, expected_len=1)[0], # dy0_dt is a single float
-#         int(t_eval_count),
-#         method
-#     ),
-#     inputs=[
-#         gr.Textbox(label="ODE Function (lambda t, y, dy_dt: ...)",
-#                    placeholder="e.g., lambda t, y, dy_dt: -0.1*dy_dt - math.sin(y)",
-#                    info="Define d²y/dt². `y` is current value, `dy_dt` is current first derivative."),
-#         gr.Textbox(label="Time Span (t_start, t_end)", placeholder="e.g., 0,20"),
-#         gr.Textbox(label="Initial y(t_start)", placeholder="e.g., 1.0"),
-#         gr.Textbox(label="Initial dy/dt(t_start)", placeholder="e.g., 0.0"),
-#         gr.Slider(minimum=10, maximum=1000, value=100, step=10, label="Evaluation Points Count"),
-#         gr.Radio(choices=['RK45', 'LSODA', 'BDF', 'RK23', 'DOP853'], value='RK45', label="Solver Method")
-#     ],
-#     outputs=[
-#         gr.Image(label="Solution Plot (y(t) and dy/dt(t))", type="filepath", show_label=True, visible=lambda res: res['success'] and res['plot_path'] is not None),
-#         gr.Textbox(label="Solver Message"),
-#         gr.Textbox(label="Success Status"),
-#         gr.JSON(label="Raw Data (t, y, dy_dt values)", visible=lambda res: res['success'])
-#     ],
-#     title="Second-Order ODE Solver",
-#     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",
-#     flagging_mode="manual"
-# )
-
-# Example usage for testing (can be removed)
-if __name__ == '__main__':
-    # Test first order
-    # result1 = solve_first_order_ode(lambda t,y: -y*t, (0,5), [1])
-    # print(result1['success'], result1['message'])
-    # if result1['plot_path']: import os; os.system(f"open {result1['plot_path']}")
-
-
-    # Test second order
-    # result2 = solve_second_order_ode(lambda t,y,dydt: -0.1*dydt - y, (0,20), 1, 0)
-    # print(result2['success'], result2['message'])
-    # if result2['plot_path']: import os; os.system(f"open {result2['plot_path']}")
-
-    # To run one of these interfaces for testing:
-    # first_order_ode_interface.launch()
-    # second_order_ode_interface.launch()
-    pass

maths/equations/equations_interface.py

@@ -1,88 +0,0 @@
-# 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
-
-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

maths/geometry/cos_degrees.py

@@ -1,5 +1,14 @@
 import math
+import gradio as gr
 
 def cos_degrees(angle):
     """Calculate the cosine of an angle in degrees."""
     return math.cos(math.radians(angle))
+
+cos_degrees_interface = gr.Interface(
+    fn=cos_degrees,
+    inputs=gr.Number(label="Angle (degrees)"),
+    outputs="number",
+    title="Cosine Calculator",
+    description="Calculate cosine of an angle in degrees."
+)

maths/geometry/geometry_tab.py

@@ -1,9 +1,9 @@
 import gradio as gr
-from maths.geometry.trigonometry_interface import (
-    trig_interface, inverse_trig_interface, trig_identities_interface
-)
+from maths.geometry.sin_degrees import sin_degrees_interface
+from maths.geometry.inverse_trig_functions import inverse_trig_interface
+from maths.geometry.trig_identities import trig_identities_interface
 
-geometry_interfaces_list = [trig_interface, inverse_trig_interface, trig_identities_interface]
+geometry_interfaces_list = [sin_degrees_interface, inverse_trig_interface, trig_identities_interface]
 geometry_tab_names = ["Trig Functions", "Inverse Trig", "Trig Identities"]
 
 geometry_tab = gr.TabbedInterface(geometry_interfaces_list, geometry_tab_names, title="Geometry")

maths/geometry/inverse_trig_functions.py

@@ -1,4 +1,5 @@
 import math
+import gradio as gr
 
 def inverse_trig_functions(value: float, function_name: str) -> str:
     """
@@ -29,3 +30,14 @@ def inverse_trig_functions(value: float, function_name: str) -> str:
     else:
         return "Error: Invalid function name. Choose 'asin', 'acos', or 'atan'."
     return f"{math.degrees(result_rad):.4f} degrees"
+
+inverse_trig_interface = gr.Interface(
+    fn=inverse_trig_functions,
+    inputs=[
+        gr.Number(label="Value"),
+        gr.Radio(["asin", "acos", "atan"], label="Inverse Function")
+    ],
+    outputs="text",
+    title="Inverse Trigonometry Calculator",
+    description="Calculate inverse trigonometric functions. Output in degrees."
+)

maths/geometry/sin_degrees.py

@@ -1,5 +1,14 @@
 import math
+import gradio as gr
 
 def sin_degrees(angle):
     """Calculate the sine of an angle in degrees."""
     return math.sin(math.radians(angle))
+
+sin_degrees_interface = gr.Interface(
+    fn=sin_degrees,
+    inputs=gr.Number(label="Angle (degrees)"),
+    outputs="number",
+    title="Sine Calculator",
+    description="Calculate sine of an angle in degrees."
+)

maths/geometry/solve_trig_equations.py

@@ -1,4 +1,5 @@
 import math
+import gradio as gr
 
 def solve_trig_equations(a: float, b: float, c: float, trig_func: str, interval_degrees: tuple[float, float] = (0, 360)) -> str:
     """
@@ -56,3 +57,26 @@ def solve_trig_equations(a: float, b: float, c: float, trig_func: str, interval_
     if not unique_solutions:
         return f"No solutions found for {a}*{func}(x) + {b} = {c} in the interval [{min_interval_deg}, {max_interval_deg}] degrees."
     return f"Solutions for x in [{min_interval_deg}, {max_interval_deg}] degrees: {', '.join(unique_solutions)}"
+
+def parse_interval(interval_str: str) -> tuple[float, float]:
+    try:
+        parts = [float(x.strip()) for x in interval_str.split(',')]
+        if len(parts) == 2 and parts[0] <= parts[1]:
+            return parts[0], parts[1]
+        raise ValueError("Interval must be two numbers, min,max.")
+    except Exception:
+        raise gr.Error("Invalid interval format. Use 'min,max' (e.g., '0,360').")
+
+solve_trig_equations_interface = gr.Interface(
+    fn=lambda a, b, c, func, interval_str: solve_trig_equations(a, b, c, func, parse_interval(interval_str)),
+    inputs=[
+        gr.Number(label="a (coefficient of function)"),
+        gr.Number(label="b (constant added to function part)"),
+        gr.Number(label="c (constant on other side of equation)"),
+        gr.Radio(["sin", "cos", "tan"], label="Trigonometric Function"),
+        gr.Textbox(label="Interval for x (degrees, comma-separated, e.g., 0,360)", value="0,360")
+    ],
+    outputs="text",
+    title="Trigonometric Equation Solver",
+    description="Solves equations like a * func(x) + b = c for x in a given interval (degrees)."
+)

maths/geometry/tan_degrees.py

@@ -1,5 +1,14 @@
 import math
+import gradio as gr
 
 def tan_degrees(angle):
     """Calculate the tangent of an angle in degrees."""
     return math.tan(math.radians(angle))
+
+tan_degrees_interface = gr.Interface(
+    fn=tan_degrees,
+    inputs=gr.Number(label="Angle (degrees)"),
+    outputs="number",
+    title="Tangent Calculator",
+    description="Calculate tangent of an angle in degrees."
+)

maths/geometry/trig_identities.py

@@ -1,4 +1,5 @@
 import math
+import gradio as gr
 
 def trig_identities(angle_degrees: float, identity_name: str = "pythagorean1") -> str:
     """
@@ -51,3 +52,22 @@ def trig_identities(angle_degrees: float, identity_name: str = "pythagorean1") -
     if not results:
         return f"Unknown identity: {identity_name}. Available: pythagorean1, pythagorean2, pythagorean3, all."
     return "\n".join(results)
+
+trig_identities_interface = gr.Interface(
+    fn=trig_identities,
+    inputs=[
+        gr.Number(label="Angle (degrees)"),
+        gr.Radio(
+            choices=[
+                ("sin²(x) + cos²(x) = 1", "pythagorean1"),
+                ("1 + tan²(x) = sec²(x)", "pythagorean2"),
+                ("1 + cot²(x) = csc²(x)", "pythagorean3"),
+                ("All Pythagorean", "all")
+            ],
+            label="Trigonometric Identity to Demonstrate"
+        )
+    ],
+    outputs="text",
+    title="Trigonometric Identities Demonstrator",
+    description="Show common trigonometric identities for a given angle."
+)

maths/geometry/trigonometry_interface.py

@@ -1,79 +0,0 @@
-import gradio as gr
-from maths.geometry.sin_degrees import sin_degrees
-from maths.geometry.cos_degrees import cos_degrees
-from maths.geometry.tan_degrees import tan_degrees
-from maths.geometry.inverse_trig_functions import inverse_trig_functions
-from maths.geometry.solve_trig_equations import solve_trig_equations
-from maths.geometry.trig_identities import trig_identities
-
-# High School Math Tab
-trig_interface = gr.Interface(
-    fn=lambda angle, function: {
-        "sin": sin_degrees(angle),
-        "cos": cos_degrees(angle),
-        "tan": tan_degrees(angle)
-    }[function],
-    inputs=[
-        gr.Number(label="Angle (degrees)"),
-        gr.Radio(["sin", "cos", "tan"], label="Trigonometric Function")
-    ],
-    outputs="number",
-    title="Trigonometry Calculator",
-    description="Calculate trigonometric functions for angles in degrees"
-)
-
-inverse_trig_interface = gr.Interface(
-    fn=inverse_trig_functions,
-    inputs=[
-        gr.Number(label="Value"),
-        gr.Radio(["asin", "acos", "atan"], label="Inverse Function")
-    ],
-    outputs="text",
-    title="Inverse Trigonometry Calculator",
-    description="Calculate inverse trigonometric functions. Output in degrees."
-)
-
-def parse_interval(interval_str: str) -> tuple[float, float]:
-    """Helper to parse comma-separated interval string (e.g., "0,360") into a tuple."""
-    try:
-        parts = [float(x.strip()) for x in interval_str.split(',')]
-        if len(parts) == 2 and parts[0] <= parts[1]:
-            return parts[0], parts[1]
-        raise ValueError("Interval must be two numbers, min,max.")
-    except Exception:
-        # Return a default or raise specific error for Gradio
-        raise gr.Error("Invalid interval format. Use 'min,max' (e.g., '0,360').")
-
-
-solve_trig_equations_interface = gr.Interface(
-    fn=lambda a, b, c, func, interval_str: solve_trig_equations(a,b,c,func, parse_interval(interval_str)),
-    inputs=[
-        gr.Number(label="a (coefficient of function)"),
-        gr.Number(label="b (constant added to function part)"),
-        gr.Number(label="c (constant on other side of equation)"),
-        gr.Radio(["sin", "cos", "tan"], label="Trigonometric Function"),
-        gr.Textbox(label="Interval for x (degrees, comma-separated, e.g., 0,360)", value="0,360")
-    ],
-    outputs="text",
-    title="Trigonometric Equation Solver",
-    description="Solves equations like a * func(x) + b = c for x in a given interval (degrees)."
-)
-
-trig_identities_interface = gr.Interface(
-    fn=trig_identities,
-    inputs=[
-        gr.Number(label="Angle (degrees)"),
-        gr.Radio(
-            choices=[
-                ("sin²(x) + cos²(x) = 1", "pythagorean1"),
-                ("1 + tan²(x) = sec²(x)", "pythagorean2"),
-                ("1 + cot²(x) = csc²(x)", "pythagorean3"),
-                ("All Pythagorean", "all")
-            ],
-            label="Trigonometric Identity to Demonstrate"
-        )
-    ],
-    outputs="text",
-    title="Trigonometric Identities Demonstrator",
-    description="Show common trigonometric identities for a given angle."
-)