jump-diffusion-estimation 0.2.0__py3-none-any.whl

jump_diffusion/__init__.py

@@ -0,0 +1,40 @@
+"""
+Jump-Diffusion Parameter Estimation Library
+
+A comprehensive Python library for simulating and estimating parameters
+of jump-diffusion processes with asymmetric jump distributions.
+"""
+
+__version__ = "0.2.0"
+__author__ = "Juan David OSPINA ARANGO"
+__email__ = "jdospina@gmail.com"
+
+# Core imports for easy access
+from .simulation import JumpDiffusionSimulator
+from .estimation import JumpDiffusionEstimator
+from .models import JumpDiffusionModel
+from .validation import ValidationExperiment
+
+# Make key classes available at package level
+__all__ = [
+    "JumpDiffusionSimulator",
+    "JumpDiffusionEstimator",
+    "JumpDiffusionModel",
+    "ValidationExperiment",
+]
+
+
+# Version information
+def get_version():
+    """Return the current version of the library."""
+    return __version__
+
+
+def get_info():
+    """Return basic information about the library."""
+    return {
+        "name": "jump-diffusion-estimation",
+        "version": __version__,
+        "author": __author__,
+        "description": "Jump-Diffusion Parameter Estimation Library",
+    }

jump_diffusion/distributions/__init__.py

@@ -0,0 +1,22 @@
+"""
+Pluggable Jump-Size Distributions
+
+This module contains the jump-size distributions that can be plugged into
+JumpDiffusionModel via its ``jump_distribution`` argument.
+"""
+
+from .base import JumpDistribution
+from .kou import KouJump
+from .normal import NormalJump
+from .sged import SGEDJump
+from .skew_normal import SkewNormalJump
+from .student_t import StudentTJump
+
+__all__ = [
+    "JumpDistribution",
+    "SkewNormalJump",
+    "NormalJump",
+    "SGEDJump",
+    "KouJump",
+    "StudentTJump",
+]

jump_diffusion/distributions/base.py

@@ -0,0 +1,152 @@
+"""
+Base interface for pluggable jump-size distributions.
+
+This module defines the ``JumpDistribution`` abstract interface used by
+:class:`~jump_diffusion.models.jump_diffusion.JumpDiffusionModel` to plug in
+different jump-magnitude distributions. Concrete distributions only need to
+implement the probability density (``pdf``) plus a few descriptive methods;
+the diffusion-convolved mixture density and random sampling have generic
+numerical fallbacks here, so any new distribution works out of the box.
+Closed-form overrides remain available for speed where they exist (see
+``SkewNormalJump`` and ``NormalJump``).
+"""
+
+from abc import ABC, abstractmethod
+from typing import Dict, Optional, Tuple
+
+import numpy as np
+from scipy.stats import norm
+
+
+class JumpDistribution(ABC):
+    """Abstract interface for a jump-size distribution."""
+
+    param_names: Tuple[str, ...] = ()
+
+    @abstractmethod
+    def default_params(self) -> Dict[str, float]:
+        """Return sensible default parameter values."""
+
+    @abstractmethod
+    def pdf(self, x: np.ndarray, params: Dict[str, float]) -> np.ndarray:
+        """Probability density of the jump size at ``x``."""
+
+    @abstractmethod
+    def param_bounds(self) -> Dict[str, Tuple[Optional[float], Optional[float]]]:
+        """Optimization bounds for each parameter in ``param_names``."""
+
+    @abstractmethod
+    def initial_guess(
+        self,
+        mean_increment: float,
+        std_increment: float,
+        skewness: float,
+    ) -> Dict[str, float]:
+        """Heuristic initial parameter guess derived from data moments."""
+
+    def characteristic_scale(self, params: Dict[str, float]) -> float:
+        """
+        Rough scale of the jump size, used to size the FFT/inverse-CDF grids
+        in :meth:`fft_convolved_pdf` and :meth:`rvs`.
+
+        Default reads ``jump_scale`` directly, the convention used by
+        ``NormalJump``/``SkewNormalJump``/``SGEDJump``. Override this for
+        distributions with a different parameterization (e.g. ``KouJump``,
+        which has separate up/down scales instead of a single one).
+        """
+        return params.get("jump_scale", 1.0)
+
+    def diffusion_convolved_pdf(
+        self,
+        x: np.ndarray,
+        params: Dict[str, float],
+        diffusion_mean: float,
+        diffusion_std: float,
+    ) -> Optional[np.ndarray]:
+        """
+        Closed-form density of (diffusion + jump), if one is known.
+
+        Returns ``None`` when no closed form is available, signalling
+        callers to fall back to :meth:`fft_convolved_pdf`.
+        """
+        return None
+
+    def fft_convolved_pdf(
+        self,
+        x: np.ndarray,
+        params: Dict[str, float],
+        diffusion_mean: float,
+        diffusion_std: float,
+        j: int = 15,
+        h: Optional[float] = None,
+    ) -> np.ndarray:
+        """
+        Numerically approximate the density of (diffusion + jump) via FFT
+        convolution.
+
+        Implements the discretization scheme from Ospina Arango (2009),
+        "Estimacion de un modelo de difusion con saltos con distribucion de
+        error generalizada asimetrica usando algoritmos evolutivos"
+        (Universidad Nacional de Colombia): both densities are discretized
+        on a symmetric grid of ``2 * 2**j`` half-integer-offset points
+        around zero, convolved via FFT, and linearly interpolated to
+        evaluate at the requested points.
+        """
+        x = np.asarray(x, dtype=float)
+        jump_std = self.characteristic_scale(params)
+        if jump_std is None or jump_std <= 0:
+            return np.zeros_like(x)
+
+        if h is None:
+            h = min(diffusion_std, jump_std) / 200.0
+
+        m = 2**j
+        k = np.arange(-m + 0.5, m, 1.0)  # length 2*m, half-integer offsets
+        x_grid = k * h
+
+        f_diffusion = norm.pdf(x_grid, loc=diffusion_mean, scale=diffusion_std)
+        f_jump = self.pdf(x_grid, params)
+        if not (np.all(np.isfinite(f_diffusion)) and np.all(np.isfinite(f_jump))):
+            return np.zeros_like(x)
+
+        # numpy's ifft already divides by n, unlike R's fft(..., inverse=TRUE)
+        conv = np.real(np.fft.ifft(np.fft.fft(f_diffusion) * np.fft.fft(f_jump)))
+        conv *= h
+        conv = np.concatenate([conv[m:], conv[:m]])  # re-center around x_grid
+        conv = np.maximum(conv, 0.0)
+
+        if x.min() < x_grid[0] or x.max() > x_grid[-1]:
+            return np.zeros_like(x)
+
+        return np.interp(x, x_grid, conv)
+
+    def rvs(
+        self,
+        params: Dict[str, float],
+        size: int,
+        random_state: Optional[np.random.Generator] = None,
+    ) -> np.ndarray:
+        """
+        Draw random jump sizes via numerical inverse-CDF sampling.
+
+        Generic fallback for distributions without a native fast sampler:
+        discretizes ``pdf`` on a grid (in the same spirit as
+        :meth:`fft_convolved_pdf`) and inverts its cumulative sum.
+
+        When ``random_state`` is ``None`` (the default), draws from
+        NumPy's global legacy random state -- the same one seeded by
+        ``JumpDiffusionModel.simulate(seed=...)`` via ``np.random.seed``
+        -- so that simulations stay reproducible. Pass an explicit
+        ``np.random.Generator`` for an isolated, independent stream.
+        """
+        jump_std = self.characteristic_scale(params)
+        h = jump_std / 200.0
+        m = 2**12  # a coarser grid than fft_convolved_pdf suffices here
+        k = np.arange(-m + 0.5, m, 1.0)
+        x_grid = k * h
+        density = np.maximum(self.pdf(x_grid, params), 0.0)
+        cdf = np.cumsum(density) * h
+        cdf /= cdf[-1]
+        rand = random_state if random_state is not None else np.random
+        u = rand.uniform(0.0, 1.0, size=size)
+        return np.interp(u, cdf, x_grid)

jump_diffusion/distributions/kou.py

@@ -0,0 +1,104 @@
+"""
+Kou (2002) asymmetric double-exponential jump distribution.
+
+Jump sizes are a mixture of one-sided exponentials: with probability
+``jump_prob_up`` the jump is positive with mean ``jump_scale_up``, otherwise
+it is negative with mean magnitude ``jump_scale_down``. Unlike the
+symmetric-around-zero ``NormalJump``/``SkewNormalJump`` parameterizations,
+this distribution has no separate loc/skew parameter -- asymmetry comes
+directly from ``jump_prob_up`` and the two scales differing.
+
+The convolution of a one-sided exponential with an independent normal is the
+well-known exponentially-modified-Gaussian ("ex-Gaussian") density, already
+implemented (numerically stably, via ``erfcx``) as ``scipy.stats.exponnorm``.
+Kou's double-exponential is just a ``jump_prob_up``-weighted mixture of two
+such terms (one direct, one reflected for the downward branch), so the
+closed-form diffusion-convolved density below reuses ``exponnorm`` rather
+than re-deriving/re-implementing the stability tricks by hand. Verified
+against direct numerical convolution in tests.
+"""
+
+from typing import Dict, Optional, Tuple, cast
+
+import numpy as np
+from scipy.stats import expon, exponnorm
+
+from .base import JumpDistribution
+
+
+class KouJump(JumpDistribution):
+    """Jump sizes distributed as Kou's asymmetric double exponential."""
+
+    param_names: Tuple[str, ...] = ("jump_prob_up", "jump_scale_up", "jump_scale_down")
+
+    def default_params(self) -> Dict[str, float]:
+        return {"jump_prob_up": 0.5, "jump_scale_up": 0.1, "jump_scale_down": 0.1}
+
+    def pdf(self, x: np.ndarray, params: Dict[str, float]) -> np.ndarray:
+        p = params["jump_prob_up"]
+        x = np.asarray(x, dtype=float)
+        up = p * expon.pdf(x, scale=params["jump_scale_up"])
+        down = (1 - p) * expon.pdf(-x, scale=params["jump_scale_down"])
+        return cast(np.ndarray, up + down)
+
+    def param_bounds(self) -> Dict[str, Tuple[Optional[float], Optional[float]]]:
+        return {
+            "jump_prob_up": (1e-6, 1 - 1e-6),
+            "jump_scale_up": (1e-6, None),
+            "jump_scale_down": (1e-6, None),
+        }
+
+    def characteristic_scale(self, params: Dict[str, float]) -> float:
+        return max(params["jump_scale_up"], params["jump_scale_down"])
+
+    def initial_guess(
+        self,
+        mean_increment: float,
+        std_increment: float,
+        skewness: float,
+    ) -> Dict[str, float]:
+        return {
+            "jump_prob_up": float(np.clip(0.5 + 0.1 * np.sign(skewness), 0.1, 0.9)),
+            "jump_scale_up": std_increment * 0.5,
+            "jump_scale_down": std_increment * 0.5,
+        }
+
+    def diffusion_convolved_pdf(
+        self,
+        x: np.ndarray,
+        params: Dict[str, float],
+        diffusion_mean: float,
+        diffusion_std: float,
+    ) -> Optional[np.ndarray]:
+        p = params["jump_prob_up"]
+        x = np.asarray(x, dtype=float)
+
+        up = p * exponnorm.pdf(
+            x,
+            K=params["jump_scale_up"] / diffusion_std,
+            loc=diffusion_mean,
+            scale=diffusion_std,
+        )
+        down = (1 - p) * exponnorm.pdf(
+            -x,
+            K=params["jump_scale_down"] / diffusion_std,
+            loc=-diffusion_mean,
+            scale=diffusion_std,
+        )
+        return cast(np.ndarray, up + down)
+
+    def rvs(
+        self,
+        params: Dict[str, float],
+        size: int,
+        random_state: Optional[np.random.Generator] = None,
+    ) -> np.ndarray:
+        rand = random_state if random_state is not None else np.random
+        is_up = rand.uniform(0.0, 1.0, size=size) < params["jump_prob_up"]
+        up = expon.rvs(
+            scale=params["jump_scale_up"], size=size, random_state=random_state
+        )
+        down = expon.rvs(
+            scale=params["jump_scale_down"], size=size, random_state=random_state
+        )
+        return cast(np.ndarray, np.where(is_up, up, -down))

jump_diffusion/distributions/normal.py

@@ -0,0 +1,73 @@
+"""
+Normal jump distribution (Merton, 1976).
+
+The classic symmetric jump-diffusion model. Nested inside
+:class:`~jump_diffusion.distributions.skew_normal.SkewNormalJump` at
+``jump_skew=0``, which makes it a natural null model for a
+likelihood-ratio test against the skew-normal or SGED jump models.
+"""
+
+from typing import Dict, Optional, Tuple, cast
+
+import numpy as np
+from scipy.stats import norm
+
+from .base import JumpDistribution
+
+
+class NormalJump(JumpDistribution):
+    """
+    Jump sizes distributed as a normal centered at zero.
+
+    References:
+    - Merton, R. C. (1976). Option pricing when underlying stock returns
+      are discontinuous. Journal of financial economics, 3(1-2), 125-144.
+    """
+
+    param_names: Tuple[str, ...] = ("jump_scale",)
+
+    def default_params(self) -> Dict[str, float]:
+        return {"jump_scale": 0.15}
+
+    def pdf(self, x: np.ndarray, params: Dict[str, float]) -> np.ndarray:
+        return cast(np.ndarray, norm.pdf(x, loc=0, scale=params["jump_scale"]))
+
+    def param_bounds(self) -> Dict[str, Tuple[Optional[float], Optional[float]]]:
+        return {"jump_scale": (1e-6, None)}
+
+    def initial_guess(
+        self,
+        mean_increment: float,
+        std_increment: float,
+        skewness: float,
+    ) -> Dict[str, float]:
+        return {"jump_scale": std_increment * 0.5}
+
+    def diffusion_convolved_pdf(
+        self,
+        x: np.ndarray,
+        params: Dict[str, float],
+        diffusion_mean: float,
+        diffusion_std: float,
+    ) -> Optional[np.ndarray]:
+        combined_std = np.sqrt(diffusion_std**2 + params["jump_scale"] ** 2)
+        return cast(
+            np.ndarray,
+            norm.pdf(x, loc=diffusion_mean, scale=combined_std),
+        )
+
+    def rvs(
+        self,
+        params: Dict[str, float],
+        size: int,
+        random_state: Optional[np.random.Generator] = None,
+    ) -> np.ndarray:
+        return cast(
+            np.ndarray,
+            norm.rvs(
+                loc=0,
+                scale=params["jump_scale"],
+                size=size,
+                random_state=random_state,
+            ),
+        )

jump_diffusion/distributions/sged.py

@@ -0,0 +1,113 @@
+"""
+Skewed Generalized Error Distribution (SGED) jump distribution.
+
+Ported from Ospina Arango (2009), "Estimacion de un modelo de difusion con
+saltos con distribucion de error generalizada asimetrica usando algoritmos
+evolutivos" (Universidad Nacional de Colombia, Escuela de Estadistica). This
+is the Fernandez & Steel (1998) skewed extension of the Generalized Error
+Distribution (GED), in the parameterization used by the ``fGarch`` R
+package: X ~ SGED(loc, scale, nu, xi) has E[X] = loc and Var[X] = scale**2.
+
+Special cases (verified against the closed forms in tests):
+    nu=2, xi=1 -> standard normal
+    nu=1, xi=1 -> standard Laplace
+
+No closed form is known for the convolution of SGED with an independent
+normal, so this distribution relies on the generic FFT-convolution and
+inverse-CDF sampling fallbacks defined in ``JumpDistribution``.
+"""
+
+from typing import Dict, Optional, Tuple
+
+import numpy as np
+from scipy.special import gamma
+
+from .base import JumpDistribution
+
+
+def _ged_lambda(nu: float) -> float:
+    return float(np.sqrt(2 ** (-2 / nu) * gamma(1 / nu) / gamma(3 / nu)))
+
+
+def _ged_pdf(z: np.ndarray, nu: float) -> np.ndarray:
+    """Standardized (mean 0, var 1) Generalized Error Distribution pdf."""
+    lam = _ged_lambda(nu)
+    return (
+        nu
+        * np.exp(-0.5 * np.abs(z / lam) ** nu)
+        / (lam * 2 ** (1 + 1 / nu) * gamma(1 / nu))
+    )
+
+
+def _fernandez_steel_pdf(z: np.ndarray, nu: float, xi: float) -> np.ndarray:
+    """Fernandez & Steel skewed GED, not yet re-centered/re-scaled."""
+    sign = np.sign(z)
+    return (2.0 / (xi + 1.0 / xi)) * _ged_pdf(np.power(xi, -sign) * z, nu)
+
+
+def _skew_moments(nu: float, xi: float) -> Tuple[float, float]:
+    """Mean and std of the (not yet standardized) skewed GED."""
+    lam = _ged_lambda(nu)
+    m1 = gamma(2 / nu) * lam * 2 ** (1 / nu) / gamma(1 / nu)
+    m2 = gamma(3 / nu) * lam**2 * 2 ** (2 / nu) / gamma(1 / nu)
+    mu_xi = (xi - 1 / xi) * m1
+    sigma_xi2 = (xi**2 + 1 / xi**2) * (m2 - m1**2) + 2 * m1**2 - m2
+    return float(mu_xi), float(np.sqrt(sigma_xi2))
+
+
+def _standardized_sged_pdf(z: np.ndarray, nu: float, xi: float) -> np.ndarray:
+    """Mean-0, var-1 SGED density (eq. densidadsged in the thesis)."""
+    mu_xi, sigma_xi = _skew_moments(nu, xi)
+    z_xi = sigma_xi * z + mu_xi
+    return sigma_xi * _fernandez_steel_pdf(z_xi, nu, xi)
+
+
+class SGEDJump(JumpDistribution):
+    """
+    Jump sizes distributed as a Skewed Generalized Error Distribution.
+
+    References:
+    - Ospina Arango, J. D. (2009). Tesis de Maestría. Universidad Nacional de Colombia.
+    - Theodossiou, P. (2015). Skewed Generalized Error Distribution of
+      Financial Assets and Option Pricing. Multinational Finance Journal,
+      19(4), 223-266.
+    """
+
+    param_names: Tuple[str, ...] = ("jump_loc", "jump_scale", "jump_nu", "jump_xi")
+
+    def default_params(self) -> Dict[str, float]:
+        return {
+            "jump_loc": 0.0,
+            "jump_scale": 0.15,
+            "jump_nu": 2.0,
+            "jump_xi": 1.0,
+        }
+
+    def pdf(self, x: np.ndarray, params: Dict[str, float]) -> np.ndarray:
+        loc = params["jump_loc"]
+        scale = params["jump_scale"]
+        nu = params["jump_nu"]
+        xi = params["jump_xi"]
+        z = (np.asarray(x, dtype=float) - loc) / scale
+        return _standardized_sged_pdf(z, nu, xi) / scale
+
+    def param_bounds(self) -> Dict[str, Tuple[Optional[float], Optional[float]]]:
+        return {
+            "jump_loc": (None, None),
+            "jump_scale": (1e-6, None),
+            "jump_nu": (0.1, 30.0),
+            "jump_xi": (0.05, 20.0),
+        }
+
+    def initial_guess(
+        self,
+        mean_increment: float,
+        std_increment: float,
+        skewness: float,
+    ) -> Dict[str, float]:
+        return {
+            "jump_loc": 0.0,
+            "jump_scale": std_increment * 0.5,
+            "jump_nu": 2.0,
+            "jump_xi": 1.0 + float(np.sign(skewness)) * 0.3,
+        }

jump_diffusion/distributions/skew_normal.py

@@ -0,0 +1,97 @@
+"""
+Skew-normal jump distribution.
+
+Migrated from the logic previously hardcoded in ``JumpDiffusionModel``. The
+skew-normal family is closed under convolution with an independent normal
+(Azzalini & Henze, 1986), which is why a closed-form diffusion-convolved
+density is available here instead of falling back to FFT convolution.
+"""
+
+from typing import Dict, Optional, Tuple, cast
+
+import numpy as np
+from scipy.stats import skewnorm
+
+from .base import JumpDistribution
+
+
+class SkewNormalJump(JumpDistribution):
+    """Jump sizes distributed as a skew-normal centered at zero."""
+
+    param_names: Tuple[str, ...] = ("jump_scale", "jump_skew")
+
+    def default_params(self) -> Dict[str, float]:
+        return {"jump_scale": 0.15, "jump_skew": 0.0}
+
+    def pdf(self, x: np.ndarray, params: Dict[str, float]) -> np.ndarray:
+        return cast(
+            np.ndarray,
+            skewnorm.pdf(
+                x,
+                a=params["jump_skew"],
+                loc=0,
+                scale=params["jump_scale"],
+            ),
+        )
+
+    def param_bounds(self) -> Dict[str, Tuple[Optional[float], Optional[float]]]:
+        return {
+            "jump_scale": (1e-6, None),
+            "jump_skew": (-10, 10),
+        }
+
+    def initial_guess(
+        self,
+        mean_increment: float,
+        std_increment: float,
+        skewness: float,
+    ) -> Dict[str, float]:
+        return {
+            "jump_scale": std_increment * 0.5,
+            "jump_skew": float(np.sign(skewness)) * 2.0,
+        }
+
+    def diffusion_convolved_pdf(
+        self,
+        x: np.ndarray,
+        params: Dict[str, float],
+        diffusion_mean: float,
+        diffusion_std: float,
+    ) -> Optional[np.ndarray]:
+        omega = params["jump_scale"]
+        alpha = params["jump_skew"]
+
+        combined_var = diffusion_std**2 + omega**2
+        combined_std = np.sqrt(combined_var)
+
+        # Azzalini & Henze (1986): SN(0,omega,alpha) + N(0,diffusion_std^2)
+        # is again skew-normal, but the new shape parameter is obtained by
+        # going through the "delta" parameterization (delta = alpha /
+        # sqrt(1+alpha^2)), not simply alpha*omega/combined_std -- that
+        # simpler-looking expression is off by ~0.2% at alpha=2, verified
+        # against direct numerical convolution.
+        delta = alpha / np.sqrt(1 + alpha**2)
+        adjusted_delta = omega * delta / combined_std
+        adjusted_skew = adjusted_delta / np.sqrt(1 - adjusted_delta**2)
+
+        return cast(
+            np.ndarray,
+            skewnorm.pdf(x, a=adjusted_skew, loc=diffusion_mean, scale=combined_std),
+        )
+
+    def rvs(
+        self,
+        params: Dict[str, float],
+        size: int,
+        random_state: Optional[np.random.Generator] = None,
+    ) -> np.ndarray:
+        return cast(
+            np.ndarray,
+            skewnorm.rvs(
+                a=params["jump_skew"],
+                loc=0,
+                scale=params["jump_scale"],
+                size=size,
+                random_state=random_state,
+            ),
+        )

jump_diffusion/distributions/student_t.py

@@ -0,0 +1,86 @@
+"""
+Student-t jump distribution.
+
+Location-scale Student-t, standardized so that ``jump_scale`` is the actual
+standard deviation of the jump (matching the convention used elsewhere in
+this package -- e.g. ``SGEDJump`` -- rather than scipy's raw ``t`` scale
+parameter, whose relationship to the standard deviation depends on the
+degrees of freedom). This is the same "standardized Student-t"
+parameterization used for Student-t innovations in GARCH-t models
+(Bollerslev, 1987): ``jump_df`` alone controls tail fatness, independent of
+overall spread.
+
+No closed form is known for the convolution of Student-t with an
+independent normal, so this distribution relies on the generic
+FFT-convolution and inverse-CDF fallbacks defined in ``JumpDistribution``.
+"""
+
+from typing import Dict, Optional, Tuple, cast
+
+import numpy as np
+from scipy.stats import t
+
+from .base import JumpDistribution
+
+
+def _scipy_scale(scale: float, df: float) -> float:
+    """Convert the standardized (std-dev) scale to scipy's raw ``t`` scale."""
+    return scale * np.sqrt((df - 2) / df)
+
+
+class StudentTJump(JumpDistribution):
+    """Jump sizes distributed as a (standardized) Student-t."""
+
+    param_names: Tuple[str, ...] = ("jump_loc", "jump_scale", "jump_df")
+
+    def default_params(self) -> Dict[str, float]:
+        return {"jump_loc": 0.0, "jump_scale": 0.15, "jump_df": 5.0}
+
+    def pdf(self, x: np.ndarray, params: Dict[str, float]) -> np.ndarray:
+        df = params["jump_df"]
+        return cast(
+            np.ndarray,
+            t.pdf(
+                x,
+                df=df,
+                loc=params["jump_loc"],
+                scale=_scipy_scale(params["jump_scale"], df),
+            ),
+        )
+
+    def param_bounds(self) -> Dict[str, Tuple[Optional[float], Optional[float]]]:
+        return {
+            "jump_loc": (None, None),
+            "jump_scale": (1e-6, None),
+            "jump_df": (2.05, 100.0),
+        }
+
+    def initial_guess(
+        self,
+        mean_increment: float,
+        std_increment: float,
+        skewness: float,
+    ) -> Dict[str, float]:
+        return {
+            "jump_loc": float(np.sign(skewness)) * std_increment * 0.1,
+            "jump_scale": std_increment * 0.5,
+            "jump_df": 5.0,
+        }
+
+    def rvs(
+        self,
+        params: Dict[str, float],
+        size: int,
+        random_state: Optional[np.random.Generator] = None,
+    ) -> np.ndarray:
+        df = params["jump_df"]
+        return cast(
+            np.ndarray,
+            t.rvs(
+                df=df,
+                loc=params["jump_loc"],
+                scale=_scipy_scale(params["jump_scale"], df),
+                size=size,
+                random_state=random_state,
+            ),
+        )