Struct EM

pub struct EM<T: Real, V: State<T>, D: CallBackData> {
    pub h: T,
    /* private fields */
}

Euler-Maruyama Method for solving stochastic differential equations.

The Euler-Maruyama method is the simplest numerical method for SDEs, essentially extending Euler’s method to stochastic equations.

For an SDE of the form: dY = a(t,Y)dt + b(t,Y)dW

The Euler-Maruyama update is: Y_{n+1} = Y_n + a(t_n, Y_n)Δt + b(t_n, Y_n)ΔW_n

where ΔW_n is a Wiener process increment, produced by the SDE’s noise method.

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(&self, dt: f64, dw: &mut SVector<f64, 1>) {
        let normal = Normal::new(0.0, dt.sqrt()).unwrap();
        dw[0] = normal.sample(&mut self.rng.clone());
    }
}

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

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

Fields

h: T

Implementations

impl<T: Real, V: State<T>, D: CallBackData> EM<T, V, D>

pub fn new(h: T) -> Self

Create a new Euler-Maruyama solver with the specified step size

Arguments

• h - Step size

Returns

• A new solver instance

Trait Implementations

impl<T: Real, V: State<T>, D: CallBackData> Default for EM<T, V, D>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Real, V: State<T>, D: CallBackData> Interpolation<T, V> for EM<T, V, D>

fn interpolate(&mut self, t_interp: T) -> Result<V, Error<T, V>>

Interpolate between previous and current step

impl<T: Real, V: State<T>, D: CallBackData> SDENumericalMethod<T, V, D> for EM<T, V, D>

fn init<F>( &mut self, sde: &F, t0: T, tf: T, y0: &V, ) -> Result<Evals, Error<T, V>>

where F: SDE<T, V, D>,

Initialize SDENumericalMethod before solving SDE

fn step<F>(&mut self, sde: &F) -> Result<Evals, Error<T, V>>

where F: SDE<T, V, D>,

Step through solving the SDE by one step

fn t(&self) -> T

Access time of last accepted step

fn y(&self) -> &V

Access solution of last accepted step

fn t_prev(&self) -> T

Access time of previous accepted step

fn y_prev(&self) -> &V

Access solution of previous accepted step

fn h(&self) -> T

Access step size of next step

fn set_h(&mut self, h: T)

Set step size of next step

fn status(&self) -> &Status<T, V, D>

Status of solver

fn set_status(&mut self, status: Status<T, V, D>)

Set status of solver