modularized

maths/differential_equations/differential_equations.py

@@ -1,236 +0,0 @@
-"""
-Differential Equations solvers for university level, using SciPy.
-"""
-import numpy as np
-from scipy.integrate import solve_ivp
-from typing import Callable, List, Tuple, Dict, Any, Union
-import matplotlib.pyplot as plt
-
-# Type hint for the function defining the ODE system
-ODEFunc = Callable[[float, Union[np.ndarray, List[float]]], Union[np.ndarray, List[float]]]
-
-def solve_first_order_ode(
-    ode_func: ODEFunc,
-    t_span: Tuple[float, float],
-    y0: List[float],
-    t_eval_count: int = 100,
-    method: str = 'RK45',
-    **kwargs: Any
-) -> Dict[str, Union[np.ndarray, str, bool]]:
-    """
-    Solves a first-order ordinary differential equation (or system of first-order ODEs)
-    dy/dt = f(t, y) with initial condition y(t0) = y0.
-
-    Args:
-        ode_func: Callable f(t, y). `t` is a scalar, `y` is an ndarray of shape (n,).
-                  It should return an array-like object of shape (n,).
-                  Example for dy/dt = -2*y: lambda t, y: -2 * y
-                  Example for system dy1/dt = y2, dy2/dt = -y1: lambda t, y: [y[1], -y[0]]
-        t_span: Tuple (t_start, t_end) for the integration interval.
-        y0: List or NumPy array of initial conditions y(t_start).
-        t_eval_count: Number of points at which to store the computed solution.
-        method: Integration method to use (e.g., 'RK45', 'LSODA', 'BDF').
-        **kwargs: Additional keyword arguments to pass to `solve_ivp` (e.g., `rtol`, `atol`).
-
-    Returns:
-        A dictionary containing:
-            't': NumPy array of time points.
-            'y': NumPy array of solution values at each time point. (y[i] corresponds to t[i])
-                 For systems, y is an array with n_equations rows and n_timepoints columns.
-            'message': Solver message.
-            'success': Boolean indicating if the solver was successful.
-            'plot_path': Path to a saved plot of the solution (if successful), else None.
-    """
-    try:
-        y0_np = np.array(y0, dtype=float)
-        t_eval = np.linspace(t_span[0], t_span[1], t_eval_count)
-
-        sol = solve_ivp(ode_func, t_span, y0_np, method=method, t_eval=t_eval, **kwargs)
-
-        plot_path = None
-        if sol.success:
-            try:
-                plt.figure(figsize=(10, 6))
-                if y0_np.ndim == 0 or len(y0_np) == 1 : # Single equation
-                    plt.plot(sol.t, sol.y[0], label=f'y(t), y0={y0_np[0] if y0_np.ndim > 0 else y0_np}')
-                else: # System of equations
-                    for i in range(sol.y.shape[0]):
-                        plt.plot(sol.t, sol.y[i], label=f'y_{i+1}(t), y0_{i+1}={y0_np[i]}')
-                plt.xlabel("Time (t)")
-                plt.ylabel("Solution y(t)")
-                plt.title(f"Solution of First-Order ODE ({method})")
-                plt.legend()
-                plt.grid(True)
-                plot_path = "ode_solution_plot.png"
-                plt.savefig(plot_path)
-                plt.close() # Close the plot to free memory
-            except Exception as e_plot:
-                print(f"Warning: Could not generate plot: {e_plot}")
-                plot_path = None
-
-
-        return {
-            't': sol.t,
-            'y': sol.y,
-            'message': sol.message,
-            'success': sol.success,
-            'plot_path': plot_path
-        }
-    except Exception as e:
-        return {
-            't': np.array([]),
-            'y': np.array([]),
-            'message': f"Error during ODE solving: {str(e)}",
-            'success': False,
-            'plot_path': None
-        }
-
-def solve_second_order_ode(
-    ode_func_second_order: Callable[[float, float, float], float],
-    t_span: Tuple[float, float],
-    y0: float,
-    dy0_dt: float,
-    t_eval_count: int = 100,
-    method: str = 'RK45',
-    **kwargs: Any
-) -> Dict[str, Union[np.ndarray, str, bool]]:
-    """
-    Solves a single second-order ordinary differential equation of the form
-    d²y/dt² = f(t, y, dy/dt) with initial conditions y(t0)=y0 and dy/dt(t0)=dy0_dt.
-
-    This is done by converting the second-order ODE into a system of two first-order ODEs:
-    Let z1 = y and z2 = dy/dt.
-    Then dz1/dt = z2
-    And dz2/dt = d²y/dt² = f(t, z1, z2)
-
-    Args:
-        ode_func_second_order: Callable f(t, y, dy_dt). `t` is scalar, `y` is scalar, `dy_dt` is scalar.
-                               It should return the value of d²y/dt².
-                               Example for d²y/dt² = -0.1*(dy/dt) - y: lambda t, y, dy_dt: -0.1 * dy_dt - y
-        t_span: Tuple (t_start, t_end) for the integration interval.
-        y0: Initial value of y at t_start.
-        dy0_dt: Initial value of dy/dt at t_start.
-        t_eval_count: Number of points at which to store the computed solution.
-        method: Integration method to use.
-        **kwargs: Additional keyword arguments for `solve_ivp`.
-
-    Returns:
-        A dictionary containing:
-            't': NumPy array of time points.
-            'y': NumPy array of solution values y(t) at each time point.
-            'dy_dt': NumPy array of solution values dy/dt(t) at each time point.
-            'message': Solver message.
-            'success': Boolean indicating if the solver was successful.
-            'plot_path': Path to a saved plot of y(t) and dy/dt(t) (if successful), else None.
-    """
-    # Define the system of first-order ODEs
-    def system_func(t: float, z: np.ndarray) -> List[float]:
-        y_val, dy_dt_val = z[0], z[1]
-        d2y_dt2_val = ode_func_second_order(t, y_val, dy_dt_val)
-        return [dy_dt_val, d2y_dt2_val]
-
-    initial_conditions_system = [y0, dy0_dt]
-
-    try:
-        t_eval = np.linspace(t_span[0], t_span[1], t_eval_count)
-        sol = solve_ivp(system_func, t_span, initial_conditions_system, method=method, t_eval=t_eval, **kwargs)
-
-        plot_path = None
-        if sol.success:
-            try:
-                plt.figure(figsize=(12, 7))
-
-                plt.subplot(2,1,1)
-                plt.plot(sol.t, sol.y[0], label=f'y(t), y0={y0}')
-                plt.xlabel("Time (t)")
-                plt.ylabel("y(t)")
-                plt.title(f"Solution of Second-Order ODE: y(t) ({method})")
-                plt.legend()
-                plt.grid(True)
-
-                plt.subplot(2,1,2)
-                plt.plot(sol.t, sol.y[1], label=f'dy/dt(t), dy0/dt={dy0_dt}', color='orange')
-                plt.xlabel("Time (t)")
-                plt.ylabel("dy/dt(t)")
-                plt.title(f"Solution of Second-Order ODE: dy/dt(t) ({method})")
-                plt.legend()
-                plt.grid(True)
-
-                plt.tight_layout()
-                plot_path = "ode_second_order_solution_plot.png"
-                plt.savefig(plot_path)
-                plt.close()
-            except Exception as e_plot:
-                print(f"Warning: Could not generate plot: {e_plot}")
-                plot_path = None
-
-        return {
-            't': sol.t,
-            'y': sol.y[0],      # First component of the system's solution
-            'dy_dt': sol.y[1],  # Second component of the system's solution
-            'message': sol.message,
-            'success': sol.success,
-            'plot_path': plot_path
-        }
-    except Exception as e:
-        return {
-            't': np.array([]),
-            'y': np.array([]),
-            'dy_dt': np.array([]),
-            'message': f"Error during ODE solving: {str(e)}",
-            'success': False,
-            'plot_path': None
-        }
-
-# Example Usage (can be removed or commented out)
-if __name__ == '__main__':
-    # --- First-order ODE example: dy/dt = -y*t with y(0)=1 ---
-    def first_order_example(t, y):
-        return -y * t
-
-    print("Solving dy/dt = -y*t, y(0)=1 from t=0 to t=5")
-    solution1 = solve_first_order_ode(first_order_example, (0, 5), [1], t_eval_count=50)
-    if solution1['success']:
-        print(f"First-order ODE solved. Message: {solution1['message']}")
-        # print("t:", solution1['t'])
-        # print("y:", solution1['y'])
-        if solution1['plot_path']:
-            print(f"Plot saved to {solution1['plot_path']}")
-    else:
-        print(f"First-order ODE failed. Message: {solution1['message']}")
-
-    # --- First-order system example: Lotka-Volterra ---
-    # dy1/dt = a*y1 - b*y1*y2 (prey)
-    # dy2/dt = c*y1*y2 - d*y2 (predator)
-    a, b, c, d = 1.5, 0.8, 0.5, 0.9
-    def lotka_volterra(t, y):
-        prey, predator = y[0], y[1]
-        d_prey_dt = a * prey - b * prey * predator
-        d_predator_dt = c * prey * predator - d * predator
-        return [d_prey_dt, d_predator_dt]
-
-    print("\nSolving Lotka-Volterra system from t=0 to t=20 with y0=[10, 5]")
-    solution_lv = solve_first_order_ode(lotka_volterra, (0, 20), [10, 5], t_eval_count=200)
-    if solution_lv['success']:
-        print(f"Lotka-Volterra solved. Plot saved to {solution_lv['plot_path']}")
-    else:
-        print(f"Lotka-Volterra failed. Message: {solution_lv['message']}")
-
-
-    # --- Second-order ODE example: d²y/dt² = -sin(y) (simple pendulum) ---
-    # y is theta, dy/dt is omega. d²y/dt² = -g/L * sin(y)
-    g_L = 9.81 / 1.0 # Example: g/L = 9.81
-    def pendulum_ode(t, y_angle, dy_dt_angular_velocity):
-        return -g_L * np.sin(y_angle)
-
-    print("\nSolving d²y/dt² = -g/L*sin(y), y(0)=pi/4, dy/dt(0)=0 from t=0 to t=10")
-    solution2 = solve_second_order_ode(pendulum_ode, (0, 10), y0=np.pi/4, dy0_dt=0, t_eval_count=100)
-    if solution2['success']:
-        print(f"Second-order ODE solved. Message: {solution2['message']}")
-        # print("t:", solution2['t'])
-        # print("y:", solution2['y'])
-        # print("dy/dt:", solution2['dy_dt'])
-        if solution2['plot_path']:
-            print(f"Plot saved to {solution2['plot_path']}")
-    else:
-        print(f"Second-order ODE failed. Message: {solution2['message']}")

maths/differential_equations/differential_equations_interface.py

@@ -14,7 +14,8 @@ 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.differential_equations import solve_first_order_ode, solve_second_order_ode
+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
 
 # --- Helper Functions ---
 
@@ -46,7 +47,7 @@ def string_to_ode_func(lambda_str: str, expected_args: Tuple[str, ...]) -> Calla
     Includes a basic check for 'lambda' keyword and argument count.
 
     Args:
-        lambda_str: The string, e.g., "lambda t, y: -2*y" or "lambda t, y, dy_dt: -0.1*dy_dt -y".
+        lambda_str: The string, e.g., "lambda t, y: -y" or "lambda t, y, dy_dt: -0.1*dy_dt -y".
         expected_args: A tuple of expected argument names, e.g., ('t', 'y') or ('t', 'y', 'dy_dt').
 
     Returns:

maths/differential_equations/ode_examples.py

@@ -0,0 +1,49 @@
+"""
+Example usage for ODE solvers. Can be run as a script.
+"""
+import numpy as np
+from solve_first_order_ode import solve_first_order_ode
+from solve_second_order_ode import solve_second_order_ode
+
+if __name__ == '__main__':
+    # --- First-order ODE example: dy/dt = -y*t with y(0)=1 ---
+    def first_order_example(t, y):
+        return -y * t
+
+    print("Solving dy/dt = -y*t, y(0)=1 from t=0 to t=5")
+    solution1 = solve_first_order_ode(first_order_example, (0, 5), [1], t_eval_count=50)
+    if solution1['success']:
+        print(f"First-order ODE solved. Message: {solution1['message']}")
+        if solution1['plot_path']:
+            print(f"Plot saved to {solution1['plot_path']}")
+    else:
+        print(f"First-order ODE failed. Message: {solution1['message']}")
+
+    # --- First-order system example: Lotka-Volterra ---
+    a, b, c, d = 1.5, 0.8, 0.5, 0.9
+    def lotka_volterra(t, y):
+        prey, predator = y[0], y[1]
+        d_prey_dt = a * prey - b * prey * predator
+        d_predator_dt = c * prey * predator - d * predator
+        return [d_prey_dt, d_predator_dt]
+
+    print("\nSolving Lotka-Volterra system from t=0 to t=20 with y0=[10, 5]")
+    solution_lv = solve_first_order_ode(lotka_volterra, (0, 20), [10, 5], t_eval_count=200)
+    if solution_lv['success']:
+        print(f"Lotka-Volterra solved. Plot saved to {solution_lv['plot_path']}")
+    else:
+        print(f"Lotka-Volterra failed. Message: {solution_lv['message']}")
+
+    # --- Second-order ODE example: d²y/dt² = -sin(y) (simple pendulum) ---
+    g_L = 9.81 / 1.0 # Example: g/L = 9.81
+    def pendulum_ode(t, y_angle, dy_dt_angular_velocity):
+        return -g_L * np.sin(y_angle)
+
+    print("\nSolving d²y/dt² = -g/L*sin(y), y(0)=pi/4, dy/dt(0)=0 from t=0 to t=10")
+    solution2 = solve_second_order_ode(pendulum_ode, (0, 10), y0=np.pi/4, dy0_dt=0, t_eval_count=100)
+    if solution2['success']:
+        print(f"Second-order ODE solved. Message: {solution2['message']}")
+        if solution2['plot_path']:
+            print(f"Plot saved to {solution2['plot_path']}")
+    else:
+        print(f"Second-order ODE failed. Message: {solution2['message']}")

maths/differential_equations/solve_first_order_ode.py

@@ -0,0 +1,62 @@
+"""
+Solves a first-order ordinary differential equation (or system of first-order ODEs)
+dy/dt = f(t, y) with initial condition y(t0) = y0.
+"""
+import numpy as np
+from scipy.integrate import solve_ivp
+from typing import Callable, List, Tuple, Dict, Any, Union
+import matplotlib.pyplot as plt
+
+ODEFunc = Callable[[float, Union[np.ndarray, List[float]]], Union[np.ndarray, List[float]]]
+
+def solve_first_order_ode(
+    ode_func: ODEFunc,
+    t_span: Tuple[float, float],
+    y0: List[float],
+    t_eval_count: int = 100,
+    method: str = 'RK45',
+    **kwargs: Any
+) -> Dict[str, Union[np.ndarray, str, bool]]:
+    # ...existing code...
+    try:
+        y0_np = np.array(y0, dtype=float)
+        t_eval = np.linspace(t_span[0], t_span[1], t_eval_count)
+
+        sol = solve_ivp(ode_func, t_span, y0_np, method=method, t_eval=t_eval, **kwargs)
+
+        plot_path = None
+        if sol.success:
+            try:
+                plt.figure(figsize=(10, 6))
+                if y0_np.ndim == 0 or len(y0_np) == 1 : # Single equation
+                    plt.plot(sol.t, sol.y[0], label=f'y(t), y0={y0_np[0] if y0_np.ndim > 0 else y0_np}')
+                else: # System of equations
+                    for i in range(sol.y.shape[0]):
+                        plt.plot(sol.t, sol.y[i], label=f'y_{i+1}(t), y0_{i+1}={y0_np[i]}')
+                plt.xlabel("Time (t)")
+                plt.ylabel("Solution y(t)")
+                plt.title(f"Solution of First-Order ODE ({method})")
+                plt.legend()
+                plt.grid(True)
+                plot_path = "ode_solution_plot.png"
+                plt.savefig(plot_path)
+                plt.close() # Close the plot to free memory
+            except Exception as e_plot:
+                print(f"Warning: Could not generate plot: {e_plot}")
+                plot_path = None
+
+        return {
+            't': sol.t,
+            'y': sol.y,
+            'message': sol.message,
+            'success': sol.success,
+            'plot_path': plot_path
+        }
+    except Exception as e:
+        return {
+            't': np.array([]),
+            'y': np.array([]),
+            'message': f"Error during ODE solving: {str(e)}",
+            'success': False,
+            'plot_path': None
+        }

maths/differential_equations/solve_second_order_ode.py

@@ -0,0 +1,76 @@
+"""
+Solves a single second-order ordinary differential equation of the form
+d²y/dt² = f(t, y, dy/dt) with initial conditions y(t0)=y0 and dy/dt(t0)=dy0_dt.
+"""
+import numpy as np
+from scipy.integrate import solve_ivp
+from typing import Callable, List, Tuple, Dict, Any, Union
+import matplotlib.pyplot as plt
+
+def solve_second_order_ode(
+    ode_func_second_order: Callable[[float, float, float], float],
+    t_span: Tuple[float, float],
+    y0: float,
+    dy0_dt: float,
+    t_eval_count: int = 100,
+    method: str = 'RK45',
+    **kwargs: Any
+) -> Dict[str, Union[np.ndarray, str, bool]]:
+    # ...existing code...
+    def system_func(t: float, z: np.ndarray) -> List[float]:
+        y_val, dy_dt_val = z[0], z[1]
+        d2y_dt2_val = ode_func_second_order(t, y_val, dy_dt_val)
+        return [dy_dt_val, d2y_dt2_val]
+
+    initial_conditions_system = [y0, dy0_dt]
+
+    try:
+        t_eval = np.linspace(t_span[0], t_span[1], t_eval_count)
+        sol = solve_ivp(system_func, t_span, initial_conditions_system, method=method, t_eval=t_eval, **kwargs)
+
+        plot_path = None
+        if sol.success:
+            try:
+                plt.figure(figsize=(12, 7))
+
+                plt.subplot(2,1,1)
+                plt.plot(sol.t, sol.y[0], label=f'y(t), y0={y0}')
+                plt.xlabel("Time (t)")
+                plt.ylabel("y(t)")
+                plt.title(f"Solution of Second-Order ODE: y(t) ({method})")
+                plt.legend()
+                plt.grid(True)
+
+                plt.subplot(2,1,2)
+                plt.plot(sol.t, sol.y[1], label=f'dy/dt(t), dy0/dt={dy0_dt}', color='orange')
+                plt.xlabel("Time (t)")
+                plt.ylabel("dy/dt(t)")
+                plt.title(f"Solution of Second-Order ODE: dy/dt(t) ({method})")
+                plt.legend()
+                plt.grid(True)
+
+                plt.tight_layout()
+                plot_path = "ode_second_order_solution_plot.png"
+                plt.savefig(plot_path)
+                plt.close()
+            except Exception as e_plot:
+                print(f"Warning: Could not generate plot: {e_plot}")
+                plot_path = None
+
+        return {
+            't': sol.t,
+            'y': sol.y[0],      # First component of the system's solution
+            'dy_dt': sol.y[1],  # Second component of the system's solution
+            'message': sol.message,
+            'success': sol.success,
+            'plot_path': plot_path
+        }
+    except Exception as e:
+        return {
+            't': np.array([]),
+            'y': np.array([]),
+            'dy_dt': np.array([]),
+            'message': f"Error during ODE solving: {str(e)}",
+            'success': False,
+            'plot_path': None
+        }