Struct BatesProcess 

pub struct BatesProcess {
    pub lambda: f64,
    pub mu_jump: f64,
    pub sigma_jump: f64,
    /* private fields */
}

Bates model: Heston stochastic volatility + Merton jump diffusion.

Same as Heston, but with compound Poisson jumps on the price.

Fields

lambda: f64

mu_jump: f64

sigma_jump: f64

Implementations

impl BatesProcess

pub fn new( mu: f64, kappa: f64, theta: f64, sigma: f64, rho: f64, lambda: f64, mu_jump: f64, sigma_jump: f64, initial_price: f64, initial_variance: f64, ) -> Self

pub fn price(&self) -> f64

pub fn volatility(&self) -> f64

pub fn mu(&self) -> f64

pub fn kappa(&self) -> f64

pub fn theta(&self) -> f64

pub fn sigma(&self) -> f64

pub fn rho(&self) -> f64

Trait Implementations

impl Clone for BatesProcess

fn clone(&self) -> BatesProcess

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Simulatable for BatesProcess

type Output = (f64, f64)

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) -> (f64, f64)

Advance the model by one step of size dt.

fn current(&self) -> (f64, f64)

The current state snapshot. Called once before simulation starts.

impl StochasticProcess for BatesProcess

type State = ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>

type Diffusion = ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>

type BrownianIncrement = ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>

fn drift(&self, x: &Array1<f64>, t: f64) -> Array1<f64>

fn diffusion(&self, x: &Array1<f64>, t: f64) -> Array2<f64>

fn jump_intensity(&self, _x: &Array1<f64>, _t: f64) -> f64

fn jump_size<R: Rng + ?Sized>( &self, x: &Array1<f64>, _t: f64, rng: &mut R, ) -> Array1<f64>

fn expected_value(&self, x0: &Array1<f64>, t: f64) -> Array1<f64>

fn variance(&self, x0: &Array1<f64>, t: f64) -> Array1<f64>

fn step<R: Rng + ?Sized>( &self, x: &Array1<f64>, t: f64, dt: f64, dw: &Array1<f64>, rng: &mut R, ) -> Array1<f64>

fn generate_increment<R: Rng + ?Sized>( &self, rng: &mut R, dt: f64, ) -> Array1<f64>

fn simulate<R: Rng + ?Sized>( &self, x0: Array1<f64>, t0: f64, t_end: f64, dt: f64, rng: &mut R, ) -> Vec<(f64, Array1<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,