Struct AvellanedaHawkes 

pub struct AvellanedaHawkes {
    pub gamma: f64,
    pub sigma: f64,
    pub kappa: f64,
    pub alpha: f64,
    pub beta: f64,
    pub mu: f64,
    pub lambda_step: f64,
    pub dq: f64,
    pub terminal_condition: TerminalCondition,
    pub q_min: f64,
    pub q_max: f64,
    pub terminal_liquidation_half_spread: Option<f64>,
}

Avellaneda-Stoikov model with Hawkes Process for order arrival intensity.

State Space: [Inventory (q), Intensity (lambda)]

• q: Discrete inventory level
• lambda: Continuous order arrival intensity

Dynamics:

• q: Jumps ±1 upon fills.
• lambda: Mean-reverting jump-diffusion (approximated). d(lambda) = beta * (mu - lambda) * dt + alpha * dN_market where N_market is the market order counting process with intensity lambda.

The solver uses a grid-based approach. We approximate the Hawkes dynamics on the lambda dimension using an upwind finite difference scheme mapped to the solver’s jump interface.

Fields

gamma: f64

sigma: f64

kappa: f64

alpha: f64

beta: f64

mu: f64

lambda_step: f64

dq: f64

Grid step size for inventory dimension (set from grid.dx[0] for FD).

terminal_condition: TerminalCondition

Terminal condition V(T, q, lambda). Defaults to Zero.

q_min: f64

Minimum inventory (lower hard boundary). Defaults to -infinity (no constraint).

q_max: f64

Maximum inventory (upper hard boundary). Defaults to +infinity (no constraint).

terminal_liquidation_half_spread: Option<f64>

Optional terminal liquidation half-spread used when terminal_condition is LiquidationCost. If None, uses the AS base spread.

Implementations

impl AvellanedaHawkes

pub fn new( gamma: f64, sigma: f64, kappa: f64, alpha: f64, beta: f64, mu: f64, ) -> Self

pub fn with_terminal_liquidation_half_spread(self, half_spread: f64) -> Self

pub fn with_inventory_bounds(self, q_min: f64, q_max: f64) -> Self

pub fn with_terminal_condition( self, terminal_condition: TerminalCondition, ) -> Self

pub fn with_lambda_step(self, lambda_step: f64) -> Self

pub fn with_dq(self, dq: f64) -> Self

pub fn get_spreads(&self, _lambda: f64, grads: &Gradients<2>) -> (f64, f64)

Computes optimal spreads based on current inventory and intensity. Note: The base intensity ‘A’ from standard Avellaneda is replaced by the state variable ‘lambda’.

Trait Implementations

impl Clone for AvellanedaHawkes

fn clone(&self) -> AvellanedaHawkes

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Model<2> for AvellanedaHawkes

fn fill_rate_base(&self, state: &[f64; 2]) -> f64

The base arrival intensity is state-dependent: returns the current intensity state[1] (clamped above 0) for intensity-to-spread conversion.

type Process = ()

The underlying stochastic process driving the continuous state dimensions. Set to () for models without a corresponding market_model process.

fn process(&self)

Returns the underlying stochastic process, if any.

fn optimize(&self, state: &[f64; 2], grads: &Gradients<2>) -> ControlOutput<2>

Given the current state and value function gradients ($\nabla V$), computations the optimal controls.

fn terminal(&self, state: &[f64; 2]) -> f64

Computes the terminal value function $V(T, x)$ (Final Condition). Usually represents liquidation cost or final utility of wealth.

fn constant_discount_rate(&self) -> Option<f64>

Optimization hint: Returns Some(r) if the discount rate is constant across all states. Returns None if it depends on state. Default implementation returns None (safe fallback).

fn next_step( &self, current_state: &[f64; 2], dt: f64, noise: &[f64; 2], ) -> [f64; 2]

Simulates the next state for BSDE exploration. Default implementation is a simple random walk: x’ = x + sqrt(dt) * noise

fn next_step_controlled( &self, current_state: &[f64; 2], control: &ControlOutput<2>, dt: f64, noise: &[f64; 2], ) -> [f64; 2]

Simulates the next state for Coupled FBSDE exploration where dynamics depend on control. Default implementation falls back to next_step (Decoupled).

fn is_diffusion_dimension(&self, _dim: usize) -> bool

Indicates if a dimension is driven by Brownian diffusion. If true, the BSDE backward step will skip the lambda_plus/minus drift term for this dimension (it is already handled by the forward simulation noise).

fn is_integer_dimension(&self, dim: usize) -> bool

Indicates if a dimension takes only integer values (e.g. inventory q). Controls BSDE initialization: integer dimensions are sampled discretely while continuous dimensions (even if non-diffusion) are sampled with uniform noise. Default: false (continuous).

fn gradient_step(&self, dim: usize) -> f64

Physical finite-difference step for each state dimension used by BSDE gradient stencils.

fn fill_rate_decay(&self) -> f64

Order fill decay parameter $\kappa$ used for intensity-to-spread conversion. Defaults to 1.0 for non-market-making models. Override in market-making models.

fn discount_rate(&self, _state: &[f64; N]) -> f64

Optional discount rate at the given state. Default implementation returns 0.0.

fn apply_constraint(&self, _state: &[f64; N], value: f64) -> f64

Optional constraint application (e.g. for American options) Default implementation does nothing.

fn transform_noise(&self, _state: &[f64; N], noise: &[f64; N]) -> [f64; N]

Optional transform for standard normal samples before forward stepping.