Struct BilateralHawkes 

pub struct BilateralHawkes {
    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 q_min: f64,
    pub q_max: f64,
    pub terminal_condition: TerminalCondition,
    pub terminal_liquidation_half_spread: Option<f64>,
}

Avellaneda-Stoikov model with a bilateral (2-D) Hawkes process.

State Space [q, lambda_plus, lambda_minus]

dim	symbol	description
0	q	Inventory level (integer, jump-controlled)
1	lambda+	Buy market-order intensity (ODE drift, no noise)
2	lambda-	Sell market-order intensity (ODE drift, no noise)

Dynamics

d(lambda+) = beta*(mu - lambda+) dt + alpha dN+ d(lambda-) = beta*(mu - lambda-) dt + alpha dN-

N+ counts buy market orders (rate lambda+), N- counts sell market orders (rate lambda-). Each side self-excites independently — there is no cross-excitation.

Market-making mapping

event	driven by	inventory effect
Sell MO hits bid	lambda-	q -> q + 1
Buy MO hits ask	lambda+	q -> q - 1

Effective fill rates:

• Lambda_bid = lambda- * exp(-kappa * delta_bid) (sell MO hits MM bid)
• Lambda_ask = lambda+ * exp(-kappa * delta_ask) (buy MO hits MM ask)

Hawkes approximation used in the FD solver

The lambda dimensions use the fluid (mean-field) approximation:

d(lambda+)/dt ~ beta*(mu - lambda+) + alpha * lambda+ d(lambda-)/dt ~ beta*(mu - lambda-) + alpha * lambda-

This is identical to the treatment in AvellanedaHawkes and ensures the stationary mean of each intensity sits at mu / (1 - alpha/beta) in the value-function PDE. Using discrete fill-triggered jumps instead requires lambda_step << alpha for accuracy; at the grid resolution affordable for 4-D tables that condition is violated, causing the PDE to see a much lower effective mean intensity than the actual simulation (mu vs mu/(1-rho)), which corrupts the value function and the extracted spreads.

Fields

gamma: f64

Risk-aversion parameter.

sigma: f64

Price volatility.

kappa: f64

Fill-rate decay (Avellaneda-Stoikov kappa).

alpha: f64

Jump size added to the excited side’s intensity.

beta: f64

Mean-reversion speed.

mu: f64

Baseline intensity (mean-reversion target).

lambda_step: f64

Grid step for both lambda+ and lambda- dimensions.

dq: f64

Grid step for the inventory dimension.

q_min: f64

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

q_max: f64

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

terminal_condition: TerminalCondition

Terminal condition for the value function at T. Defaults to Zero.

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 BilateralHawkes

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

pub fn with_terminal_condition( self, terminal_condition: TerminalCondition, ) -> 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_lambda_step(self, lambda_step: f64) -> Self

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

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

Computes optimal bid/ask half-spreads from value-function gradients.

Bid spread: driven by the inventory gradient in the +q direction (sell MO fills). Ask spread: driven by the inventory gradient in the -q direction (buy MO fills).

Trait Implementations

impl Clone for BilateralHawkes

fn clone(&self) -> BilateralHawkes

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BilateralHawkes

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Model<3> for BilateralHawkes

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

Forward step using the fluid (mean-field) drift, consistent with optimize().

The drift is beta*(mu - lambda) + alpha * lambda (same approximation used in the PDE so that the forward simulation matches the value-function’s stationary lambda regime at mu / (1 - alpha/beta)).

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

Coupled step: inventory jumps based on current fill probabilities.

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

Both intensity dimensions follow deterministic ODE drift with no Brownian noise.

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

The base arrival intensity is state-dependent: returns the average of the buy/sell intensity states 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; 3], grads: &Gradients<3>) -> ControlOutput<3>

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

fn terminal(&self, state: &[f64; 3]) -> 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 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.