Struct diffeq::ode::problem::OdeProblem

pub struct OdeProblem<F, Y> where
    F: Fn(f64, &Y) -> Y,
    Y: OdeType,  { /* fields omitted */ }

F: the RHS of the ODE dy/dt = F(t,y), which is a function of t and y(t) and returns dy/dt. y0: initial value for y. The type of y0, promoted as necessary according to the numeric type used for the times, determines the element type of the yout vector (yout::Vector{typeof(y0*one(t))}) tspan: Any iterable of sorted t values at which the solution (y) is requested. Most solvers will only consider tspan[0] and tspan[end], and intermediary points will be interpolated. If tspan[0] > tspan[end] the integration is performed backwards. The times are promoted as necessary to a common floating-point type.

Methods

impl<F, Y, T> OdeProblem<F, Y> where
    F: Fn(f64, &Y) -> Y,
    T: RealField + Add<f64, Output = T> + Mul<f64, Output = T> + Into<f64>,
    Y: OdeType<Item = T>, 

pub fn builder() -> OdeBuilder<F, Y>

convenience method to create a new builder same as OdeBuilder::default()

pub fn solve(
    self,
    ode: Ode,
    opts: OdeOptionMap
) -> Result<OdeSolution<f64, Y>, OdeError>

pub fn feuler(self) -> OdeSolution<f64, Y>

Solve the problem using the Feuler Butchertableau.

pub fn heun(self) -> OdeSolution<f64, Y>

Solve the problem using the Heun Butchertableau.

pub fn midpoint(self) -> OdeSolution<f64, Y>

Solve the problem using the Mindpoint method.

pub fn ode21(&self, opts: OdeOptionMap) -> Result<OdeSolution<f64, Y>, OdeError>

pub fn ode23(&self, opts: OdeOptionMap) -> Result<OdeSolution<f64, Y>, OdeError>

pub fn ode4(self) -> OdeSolution<f64, Y>

pub fn ode45(&self, opts: OdeOptionMap) -> Result<OdeSolution<f64, Y>, OdeError>

pub fn ode45_dp(
    &self,
    opts: OdeOptionMap
) -> Result<OdeSolution<f64, Y>, OdeError>

pub fn ode45_fe(
    &self,
    opts: OdeOptionMap
) -> Result<OdeSolution<f64, Y>, OdeError>

pub fn ode78(&self, opts: OdeOptionMap) -> Result<OdeSolution<f64, Y>, OdeError>

pub fn ode23s<Ops: Into<AdaptiveOptions>>(
    &self,
    opts: Ops
) -> Result<OdeSolution<f64, Y>, OdeError>

Solve stiff systems based on a modified Rosenbrock triple

pub fn oderosenbrock<S: Dim>(
    &self,
    coeffs: RosenbrockCoeffs<S>
) -> Result<OdeSolution<f64, Y>, OdeError> where
    DefaultAllocator: Allocator<f64, S, S> + Allocator<f64, S>, 

Solve stiff differential equations, Rosenbrock method with provided coefficients.

pub fn ode4s_kr(&self) -> Result<OdeSolution<f64, Y>, OdeError>

Solve the problem using the Kaps-Rentrop coefficients.

pub fn ode4s_s(&self) -> Result<OdeSolution<f64, Y>, OdeError>

Solve the problem using the Shampine coefficients.

pub fn calc_coefficients<S: Dim>(
    &self,
    btab: &ButcherTableau<S>,
    t: f64,
    init: CoefficientPoint<Y>,
    dt: f64
) -> CoefficientMap<Y> where
    DefaultAllocator: Allocator<f64, U1, S> + Allocator<f64, S, U2> + Allocator<f64, S, S> + Allocator<f64, S>, 

Calculates all coefficients values for a given value yn at a specific time t.

Creates an CoefficientMap with the calculated coefficient k and their approximations y of size S, the number of stages of the butcher tableau

pub fn fdjacobian(&self, t: f64, x: &Y) -> DMatrix<T>

Crude forward finite differences estimator of Jacobian as fallback returns a NxN Matrix where N is the degree of freedom of the OdeType y

Trait Implementations

impl<F: Clone, Y: Clone> Clone for OdeProblem<F, Y> where
    F: Fn(f64, &Y) -> Y,
    Y: OdeType, 

fn clone(&self) -> OdeProblem<F, Y>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F: Debug, Y: Debug> Debug for OdeProblem<F, Y> where
    F: Fn(f64, &Y) -> Y,
    Y: OdeType, 

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

Formats the value using the given formatter.