Struct HawkesProcess 

pub struct HawkesProcess<K: Kernel> {
    pub mu: f64,
    pub kernel: K,
    /* private fields */
}

Hawkes process with arbitrary kernel.

Simulated via Ogata’s thinning algorithm. For exponential kernels, intensity is maintained O(1) via the recursion I(t+dt) = mu + (I(t) - mu) * exp(-beta*dt) + alpha * new_jumps. For non-exponential kernels, intensity is computed by summing over all historical jumps (O(n)).

Fields

mu: f64

kernel: K

Implementations

impl<K: Kernel> HawkesProcess<K>

pub fn new(mu: f64, kernel: K) -> Self

pub fn value(&self) -> f64

impl<K: Kernel + 'static> HawkesProcess<K>

Simulate the Hawkes process and return the intensity path on a grid.

pub fn simulate_intensity(&self, total_time: f64, n_steps: usize) -> Vec<f64>

Trait Implementations

impl<K: Clone + Kernel> Clone for HawkesProcess<K>

fn clone(&self) -> HawkesProcess<K>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: Kernel + 'static> Simulatable for HawkesProcess<K>

type Output = 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

Advance the model by one step of size dt.

fn current(&self) -> f64

The current state snapshot. Called once before simulation starts.

impl<K: Kernel + 'static> StochasticProcess for HawkesProcess<K>

type State = f64

type Diffusion = f64

type BrownianIncrement = f64

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

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

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

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

fn expected_value(&self, x0: &f64, _t: f64) -> f64

fn variance(&self, _x0: &f64, _t: f64) -> f64

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

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

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