Struct SDEProblem

pub struct SDEProblem<T, V, D, F>
where
    T: Real,
    V: State<T>,
    D: CallBackData,
    F: SDE<T, V, D>,
{
    pub sde: F,
    pub t0: T,
    pub tf: T,
    pub y0: V,
    /* private fields */
}

Initial Value Problem for Stochastic Differential Equations (SDEProblem)

The Initial Value Problem takes the form: dY = a(t, Y)dt + b(t, Y)dW, t0 <= t <= tf, Y(t0) = y0

where:

• a(t, Y) is the drift term (deterministic part)
• b(t, Y) is the diffusion term (stochastic part)
• dW represents a Wiener process increment

Overview

The SDEProblem struct provides a simple interface for solving stochastic differential equations:

Example

use differential_equations::prelude::*;
use nalgebra::SVector;
use rand::SeedableRng;
use rand_distr::{Distribution, Normal};

struct GBM {
    rng: rand::rngs::StdRng,
}

impl GBM {
    fn new(seed: u64) -> Self {
        Self {
            rng: rand::rngs::StdRng::seed_from_u64(seed),
        }
    }
}

impl SDE<f64, SVector<f64, 1>> for GBM {
    fn drift(&self, _t: f64, y: &SVector<f64, 1>, dydt: &mut SVector<f64, 1>) {
        dydt[0] = 0.1 * y[0]; // μS
    }
     
    fn diffusion(&self, _t: f64, y: &SVector<f64, 1>, dydw: &mut SVector<f64, 1>) {
        dydw[0] = 0.2 * y[0]; // σS
    }
     
    fn noise(&mut self, dt: f64, dw: &mut SVector<f64, 1>) {
        let normal = Normal::new(0.0, dt.sqrt()).unwrap();
        dw[0] = normal.sample(&mut self.rng);
    }
}

let t0 = 0.0;
let tf = 1.0;
let y0 = SVector::<f64, 1>::new(100.0);
let mut solver = ExplicitRungeKutta::three_eighths(0.01);
let gbm = GBM::new(42);
let mut gbm_problem = SDEProblem::new(gbm, t0, tf, y0);

// Solve the SDE
let result = gbm_problem.solve(&mut solver);

Fields

• sde - SDE implementing the stochastic differential equation
• t0 - Initial time
• tf - Final time
• y0 - Initial state vector

Basic Usage

• new(sde, t0, tf, y0) - Create a new SDE Problem
• solve(&mut solver) - Solve using default output (solver step points)

Output Control Methods

These methods configure how solution points are generated and returned:

• even(dt) - Generate evenly spaced output points with interval dt
• dense(n) - Include n interpolated points between each solver step
• t_eval(points) - Evaluate solution at specific time points
• solout(custom_solout) - Use a custom output handler
• seed(u64) - Set a specific random seed for reproducible simulations

Fields

sde: F

t0: T

tf: T

y0: V

Implementations

impl<T, V, D, F> SDEProblem<T, V, D, F>

where T: Real, V: State<T>, D: CallBackData, F: SDE<T, V, D>,

pub fn new(sde: F, t0: T, tf: T, y0: V) -> Self

Create a new Stochastic Differential Equation Problem

Arguments

• sde - SDE containing the Stochastic Differential Equation and Optional Terminate Function
• t0 - Initial Time
• tf - Final Time
• y0 - Initial State Vector

Returns

• SDE Problem ready to be solved

pub fn solve<S>( &mut self, solver: &mut S, ) -> Result<Solution<T, V, D>, Error<T, V>>

where S: StochasticNumericalMethod<T, V, D> + Interpolation<T, V>,

Solve the SDE Problem using a default solout, e.g. outputting solutions at calculated steps

Returns

• Result<Solution<T, V, D>, Error<T, V>> - Ok(Solution) if successful or interrupted by events, Err(Error) if errors or issues are encountered

pub fn solout<'a, O: Solout<T, V, D>>( &'a mut self, solout: &'a mut O, ) -> SDEProblemMutRefSoloutPair<'a, T, V, D, F, O>

Returns an SDE Problem with the provided solout function for outputting points

Returns

• SDE Problem with the provided solout function ready for .solve() method

pub fn even( &mut self, dt: T, ) -> SDEProblemSoloutPair<'_, T, V, D, F, EvenSolout<T>>

Uses the an Even Solout implementation to output evenly spaced points between the initial and final time Note that this does not include the solution of the calculated steps

Arguments

• dt - Interval between each output point

Returns

• SDE Problem with Even Solout function ready for .solve() method

pub fn dense( &mut self, n: usize, ) -> SDEProblemSoloutPair<'_, T, V, D, F, DenseSolout>

Uses the Dense Output method to output n number of interpolation points between each step Note this includes the solution of the calculated steps

Arguments

• n - Number of interpolation points between each step

Returns

• SDE Problem with Dense Output function ready for .solve() method

pub fn t_eval( &mut self, points: Vec<T>, ) -> SDEProblemSoloutPair<'_, T, V, D, F, TEvalSolout<T>>

Uses the provided time points for evaluation instead of the default method Note this does not include the solution of the calculated steps

Arguments

• points - Custom output points

Returns

• SDE Problem with Custom Time Evaluation function ready for .solve() method

pub fn crossing( &mut self, component_idx: usize, threshold: T, direction: CrossingDirection, ) -> SDEProblemSoloutPair<'_, T, V, D, F, CrossingSolout<T>>

Uses the CrossingSolout method to output points when a specific component crosses a threshold Note this does not include the solution of the calculated steps

Arguments

• component_idx - Index of the component to monitor for crossing
• threshold - Value to cross
• direction - Direction of crossing (positive or negative)

Returns

• SDE Problem with CrossingSolout function ready for .solve() method

pub fn hyperplane_crossing<V1>( &mut self, point: V1, normal: V1, extractor: fn(&V) -> V1, direction: CrossingDirection, ) -> SDEProblemSoloutPair<'_, T, V, D, F, HyperplaneCrossingSolout<T, V1, V>>

where V1: State<T>,

Uses the HyperplaneCrossingSolout method to output points when a specific hyperplane is crossed Note this does not include the solution of the calculated steps

Arguments

• point - Point on the hyperplane
• normal - Normal vector of the hyperplane
• extractor - Function to extract the component from the state vector
• direction - Direction of crossing (positive or negative)

Returns

• SDE Problem with HyperplaneCrossingSolout function ready for .solve() method

Trait Implementations

impl<T, V, D, F> Clone for SDEProblem<T, V, D, F>

where T: Real + Clone, V: State<T> + Clone, D: CallBackData + Clone, F: SDE<T, V, D> + Clone,

fn clone(&self) -> SDEProblem<T, V, D, F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, V, D, F> Debug for SDEProblem<T, V, D, F>

where T: Real + Debug, V: State<T> + Debug, D: CallBackData + Debug, F: SDE<T, V, D> + Debug,

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

Formats the value using the given formatter.