Struct ODESolver 

pub struct ODESolver { /* private fields */ }

Automatic ODE solver with intelligent routing

Implementations

impl ODESolver

pub fn new() -> Self

Create a new ODE solver with default configuration

pub fn with_config(config: SolverConfig) -> Self

Create an ODE solver with custom configuration

pub fn tolerance(self, tol: f64) -> Self

Set numerical tolerance (builder pattern)

Examples

use mathhook_core::calculus::ode::solver::ODESolver;

let solver = ODESolver::new()
    .tolerance(1e-12);

pub fn max_iterations(self, max: usize) -> Self

Set maximum iterations for numerical methods (builder pattern)

Examples

use mathhook_core::calculus::ode::solver::ODESolver;

let solver = ODESolver::new()
    .max_iterations(5000);

pub fn simplify(self, enable: bool) -> Self

Enable or disable automatic simplification (builder pattern)

Examples

use mathhook_core::calculus::ode::solver::ODESolver;

let solver = ODESolver::new()
    .simplify(false);  // Disable simplification

pub fn educational(self, enable: bool) -> Self

Enable or disable educational mode (builder pattern)

Educational mode provides step-by-step explanations

Examples

use mathhook_core::calculus::ode::solver::ODESolver;

let solver = ODESolver::new()
    .educational(true);

pub fn config(&self) -> &SolverConfig

Get current solver configuration

pub fn solve_first_order( &self, rhs: &Expression, dependent: &Symbol, independent: &Symbol, ) -> ODEResult

Solve a first-order ODE automatically

Automatically classifies the ODE and routes to the appropriate solver via registry. Attempts multiple methods in priority order if the primary method fails.

Arguments

• rhs - Right-hand side of dy/dx = rhs
• dependent - Dependent variable (y)
• independent - Independent variable (x)

Returns

Returns solution expression on success

Examples

use mathhook_core::calculus::ode::solver::ODESolver;
use mathhook_core::{symbol, expr};

let x = symbol!(x);
let y = symbol!(y);
let rhs = expr!(x * y);

let solver = ODESolver::new();
let solution = solver.solve_first_order(&rhs, &y, &x).unwrap();
assert!(solution.to_string().contains("exp") || solution.to_string().contains("C"));

pub fn solve_ivp( &self, rhs: &Expression, dependent: &Symbol, independent: &Symbol, x0: Expression, y0: Expression, ) -> ODEResult

Solve a first-order initial value problem

Convenience method for solving with initial condition

Arguments

• rhs - Right-hand side of dy/dx = rhs
• dependent - Dependent variable (y)
• independent - Independent variable (x)
• x0 - Initial x value
• y0 - Initial y value

Examples

use mathhook_core::calculus::ode::solver::ODESolver;
use mathhook_core::{symbol, expr};

let x = symbol!(x);
let y = symbol!(y);
let rhs = expr!(x);

let solver = ODESolver::new();
let solution = solver.solve_ivp(&rhs, &y, &x, expr!(0), expr!(1));
// Returns particular solution with y(0) = 1

pub fn solve_second_order( &self, a: &Expression, b: &Expression, c: &Expression, r: &Expression, dependent: &Symbol, independent: &Symbol, ) -> ODEResult

Solve a second-order ODE automatically

Currently supports constant coefficient equations.

Arguments

• a - Coefficient of y’’
• b - Coefficient of y’
• c - Coefficient of y
• r - Right-hand side (forcing function)
• dependent - Dependent variable (y)
• independent - Independent variable (x)

Examples

use mathhook_core::calculus::ode::solver::ODESolver;
use mathhook_core::{symbol, expr};

let x = symbol!(x);
let y = symbol!(y);

let solver = ODESolver::new();
let solution = solver.solve_second_order(
    &expr!(1),
    &expr!(0),
    &expr!(-1),
    &expr!(0),
    &y,
    &x
).unwrap();

assert!(solution.to_string().contains("exp") || solution.to_string().contains("sinh") || solution.to_string().contains("cosh"));

Trait Implementations

impl Default for ODESolver

fn default() -> Self

Returns the “default value” for a type.