Struct BilateralHawkesOrderFlowImbalance 

pub struct BilateralHawkesOrderFlowImbalance {

    pub gamma: f64,
    pub sigma: f64,
    pub kappa: f64,
    pub alpha: f64,
    pub beta: f64,
    pub mu: f64,
    pub eta_ofi: 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>,
}

Bilateral Hawkes model with price-impact-driven adverse selection.

State Space: [q, lambda_plus, lambda_minus]

dim	symbol	description
0	q	Inventory level (integer, jump-controlled)
1	lambda_plus	Buy market-order intensity (ODE drift, no noise)
2	lambda_minus	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- dS = sigma dW + eta_ofi (dN+ - dN-)

Each buy market order (dN+) moves the mid price UP by eta_ofi; each sell market order (dN-) moves it DOWN by eta_ofi. The market maker accounts for this price impact when setting optimal spreads.

Optimal Spreads Under Price Impact

Deriving the FOC from the CARA HJB with per-fill wealth effect (q±1)*eta_ofi gives:

$$ \delta_{bid}^* = \delta_{base} - \frac{\partial V}{\partial q} + (q+1)\eta_{OFI} $$ $$ \delta_{ask}^* = \delta_{base} + \frac{\partial V}{\partial q} - (q-1)\eta_{OFI} $$

Economic interpretation:

• Long inventory (q > 0): ask narrows (selling into a rising price is favourable), bid widens (avoid accumulating more when sell MOs push price down).
• Short inventory (q < 0): ask widens (avoid shorting further into a rising price), bid narrows (cover cheaply when sell MOs push price down).

Setting eta_ofi = 0 recovers the plain BilateralHawkes (BHK) model exactly.

In the simulation pass impact_factor = -eta_ofi to SimulatedDataSource so the price process matches the assumed dynamics dS = sigma dW + eta_ofi (dN+ - dN-).

Hawkes Approximation

Same fluid (mean-field) approximation as BilateralHawkes:

$$ d(\lambda_+)/dt \approx \beta(\mu - \lambda_+) + \alpha \lambda_+ $$ $$ d(\lambda_-)/dt \approx \beta(\mu - \lambda_-) + \alpha \lambda_- $$

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).

eta_ofi: f64

Price impact per fill event (eta_ofi in dS = sigmadW + eta_ofi(dN+ - dN-)). Higher eta_ofi = stronger q-dependent spread correction. Setting eta_ofi = 0 recovers the plain BilateralHawkes (BHK) model.

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 BilateralHawkesOrderFlowImbalance

pub fn new( gamma: f64, sigma: f64, kappa: f64, alpha: f64, beta: f64, mu: f64, eta_ofi: 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, state: &[f64; 3], derivs: &StateDerivatives<3>, ) -> (f64, f64)

Computes optimal bid/ask half-spreads with price-impact-driven inventory correction.

When eta_ofi > 0 each fill carries an adverse-selection wealth effect (q±1)*eta_ofi. The FOC on the CARA HJB gives: delta_bid = base_spread - dV/dq_fwd + (q+1)*eta_ofi delta_ask = base_spread + dV/dq_bwd - (q-1)*eta_ofi

Long inventory (q > 0): ask narrows (sell into rising price), bid widens. Short inventory (q < 0): ask widens (avoid adding short), bid narrows. eta_ofi = 0 recovers the plain BHK spread formula identically.

pub 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.

pub fn fill_rate_decay(&self) -> f64

The fill-rate decay parameter used for intensity-to-spread conversion.

Trait Implementations

impl Clone for BilateralHawkesOrderFlowImbalance

fn clone(&self) -> BilateralHawkesOrderFlowImbalance

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ControlProblem<3> for BilateralHawkesOrderFlowImbalance

type Control = MarketMakingControl

The action type. For Merton this is a scalar portfolio fraction; for market making it is a pair of bid/ask intensities.

fn optimize( &self, _t: f64, state: &[f64; 3], derivs: &StateDerivatives<3>, ) -> Self::Control

Returns the control that maximizes the driver at (t, state).

fn running_reward( &self, _t: f64, _state: &[f64; 3], control: &Self::Control, ) -> f64

Returns the running reward f(t,x,u).

fn bsde_driver( &self, _t: f64, state: &[f64; 3], control: &Self::Control, _derivs: &StateDerivatives<3>, dt: f64, ) -> f64

Returns the backward driver consumed by the BSDE regression solver.

fn generator( &self, _t: f64, state: &[f64; 3], _control: &Self::Control, derivs: &StateDerivatives<3>, ) -> f64

Returns the infinitesimal generator L^u V for the given control and derivative bundle.

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

Terminal value g(x) at the horizon.

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

Discount rate r(t,x). Defaults to zero.

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

Constant discount rate hint. Defaults to None (state dependent).

fn next_step( &self, _t: f64, state: &[f64; 3], dt: f64, noise: &[f64; 3], ) -> [f64; 3]

Advances the state one step under the optimal control at forward time t.

fn next_step_controlled( &self, _t: f64, state: &[f64; 3], control: &Self::Control, dt: f64, noise: &[f64; 3], ) -> [f64; 3]

Advances the state one step under an explicitly supplied control.

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

Whether a dimension is driven by Brownian diffusion.

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

Physical finite-difference step for a dimension, used by mesh-free gradient stencils.

fn driver( &self, t: f64, state: &[f64; N], control: &Self::Control, derivs: &StateDerivatives<N>, ) -> f64

Returns the full HJB driver f(t,x,u) + L^u V.

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

Optional pointwise constraint on the value, e.g. the early-exercise obstacle V >= payoff for an American option.

fn is_reduced_value(&self) -> bool

Whether the value this problem solves is a reduced value.

impl Debug for BilateralHawkesOrderFlowImbalance

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

Formats the value using the given formatter.

impl PdeProblem<3> for BilateralHawkesOrderFlowImbalance

fn dimension_kind(&self, dim: usize) -> DimensionKind

Discretization kind for dim.

fn transport( &self, _t: f64, state: &[f64; 3], control: &Self::Control, derivs: &StateDerivatives<3>, ) -> Transport<3>

Transport and local source for the given control and derivatives.

fn jump_kernel( &self, _t: f64, _state: &[f64; N], _control: &Self::Control, _derivs: &StateDerivatives<N>, transport: &Transport<N>, ) -> JumpKernel<N>

Jump kernel for arbitrary-amplitude jump dimensions.