Struct ODE 

pub struct ODE {
    pub state_vars: Vec<ExprId>,
    pub derivatives: Vec<ExprId>,
    pub rhs: Vec<ExprId>,
    pub time_var: ExprId,
    pub initial_conditions: Vec<(ExprId, ExprId)>,
}

A first-order ODE system dy_i/dt = rhs_i(t, y).

Invariants:

• state_vars.len() == derivatives.len() == rhs.len()
• derivatives[i] is a Symbol representing d(state_vars[i])/dt
• All expressions live in the same pool

Fields

state_vars: Vec<ExprId>

State variables y_0, y_1, …

derivatives: Vec<ExprId>

Derivative symbols dy_0/dt, dy_1/dt, …

rhs: Vec<ExprId>

Right-hand-side expressions f_i(t, y)

time_var: ExprId

The independent variable (usually t)

initial_conditions: Vec<(ExprId, ExprId)>

Initial conditions: (var, value) pairs

Implementations

impl ODE

pub fn new( state_vars: Vec<ExprId>, rhs: Vec<ExprId>, time_var: ExprId, pool: &ExprPool, ) -> Result<Self, OdeError>

Construct a first-order system directly.

state_vars — the state y_i rhs — the right-hand sides f_i(t, y) time_var — the independent variable t

Derivative symbols d(y_i)/dt are created automatically with the naming convention d{name}/dt.

pub fn with_ic(self, var: ExprId, value: ExprId) -> Self

Add an initial condition var = value.

pub fn order(&self) -> usize

Number of state variables.

pub fn is_autonomous(&self, pool: &ExprPool) -> bool

Return true if t does not appear in any RHS expression.

pub fn simplify_rhs(&self, pool: &ExprPool) -> ODE

Simplify all RHS expressions in place.

pub fn display(&self, pool: &ExprPool) -> String

Display the system as a sequence of equations.

Trait Implementations

impl Clone for ODE

fn clone(&self) -> ODE

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ODE

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.