Struct RoughOrnsteinUhlenbeck 

pub struct RoughOrnsteinUhlenbeck {
    pub kappa: f64,
    pub theta: f64,
    pub sigma: f64,
    pub hurst: f64,
    /* private fields */
}

Rough Ornstein-Uhlenbeck process with Hurst parameter H.

The fractional kernel K(t) = t^{H-1/2} / Gamma(H+1/2) is approximated by a sum of exponentials via n_factors factors.

Fields

kappa: f64

theta: f64

sigma: f64

hurst: f64

Implementations

impl RoughOrnsteinUhlenbeck

pub fn new( kappa: f64, theta: f64, sigma: f64, hurst: f64, n_factors: usize, initial_value: f64, ) -> Self

pub fn value(&self) -> f64

pub fn expected_value(&self, t: f64) -> f64

Closed-form expected value.

Trait Implementations

impl Clone for RoughOrnsteinUhlenbeck

fn clone(&self) -> RoughOrnsteinUhlenbeck

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Simulatable for RoughOrnsteinUhlenbeck

type Output = RoughOUState

The type emitted at each step (e.g. f64 for GBM, BookSnapshot for L3).

fn dim(&self) -> usize

Dimensionality of the Brownian driver. Used by the runner to pre-generate the correct number of random normals per step. GBM is 1, Heston is 2, etc.

fn step(&mut self, dt: f64, dw: &[f64], _rng: &mut impl Rng) -> Self::Output

Advance the model by one step of size dt.

fn current(&self) -> RoughOUState

The current state snapshot. Called once before simulation starts.

impl StochasticProcess for RoughOrnsteinUhlenbeck

type State = RoughOUState

type Diffusion = f64

type BrownianIncrement = f64

fn drift(&self, x: &Self::State, _t: f64) -> Self::State

fn diffusion(&self, _x: &Self::State, _t: f64) -> Self::Diffusion

fn jump_size<R: Rng + ?Sized>( &self, _x: &Self::State, _t: f64, _rng: &mut R, ) -> Self::State

fn expected_value(&self, x0: &Self::State, t: f64) -> Self::State

fn variance(&self, _x0: &Self::State, t: f64) -> Self::State

fn step<R: Rng + ?Sized>( &self, x: &Self::State, _t: f64, dt: f64, dw: &Self::BrownianIncrement, _rng: &mut R, ) -> Self::State

fn generate_increment<R: Rng + ?Sized>( &self, rng: &mut R, _dt: f64, ) -> Self::BrownianIncrement

fn simulate<R: Rng + ?Sized>( &self, x0: Self::State, t0: f64, t_end: f64, dt: f64, rng: &mut R, ) -> Vec<(f64, Self::State)>

fn jump_intensity(&self, _x: &Self::State, _t: f64) -> f64

fn simulate_paths( &self, x0: Self::State, t0: f64, t_end: f64, dt: f64, num_paths: usize, ) -> Vec<Vec<(f64, Self::State)>>

where Self: Sync, Self::State: Send + Sync + Clone,