Struct Heston 

pub struct Heston {

    pub gamma: f64,
    pub kappa_m: f64,
    pub a: f64,
    pub v_kappa: f64,
    pub v_theta: f64,
    pub v_xi: f64,
    pub rho: f64,
    pub price_scale: f64,
    pub dv: f64,
    pub dq: f64,
    pub q_min: f64,
    pub q_max: f64,
    pub terminal_condition: TerminalCondition,
}

Heston Stochastic Volatility Model for Market Making

Extends the Avellaneda-Stoikov model by adding stochastic volatility to the mid-price. The value function depends on both inventory and current variance.

Dynamics

• $dS_t = S_0 \sqrt{v_t} dW^S_t$
• $dv_t = \kappa_v (\theta - v_t) dt + \xi \sqrt{v_t} dW^v_t$

This reduced HJB model has state [q, v] only (no spot state). To align with a multiplicative market process where price diffusion scales with S_t, we freeze spot at a reference level price_scale (typically initial price).

Fields

gamma: f64

Risk aversion for inventory holding.

kappa_m: f64

Order filling intensity decay ($\kappa$).

a: f64

Base order arrival intensity ($A$).

v_kappa: f64

Mean reversion speed for variance ($\kappa_v$).

v_theta: f64

Long-run mean variance ($\theta$).

v_xi: f64

Volatility of variance (vol-of-vol, $\xi$).

rho: f64

Correlation between price and variance Brownian motions ($\rho$).

price_scale: f64

Reference spot level used to map relative variance into absolute price-risk scale.

dv: f64

Grid step size for the variance dimension.

dq: f64

Grid step for inventory dimension (defaults to 1.0 for integer grid).

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_condition: TerminalCondition

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

Implementations

impl Heston

pub fn new(gamma: f64, kappa_m: f64, a: f64) -> Self

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

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

pub fn with_variance_params(self, v_kappa: f64, v_theta: f64, v_xi: f64) -> Self

pub fn with_rho(self, rho: f64) -> Self

pub fn with_price_scale(self, price_scale: f64) -> Self

pub fn with_dv(self, dv: f64) -> Self

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

pub fn with_grid_steps(self, dx: &[f64; 2]) -> Self

Sets grid step sizes from a Grid<2>. Dimension 0 = inventory (dq), Dimension 1 = variance (dv).

pub fn build_process(&self) -> HestonProcess

Constructs a HestonProcess matching this model’s variance parameters and correlation. Uses price_scale as the initial spot and v_theta as the initial variance so that the process starts in its stationary regime.

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

Trait Implementations

impl Clone for Heston

fn clone(&self) -> Heston

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Heston

impl Debug for Heston

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

Formats the value using the given formatter.

impl Model<2> for Heston

type Process = HestonProcess

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

fn process(&self) -> HestonProcess

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 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_base(&self, _state: &[f64; 2]) -> f64

Base order arrival rate $A$ used for intensity-to-spread conversion. May depend on the current state (e.g. Hawkes lambda). Defaults to 1.0.

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 next_step_controlled( &self, current_state: &[f64; N], _control: &ControlOutput<N>, dt: f64, noise: &[f64; N], ) -> [f64; N]

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

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

Optional transform for standard normal samples before forward stepping.