Processes Module

Black-Scholes Processes

GeneralizedBlackScholesProcess

class pyquantlib.GeneralizedBlackScholesProcess

Bases: StochasticProcess1D

Generalized Black-Scholes-Merton stochastic process.

__init__(*args, **kwargs)

Overloaded function.

  1. __init__(x0: QuoteHandle, dividendTS: YieldTermStructureHandle, riskFreeTS: YieldTermStructureHandle, blackVolTS: BlackVolTermStructureHandle) -> None

  2. __init__(x0: QuoteHandle, dividendTS: YieldTermStructureHandle, riskFreeTS: YieldTermStructureHandle, blackVolTS: BlackVolTermStructureHandle, discretization: base.StochasticProcess1D.discretization) -> None

  3. __init__(x0: base.Quote, dividendTS: base.YieldTermStructure, riskFreeTS: base.YieldTermStructure, blackVolTS: base.BlackVolTermStructure) -> None

Constructs from term structures (handles created internally).

  1. __init__(x0: base.Quote, dividendTS: base.YieldTermStructure, riskFreeTS: base.YieldTermStructure, blackVolTS: base.BlackVolTermStructure, discretization: base.StochasticProcess1D.discretization) -> None

Constructs from term structures with discretization (handles created internally).

  1. __init__(x0: QuoteHandle, dividendTS: YieldTermStructureHandle, riskFreeTS: YieldTermStructureHandle, blackVolTS: BlackVolTermStructureHandle, localVolTS: LocalVolTermStructureHandle) -> None

  2. __init__(x0: base.Quote, dividendTS: base.YieldTermStructure, riskFreeTS: base.YieldTermStructure, blackVolTS: base.BlackVolTermStructure, localVolTS: base.LocalVolTermStructure) -> None

Constructs with external local vol (handles created internally).

blackVolatility() → BlackVolTermStructureHandle

Returns the Black volatility term structure handle.

dividendYield() → YieldTermStructureHandle

Returns the dividend yield term structure handle.

localVolatility() → LocalVolTermStructureHandle

Returns the local volatility term structure handle.

riskFreeRate() → YieldTermStructureHandle

Returns the risk-free rate term structure handle.

stateVariable() → QuoteHandle

Returns the state variable handle.

spot = ql.SimpleQuote(100.0)
risk_free = ql.FlatForward(today, 0.05, dc)
dividend = ql.FlatForward(today, 0.0, dc)
volatility = ql.BlackConstantVol(today, ql.TARGET(), 0.20, dc)

# Pythonic API: handles created internally
process = ql.GeneralizedBlackScholesProcess(spot, dividend, risk_free, volatility)

# Explicit handle construction
process = ql.GeneralizedBlackScholesProcess(
    ql.QuoteHandle(spot),
    ql.YieldTermStructureHandle(dividend),
    ql.YieldTermStructureHandle(risk_free),
    ql.BlackVolTermStructureHandle(volatility),
)

BlackScholesProcess

class pyquantlib.BlackScholesProcess

Bases: GeneralizedBlackScholesProcess

Black-Scholes process with no dividend yield.

__init__(*args, **kwargs)

Overloaded function.

  1. __init__(x0: QuoteHandle, riskFreeTS: YieldTermStructureHandle, blackVolTS: BlackVolTermStructureHandle) -> None

  2. __init__(x0: QuoteHandle, riskFreeTS: YieldTermStructureHandle, blackVolTS: BlackVolTermStructureHandle, discretization: base.StochasticProcess1D.discretization, forceDiscretization: bool = False) -> None

  3. __init__(x0: base.Quote, riskFreeTS: base.YieldTermStructure, blackVolTS: base.BlackVolTermStructure) -> None

Constructs from term structures (handles created internally).

  1. __init__(x0: base.Quote, riskFreeTS: base.YieldTermStructure, blackVolTS: base.BlackVolTermStructure, discretization: base.StochasticProcess1D.discretization, forceDiscretization: bool = False) -> None

Constructs from term structures with discretization (handles created internally).

BlackScholesMertonProcess

pyquantlib.BlackScholesMertonProcess

alias of GeneralizedBlackScholesProcess

Heston Process

HestonProcess

class pyquantlib.HestonProcess

Bases: StochasticProcess

Heston stochastic volatility process.

class Discretization

Bases: pybind11_object

Discretization schemes for Heston process simulation.

Members:

PartialTruncation

FullTruncation

Reflection

NonCentralChiSquareVariance

QuadraticExponential

QuadraticExponentialMartingale

BroadieKayaExactSchemeLobatto

BroadieKayaExactSchemeLaguerre

BroadieKayaExactSchemeTrapezoidal

__init__(value: SupportsInt | SupportsIndex) → None
BroadieKayaExactSchemeLaguerre = <Discretization.BroadieKayaExactSchemeLaguerre: 7>
BroadieKayaExactSchemeLobatto = <Discretization.BroadieKayaExactSchemeLobatto: 6>
BroadieKayaExactSchemeTrapezoidal = <Discretization.BroadieKayaExactSchemeTrapezoidal: 8>
FullTruncation = <Discretization.FullTruncation: 1>
NonCentralChiSquareVariance = <Discretization.NonCentralChiSquareVariance: 3>
PartialTruncation = <Discretization.PartialTruncation: 0>
QuadraticExponential = <Discretization.QuadraticExponential: 4>
QuadraticExponentialMartingale = <Discretization.QuadraticExponentialMartingale: 5>
Reflection = <Discretization.Reflection: 2>
HestonProcess.Discretization.name -> str
property value
__init__(*args, **kwargs)

Overloaded function.

  1. __init__(riskFreeRate: YieldTermStructureHandle, dividendYield: YieldTermStructureHandle, s0: QuoteHandle, v0: SupportsFloat | SupportsIndex, kappa: SupportsFloat | SupportsIndex, theta: SupportsFloat | SupportsIndex, sigma: SupportsFloat | SupportsIndex, rho: SupportsFloat | SupportsIndex, d: HestonProcess.Discretization = <Discretization.QuadraticExponentialMartingale: 5>) -> None

  2. __init__(riskFreeRate: base.YieldTermStructure, dividendYield: base.YieldTermStructure, s0: base.Quote, v0: SupportsFloat | SupportsIndex, kappa: SupportsFloat | SupportsIndex, theta: SupportsFloat | SupportsIndex, sigma: SupportsFloat | SupportsIndex, rho: SupportsFloat | SupportsIndex, d: HestonProcess.Discretization = <Discretization.QuadraticExponentialMartingale: 5>) -> None

Constructs from term structures (handles created internally).

dividendYield() → YieldTermStructureHandle

Returns the dividend yield term structure handle.

kappa() → float

Returns the mean-reversion speed.

pdf(x: SupportsFloat | SupportsIndex, v: SupportsFloat | SupportsIndex, t: SupportsFloat | SupportsIndex, eps: SupportsFloat | SupportsIndex = 0.001) → float

Returns the probability density at (x, v) for time t, where x is log-spot.

rho() → float

Returns the correlation between spot and variance.

riskFreeRate() → YieldTermStructureHandle

Returns the risk-free rate term structure handle.

s0() → QuoteHandle

Returns the initial spot price handle.

sigma() → float

Returns the volatility of volatility.

theta() → float

Returns the long-term variance.

v0() → float

Returns the initial variance.

BroadieKayaExactSchemeLaguerre = <Discretization.BroadieKayaExactSchemeLaguerre: 7>
BroadieKayaExactSchemeLobatto = <Discretization.BroadieKayaExactSchemeLobatto: 6>
BroadieKayaExactSchemeTrapezoidal = <Discretization.BroadieKayaExactSchemeTrapezoidal: 8>
FullTruncation = <Discretization.FullTruncation: 1>
NonCentralChiSquareVariance = <Discretization.NonCentralChiSquareVariance: 3>
PartialTruncation = <Discretization.PartialTruncation: 0>
QuadraticExponential = <Discretization.QuadraticExponential: 4>
QuadraticExponentialMartingale = <Discretization.QuadraticExponentialMartingale: 5>
Reflection = <Discretization.Reflection: 2>

Parameter

Symbol

Description

v0

\(v_0\)

Initial variance

kappa

\(\kappa\)

Mean reversion speed

theta

\(\theta\)

Long-term variance

sigma

\(\sigma\)

Vol of vol

rho

\(\rho\)

Correlation between spot and vol

 
heston_process = ql.HestonProcess(
    risk_free, dividend, spot,
    v0=0.04, kappa=1.0, theta=0.04, sigma=0.5, rho=-0.7,
)

BatesProcess

class pyquantlib.BatesProcess

Bases: HestonProcess

Bates stochastic volatility process with jumps.

__init__(*args, **kwargs)

Overloaded function.

  1. __init__(riskFreeRate: YieldTermStructureHandle, dividendYield: YieldTermStructureHandle, s0: QuoteHandle, v0: SupportsFloat | SupportsIndex, kappa: SupportsFloat | SupportsIndex, theta: SupportsFloat | SupportsIndex, sigma: SupportsFloat | SupportsIndex, rho: SupportsFloat | SupportsIndex, lambda: SupportsFloat | SupportsIndex, nu: SupportsFloat | SupportsIndex, delta: SupportsFloat | SupportsIndex, discretization: HestonProcess.Discretization = <Discretization.FullTruncation: 1>) -> None

Constructs Bates process with Heston parameters plus jump parameters.

  1. __init__(riskFreeRate: base.YieldTermStructure, dividendYield: base.YieldTermStructure, s0: base.Quote, v0: SupportsFloat | SupportsIndex, kappa: SupportsFloat | SupportsIndex, theta: SupportsFloat | SupportsIndex, sigma: SupportsFloat | SupportsIndex, rho: SupportsFloat | SupportsIndex, lambda: SupportsFloat | SupportsIndex, nu: SupportsFloat | SupportsIndex, delta: SupportsFloat | SupportsIndex, discretization: HestonProcess.Discretization = <Discretization.FullTruncation: 1>) -> None

Constructs with term structures and quote (handles created internally).

delta() → float

Returns jump size volatility.

lambda_() → float

Returns jump intensity.

nu() → float

Returns mean jump size.

Extends HestonProcess with jump parameters:

Parameter

Symbol

Description

lambda

\(\lambda\)

Jump intensity

nu

\(\nu\)

Mean jump size

delta

\(\delta\)

Jump size volatility

 
bates_process = ql.BatesProcess(
    risk_free, dividend, spot,
    0.04, 1.0, 0.04, 0.5, -0.7,  # v0, kappa, theta, sigma, rho
    0.1, -0.05, 0.1,              # lambda, nu, delta
)

Short-Rate Processes

OrnsteinUhlenbeckProcess

class pyquantlib.OrnsteinUhlenbeckProcess

Bases: StochasticProcess1D

Ornstein-Uhlenbeck mean-reverting process: dx = a(r - x)dt + sigma dW.

__init__(speed: SupportsFloat | SupportsIndex, volatility: SupportsFloat | SupportsIndex, x0: SupportsFloat | SupportsIndex = 0.0, level: SupportsFloat | SupportsIndex = 0.0) → None

Constructs an OU process.

level() → float

Returns long-term mean level.

speed() → float

Returns mean reversion speed.

volatility() → float

Returns volatility.

x0() → float

Returns initial value.

Mean-reverting Ornstein-Uhlenbeck process: \(dx = a(r - x)\,dt + \sigma\,dW\).

process = ql.OrnsteinUhlenbeckProcess(speed=0.5, volatility=0.01, x0=0.05, level=0.05)

HullWhiteProcess

class pyquantlib.HullWhiteProcess

Bases: StochasticProcess1D

Hull-White short-rate stochastic process.

__init__(*args, **kwargs)

Overloaded function.

  1. __init__(riskFreeRate: YieldTermStructureHandle, a: SupportsFloat | SupportsIndex, sigma: SupportsFloat | SupportsIndex) -> None

Constructs from yield term structure handle.

  1. __init__(riskFreeRate: base.YieldTermStructure, a: SupportsFloat | SupportsIndex, sigma: SupportsFloat | SupportsIndex) -> None

Constructs from yield term structure (handle created internally).

a() → float

Returns mean reversion speed.

alpha(t: SupportsFloat | SupportsIndex) → float

Returns alpha at time t.

sigma() → float

Returns volatility.

Hull-White short-rate process under the risk-neutral measure.

process = ql.HullWhiteProcess(curve, a=0.1, sigma=0.01)

HullWhiteForwardProcess

class pyquantlib.HullWhiteForwardProcess

Bases: ForwardMeasureProcess1D

Hull-White forward-measure short-rate process.

B(t: SupportsFloat | SupportsIndex, T: SupportsFloat | SupportsIndex) → float

Returns discount bond function B(t, T).

M_T(s: SupportsFloat | SupportsIndex, t: SupportsFloat | SupportsIndex, T: SupportsFloat | SupportsIndex) → float

Returns forward-measure adjustment M_T(s, t, T).

__init__(*args, **kwargs)

Overloaded function.

  1. __init__(riskFreeRate: YieldTermStructureHandle, a: SupportsFloat | SupportsIndex, sigma: SupportsFloat | SupportsIndex) -> None

Constructs from yield term structure handle.

  1. __init__(riskFreeRate: base.YieldTermStructure, a: SupportsFloat | SupportsIndex, sigma: SupportsFloat | SupportsIndex) -> None

Constructs from yield term structure (handle created internally).

a() → float

Returns mean reversion speed.

alpha(t: SupportsFloat | SupportsIndex) → float

Returns alpha at time t.

sigma() → float

Returns volatility.

Hull-White process under the T-forward measure. Adds M_T(s, t, T) and B(t, T) methods.

process = ql.HullWhiteForwardProcess(curve, a=0.1, sigma=0.01)
process.setForwardMeasureTime(5.0)

Jump-Diffusion Processes

GeometricBrownianMotionProcess

class pyquantlib.GeometricBrownianMotionProcess

Bases: StochasticProcess1D

Geometric Brownian motion process: dS = mu*S*dt + sigma*S*dW.

__init__(initialValue: SupportsFloat | SupportsIndex, mu: SupportsFloat | SupportsIndex, sigma: SupportsFloat | SupportsIndex) → None

Constructs a GBM process.

x0() → float

Returns initial value.

Geometric Brownian motion: \(dS = \mu S\,dt + \sigma S\,dW\).

process = ql.GeometricBrownianMotionProcess(initialValue=100.0, mu=0.05, sigma=0.2)

Merton76Process

class pyquantlib.Merton76Process

Bases: StochasticProcess1D

Merton jump-diffusion process.

__init__(*args, **kwargs)

Overloaded function.

  1. __init__(stateVariable: QuoteHandle, dividendTS: YieldTermStructureHandle, riskFreeTS: YieldTermStructureHandle, blackVolTS: BlackVolTermStructureHandle, jumpIntensity: QuoteHandle, logMeanJump: QuoteHandle, logJumpVolatility: QuoteHandle) -> None

Constructs from handles.

  1. __init__(stateVariable: base.Quote, dividendTS: base.YieldTermStructure, riskFreeTS: base.YieldTermStructure, blackVolTS: base.BlackVolTermStructure, jumpIntensity: base.Quote, logMeanJump: base.Quote, logJumpVolatility: base.Quote) -> None

Constructs from shared_ptrs (handles created internally).

blackVolatility() → BlackVolTermStructureHandle

Returns Black volatility handle.

dividendYield() → YieldTermStructureHandle

Returns dividend yield handle.

jumpIntensity() → QuoteHandle

Returns jump intensity handle.

logJumpVolatility() → QuoteHandle

Returns log jump volatility handle.

logMeanJump() → QuoteHandle

Returns log-mean jump handle.

riskFreeRate() → YieldTermStructureHandle

Returns risk-free rate handle.

stateVariable() → QuoteHandle

Returns spot quote handle.

x0() → float

Returns initial value.

Merton jump-diffusion process extending Black-Scholes with log-normal jumps.

process = ql.Merton76Process(spot, dividend, risk_free, volatility,
                              jumpIntensity, logMeanJump, logJumpVolatility)

SquareRootProcess

class pyquantlib.SquareRootProcess

Bases: StochasticProcess1D

Square root (CIR) process: dx = a(b - x)dt + sigma*sqrt(x)*dW.

__init__(b: SupportsFloat | SupportsIndex, a: SupportsFloat | SupportsIndex, sigma: SupportsFloat | SupportsIndex, x0: SupportsFloat | SupportsIndex = 0.0) → None

Constructs a square root process.

a() → float

Returns speed of mean reversion.

b() → float

Returns long-term mean.

sigma() → float

Returns volatility.

x0() → float

Returns initial value.

CIR-type square root mean-reverting process: \(dx = a(b - x)\,dt + \sigma\sqrt{x}\,dW\).

process = ql.SquareRootProcess(b=0.04, a=1.0, sigma=0.2, x0=0.04)

ExtendedOrnsteinUhlenbeckProcess

class pyquantlib.ExtendedOrnsteinUhlenbeckProcess

Bases: StochasticProcess1D

Extended OU process with time-dependent level: dx = a(b(t) - x)dt + sigma*dW.

__init__(speed: typing.SupportsFloat | typing.SupportsIndex, sigma: typing.SupportsFloat | typing.SupportsIndex, x0: typing.SupportsFloat | typing.SupportsIndex, b: collections.abc.Callable[[typing.SupportsFloat | typing.SupportsIndex], float], discretization: ExtendedOUDiscretization = <ExtendedOUDiscretization.MidPoint: 0>, intEps: typing.SupportsFloat | typing.SupportsIndex = 0.0001) → None

Constructs with time-dependent level function b(t).

speed() → float

Returns mean reversion speed.

volatility() → float

Returns volatility.

x0() → float

Returns initial value.

Extended Ornstein-Uhlenbeck process with time-dependent level \(b(t)\).

process = ql.ExtendedOrnsteinUhlenbeckProcess(
    speed=0.5, sigma=0.01, x0=0.05, b=lambda t: 0.05 + 0.01 * t
)

Two-Factor Processes

G2Process

class pyquantlib.G2Process

Bases: StochasticProcess

G2 two-factor short-rate stochastic process.

__init__(a: SupportsFloat | SupportsIndex, sigma: SupportsFloat | SupportsIndex, b: SupportsFloat | SupportsIndex, eta: SupportsFloat | SupportsIndex, rho: SupportsFloat | SupportsIndex) → None

Constructs G2Process.

a() → float

Returns mean reversion speed a.

b() → float

Returns mean reversion speed b.

eta() → float

Returns volatility eta.

rho() → float

Returns correlation rho.

sigma() → float

Returns volatility sigma.

x0() → float

Returns initial x value.

y0() → float

Returns initial y value.

G2 two-factor short-rate stochastic process.

process = ql.G2Process(a=0.1, sigma=0.01, b=0.1, eta=0.01, rho=-0.75)

G2ForwardProcess

class pyquantlib.G2ForwardProcess

Bases: ForwardMeasureProcess

G2 forward-measure two-factor short-rate process.

__init__(a: SupportsFloat | SupportsIndex, sigma: SupportsFloat | SupportsIndex, b: SupportsFloat | SupportsIndex, eta: SupportsFloat | SupportsIndex, rho: SupportsFloat | SupportsIndex) → None

Constructs G2ForwardProcess.

G2 forward-measure two-factor short-rate process.

Hybrid Processes

HybridHestonHullWhiteProcess

class pyquantlib.HybridHestonHullWhiteProcess

Bases: StochasticProcess

Hybrid Heston Hull-White three-factor stochastic process.

class Discretization

Bases: pybind11_object

Discretization schemes for hybrid process.

Members:

Euler

BSMHullWhite

__init__(value: SupportsInt | SupportsIndex) → None
BSMHullWhite = <Discretization.BSMHullWhite: 1>
Euler = <Discretization.Euler: 0>
HybridHestonHullWhiteProcess.Discretization.name -> str
property value
__init__(hestonProcess: HestonProcess, hullWhiteProcess: HullWhiteForwardProcess, corrEquityShortRate: SupportsFloat | SupportsIndex, discretization: HybridHestonHullWhiteProcess.Discretization = <Discretization.BSMHullWhite: 1>) → None

Constructs HybridHestonHullWhiteProcess.

discretization() → HybridHestonHullWhiteProcess.Discretization

Returns the discretization scheme.

eta() → float

Returns the equity-rate correlation.

hestonProcess() → HestonProcess

Returns the Heston process.

hullWhiteProcess() → HullWhiteForwardProcess

Returns the Hull-White forward process.

BSMHullWhite = <Discretization.BSMHullWhite: 1>
Euler = <Discretization.Euler: 0>

Hybrid Heston + Hull-White three-factor stochastic process combining equity stochastic volatility with stochastic interest rates.

hybrid = ql.HybridHestonHullWhiteProcess(
    heston_process, hw_forward_process,
    corrEquityShortRate=0.3,
    discretization=ql.HybridHestonHullWhiteProcess.BSMHullWhite,
)

Multi-Asset Processes

StochasticProcessArray

class pyquantlib.StochasticProcessArray

Bases: StochasticProcess

Array of correlated 1-D stochastic processes.

__init__(processes: collections.abc.Sequence[base.StochasticProcess1D], correlation: Matrix) → None

Constructs from a list of 1D processes and correlation matrix.

correlation() → Matrix

Returns the correlation matrix.

covariance(t0: SupportsFloat | SupportsIndex, x0: Array, dt: SupportsFloat | SupportsIndex) → Matrix

Returns the covariance matrix.

diffusion(t: SupportsFloat | SupportsIndex, x: Array) → Matrix

Returns the diffusion matrix at time t and state x.

drift(t: SupportsFloat | SupportsIndex, x: Array) → Array

Returns the drift at time t and state x.

evolve(t0: SupportsFloat | SupportsIndex, x0: Array, dt: SupportsFloat | SupportsIndex, dw: Array) → Array

Returns the asset value after a time interval.

expectation(t0: SupportsFloat | SupportsIndex, x0: Array, dt: SupportsFloat | SupportsIndex) → Array

Returns the expectation of the process.

initialValues() → Array

Returns the initial values of all processes.

process(i: SupportsInt | SupportsIndex) → base.StochasticProcess1D

Returns the i-th process.

size() → int

Returns the number of processes.

stdDeviation(t0: SupportsFloat | SupportsIndex, x0: Array, dt: SupportsFloat | SupportsIndex) → Matrix

Returns the standard deviation matrix.

Stochastic Local Volatility

HestonSLVProcess

class pyquantlib.HestonSLVProcess

Bases: StochasticProcess

Heston stochastic local volatility process.

__init__(hestonProcess: HestonProcess, leverageFct: base.LocalVolTermStructure, mixingFactor: SupportsFloat | SupportsIndex = 1.0) → None

Constructs from Heston process and leverage function.

dividendYield() → YieldTermStructureHandle

Returns dividend yield handle.

factors() → int

Returns number of Brownian factors (2).

kappa() → float

Returns mean reversion speed.

leverageFct() → base.LocalVolTermStructure

Returns leverage function.

mixingFactor() → float

Returns mixing factor.

rho() → float

Returns correlation.

riskFreeRate() → YieldTermStructureHandle

Returns risk-free rate handle.

s0() → QuoteHandle

Returns spot price handle.

sigma() → float

Returns volatility of volatility.

size() → int

Returns process dimension (2).

theta() → float

Returns long-term variance.

v0() → float

Returns initial variance.

Heston stochastic local volatility process combining a Heston process with a leverage function (local vol surface).

heston_process = ql.HestonProcess(
    risk_free, dividend, spot,
    v0=0.04, kappa=1.0, theta=0.04, sigma=0.5, rho=-0.7,
)
leverage_fct = ql.LocalConstantVol(today, 0.20, dc)

slv_process = ql.HestonSLVProcess(heston_process, leverage_fct, mixingFactor=1.0)

Note

Abstract base classes StochasticProcess, StochasticProcess1D, ForwardMeasureProcess, and ForwardMeasureProcess1D are available in pyquantlib.base for custom process implementations.