"""Double-exponential Tangent Lévy density and pricing formulas."""
from __future__ import annotations
import math
from dataclasses import dataclass
import numpy as np
from cdxcore.err import verify_inp
from .config import PricingConfig
from .coordinates import normalized_call_intrinsic
from .pricing import fourier_call_prices
[docs]
@dataclass(frozen=True, kw_only=True)
class DoubleExponentialParameters:
"""Kou pure-jump parameters from equations (2.10)--(2.11)."""
intensity: float
positive_rate: float
negative_rate: float
positive_probability: float
def __post_init__(self) -> None:
verify_inp(
math.isfinite(self.intensity) and self.intensity > 0.0,
lambda: f"'intensity' must be finite and positive, got {self.intensity!r}",
)
verify_inp(
math.isfinite(self.positive_rate) and self.positive_rate > 1.0,
lambda: (
"'positive_rate' must be finite and greater than one, got "
f"{self.positive_rate!r}"
),
)
verify_inp(
math.isfinite(self.negative_rate) and self.negative_rate > 0.0,
lambda: (
"'negative_rate' must be finite and positive, got "
f"{self.negative_rate!r}"
),
)
verify_inp(
math.isfinite(self.positive_probability)
and 0.0 < self.positive_probability < 1.0,
lambda: (
"'positive_probability' must lie in (0, 1), got "
f"{self.positive_probability!r}"
),
)
@property
def negative_probability(self) -> float:
"""Probability of a negative jump."""
return 1.0 - self.positive_probability
@property
def exponential_jump_mean(self) -> float:
"""Return ``E[exp(Y)-1]`` for one jump."""
p = self.positive_probability
return (
p * self.positive_rate / (self.positive_rate - 1.0)
+ (1.0 - p) * self.negative_rate / (self.negative_rate + 1.0)
- 1.0
)
[docs]
def density(
jump_x: np.ndarray | float,
parameters: DoubleExponentialParameters,
) -> np.ndarray:
"""Evaluate the Lévy density ``eta(x)`` in equation (2.11)."""
x = np.asarray(jump_x, dtype=np.float64)
verify_inp(
np.all(np.isfinite(x)),
lambda: "jump sizes must contain only finite values",
)
p = parameters.positive_probability
result = np.where(
x >= 0.0,
p * parameters.positive_rate * np.exp(-parameters.positive_rate * x),
(1.0 - p)
* parameters.negative_rate
* np.exp(parameters.negative_rate * x),
)
return parameters.intensity * result
[docs]
def symmetry_index(parameters: DoubleExponentialParameters) -> float:
"""Return equation (2.17), ``integral (exp(x)-1) eta(x) dx``."""
return parameters.intensity * parameters.exponential_jump_mean
[docs]
def continuous_negative_rate(*, positive_rate: float, probability: float) -> float:
"""Derive the negative-tail rate from density continuity at zero."""
verify_inp(
math.isfinite(positive_rate) and positive_rate > 1.0,
lambda: f"'positive_rate' must exceed one, got {positive_rate!r}",
)
verify_inp(
math.isfinite(probability) and 0.0 < probability < 1.0,
lambda: f"'probability' must lie in (0, 1), got {probability!r}",
)
return probability * positive_rate / (1.0 - probability)
[docs]
def constrained_parameters(
*,
intensity: float,
positive_rate: float,
target_symmetry_index: float,
) -> DoubleExponentialParameters:
"""Apply equations (2.16)--(2.18) to obtain the two derived parameters."""
verify_inp(
math.isfinite(intensity) and intensity > 0.0,
lambda: f"'intensity' must be finite and positive, got {intensity!r}",
)
verify_inp(
math.isfinite(positive_rate) and positive_rate > 1.0,
lambda: f"'positive_rate' must exceed one, got {positive_rate!r}",
)
verify_inp(
math.isfinite(target_symmetry_index),
lambda: f"'target_symmetry_index' must be finite, got {target_symmetry_index!r}",
)
tail_excess = positive_rate - 1.0
ratio = target_symmetry_index / intensity
denominator = 1.0 + 2.0 * tail_excess - ratio * tail_excess**2
probability = tail_excess * (1.0 + ratio) / denominator
verify_inp(
math.isfinite(probability) and 0.0 < probability < 1.0,
lambda: (
"equations (2.16)--(2.18) imply an invalid probability "
f"{probability!r} for intensity={intensity}, "
f"positive_rate={positive_rate}, Xi={target_symmetry_index}"
),
)
negative_rate = continuous_negative_rate(
positive_rate=positive_rate,
probability=probability,
)
return DoubleExponentialParameters(
intensity=intensity,
positive_rate=positive_rate,
negative_rate=negative_rate,
positive_probability=probability,
)
[docs]
def characteristic_function(
z: np.ndarray,
*,
tau: float,
parameters: DoubleExponentialParameters,
) -> np.ndarray:
"""Return the martingale characteristic function of ``log(S_T/S_t)``."""
verify_inp(
math.isfinite(tau) and tau >= 0.0,
lambda: f"'tau' must be finite and nonnegative, got {tau!r}",
)
z = np.asarray(z, dtype=np.complex128)
p = parameters.positive_probability
jump_transform = (
p * parameters.positive_rate / (parameters.positive_rate - 1j * z)
+ (1.0 - p)
* parameters.negative_rate
/ (parameters.negative_rate + 1j * z)
)
exponent = tau * parameters.intensity * (
jump_transform - 1.0 - 1j * z * parameters.exponential_jump_mean
)
return np.exp(exponent)
[docs]
def call_prices(
*,
tau: float,
log_strikes: np.ndarray | float,
parameters: DoubleExponentialParameters,
config: PricingConfig = PricingConfig(),
) -> np.ndarray:
"""Price normalized calls under the pure-jump double-exponential model."""
if tau == 0.0:
return normalized_call_intrinsic(np.exp(np.asarray(log_strikes)))
return fourier_call_prices(
log_strikes,
lambda z: characteristic_function(z, tau=tau, parameters=parameters),
config=config,
)