stokestrel 0.1.0__py3-none-any.whl

kestrel/jump_diffusion/__init__.py

@@ -0,0 +1,5 @@
+"""Jump diffusion processes."""
+
+from kestrel.jump_diffusion.merton import MertonProcess
+
+__all__ = ["MertonProcess"]

kestrel/jump_diffusion/merton.py

@@ -0,0 +1,375 @@
+# kestrel/jump_diffusion/merton.py
+"""Merton Jump Diffusion process implementation."""
+
+import math
+import numpy as np
+import pandas as pd
+from scipy.optimize import minimize
+from scipy.stats import norm
+from kestrel.base import StochasticProcess
+from kestrel.utils.kestrel_result import KestrelResult
+
+
+class MertonProcess(StochasticProcess):
+    """
+    Merton Jump Diffusion Process.
+
+    Combines Brownian motion with Poisson-distributed jumps.
+    For log-returns: r_t = (mu - 0.5*sigma^2 - lambda*k) dt + sigma dW_t + J_t dN_t
+
+    Where J_t ~ N(jump_mu, jump_sigma^2) and N_t is Poisson(lambda).
+
+    Parameters
+    ----------
+    mu : float, optional
+        Drift of continuous component.
+    sigma : float, optional
+        Volatility of continuous component.
+    lambda_ : float, optional
+        Jump intensity (expected jumps per unit time).
+    jump_mu : float, optional
+        Mean of jump size distribution.
+    jump_sigma : float, optional
+        Standard deviation of jump size distribution.
+    """
+
+    def __init__(self, mu: float = None, sigma: float = None,
+                 lambda_: float = None, jump_mu: float = None, jump_sigma: float = None):
+        super().__init__()
+        self.mu = mu
+        self.sigma = sigma
+        self.lambda_ = lambda_
+        self.jump_mu = jump_mu
+        self.jump_sigma = jump_sigma
+
+    def fit(self, data: pd.Series, dt: float = None, method: str = 'mle'):
+        """
+        Estimates parameters from log-return time-series data.
+
+        Parameters
+        ----------
+        data : pd.Series
+            Log-returns (or price levels, which are converted to log-returns).
+        dt : float, optional
+            Time step between observations.
+        method : str
+            Estimation method: 'mle' only currently supported.
+
+        Raises
+        ------
+        ValueError
+            If data not pandas Series or unknown method.
+        """
+        if not isinstance(data, pd.Series):
+            raise ValueError("Input data must be a pandas Series.")
+
+        if dt is None:
+            dt = self._infer_dt(data)
+
+        self.dt_ = dt
+
+        if method == 'mle':
+            param_ses = self._fit_mle(data, dt)
+        else:
+            raise ValueError(f"Unknown estimation method: {method}. Choose 'mle'.")
+
+        self._set_params(
+            last_data_point=data.iloc[-1],
+            mu=self.mu,
+            sigma=self.sigma,
+            lambda_=self.lambda_,
+            jump_mu=self.jump_mu,
+            jump_sigma=self.jump_sigma,
+            dt=self.dt_,
+            param_ses=param_ses
+        )
+
+    def _infer_dt(self, data: pd.Series) -> float:
+        """Infers dt from DatetimeIndex or defaults to 1.0."""
+        if isinstance(data.index, pd.DatetimeIndex):
+            if len(data.index) < 2:
+                return 1.0
+
+            inferred_timedelta = data.index[1] - data.index[0]
+            current_freq = pd.infer_freq(data.index)
+            if current_freq is None:
+                current_freq = 'B'
+
+            if current_freq in ['B', 'C', 'D']:
+                dt = inferred_timedelta / pd.Timedelta(days=252.0)
+            elif current_freq.startswith('W'):
+                dt = inferred_timedelta / pd.Timedelta(weeks=52)
+            elif current_freq in ['M', 'MS', 'BM', 'BMS']:
+                dt = inferred_timedelta / pd.Timedelta(days=365 / 12)
+            elif current_freq in ['Q', 'QS', 'BQ', 'BQS']:
+                dt = inferred_timedelta / pd.Timedelta(days=365 / 4)
+            elif current_freq in ['A', 'AS', 'BA', 'BAS', 'Y', 'YS', 'BY', 'BYS']:
+                dt = inferred_timedelta / pd.Timedelta(days=365)
+            else:
+                dt = inferred_timedelta.total_seconds() / (365 * 24 * 3600)
+
+            return max(dt, 1e-10)
+        return 1.0
+
+    def _fit_mle(self, data: pd.Series, dt: float) -> dict:
+        """
+        Estimates Merton parameters using Maximum Likelihood.
+
+        Uses mixture density approach where observation density is weighted
+        sum over possible jump counts.
+        """
+        if len(data) < 10:
+            raise ValueError("MLE estimation requires at least 10 data points.")
+
+        returns = data.values
+        n = len(returns)
+
+        # Initial parameter estimates from moments
+        mean_r = np.mean(returns)
+        var_r = np.var(returns)
+        skew_r = self._skewness(returns)
+        kurt_r = self._kurtosis(returns)
+
+        # Method of moments initial guess
+        # Excess kurtosis suggests jumps; higher kurtosis = more/larger jumps
+        excess_kurt = max(0, kurt_r - 3)
+
+        if excess_kurt > 0.5:
+            # Evidence of jumps
+            lambda_0 = min(2.0, max(0.1, excess_kurt / 2))
+            jump_sigma_0 = np.sqrt(var_r * 0.3)
+            sigma_0 = np.sqrt(max(0.01, var_r * 0.7 / dt))
+        else:
+            # Weak evidence of jumps
+            lambda_0 = 0.1
+            jump_sigma_0 = np.sqrt(var_r * 0.1)
+            sigma_0 = np.sqrt(max(0.01, var_r * 0.9 / dt))
+
+        mu_0 = mean_r / dt
+        jump_mu_0 = 0.0  # Symmetric jumps initially
+
+        initial_params = [mu_0, sigma_0, lambda_0, jump_mu_0, jump_sigma_0]
+        bounds = [
+            (None, None),      # mu
+            (1e-6, None),      # sigma
+            (1e-6, 10.0),      # lambda_
+            (None, None),      # jump_mu
+            (1e-6, None)       # jump_sigma
+        ]
+
+        result = minimize(
+            self._neg_log_likelihood,
+            initial_params,
+            args=(returns, dt),
+            bounds=bounds,
+            method='L-BFGS-B',
+            options={'maxiter': 500}
+        )
+
+        if result.success:
+            self.mu, self.sigma, self.lambda_, self.jump_mu, self.jump_sigma = result.x
+        else:
+            # Fallback to moment estimates
+            self.mu = mu_0
+            self.sigma = sigma_0
+            self.lambda_ = lambda_0
+            self.jump_mu = jump_mu_0
+            self.jump_sigma = jump_sigma_0
+
+        # Ensure sigma and jump_sigma are positive
+        self.sigma = max(1e-6, self.sigma)
+        self.lambda_ = max(1e-6, self.lambda_)
+        self.jump_sigma = max(1e-6, self.jump_sigma)
+
+        param_ses = self._compute_standard_errors(
+            result,
+            ['mu', 'sigma', 'lambda_', 'jump_mu', 'jump_sigma']
+        )
+        return param_ses
+
+    def _neg_log_likelihood(self, params, returns, dt):
+        """
+        Negative log-likelihood for Merton model.
+
+        Density is mixture over Poisson jump counts:
+        f(r) = sum_{k=0}^{K} P(N=k) * phi(r; mu_k, sigma_k^2)
+
+        where mu_k = (mu - 0.5*sigma^2)*dt + k*jump_mu
+              sigma_k^2 = sigma^2*dt + k*jump_sigma^2
+        """
+        mu, sigma, lambda_, jump_mu, jump_sigma = params
+
+        if sigma <= 0 or lambda_ < 0 or jump_sigma <= 0:
+            return np.inf
+
+        n = len(returns)
+        ll = 0.0
+
+        # Truncate Poisson sum at reasonable number of jumps
+        max_jumps = max(10, int(3 * lambda_ * dt + 5))
+
+        for r in returns:
+            density = 0.0
+
+            for k in range(max_jumps + 1):
+                # Poisson probability of k jumps
+                poisson_prob = self._poisson_pmf(k, lambda_ * dt)
+
+                # Conditional mean and variance given k jumps
+                mean_k = (mu - 0.5 * sigma ** 2) * dt + k * jump_mu
+                var_k = sigma ** 2 * dt + k * jump_sigma ** 2
+
+                if var_k <= 0:
+                    continue
+
+                # Gaussian density contribution
+                density += poisson_prob * norm.pdf(r, loc=mean_k, scale=np.sqrt(var_k))
+
+            if density <= 1e-300:
+                ll += -700  # Log of very small number
+            else:
+                ll += np.log(density)
+
+        return -ll
+
+    def _poisson_pmf(self, k: int, lam: float) -> float:
+        """Poisson probability mass function."""
+        if lam <= 0:
+            return 1.0 if k == 0 else 0.0
+        return np.exp(-lam) * (lam ** k) / math.factorial(k)
+
+    def _skewness(self, x: np.ndarray) -> float:
+        """Computes sample skewness."""
+        n = len(x)
+        mean = np.mean(x)
+        std = np.std(x, ddof=0)
+        if std == 0:
+            return 0.0
+        return np.sum((x - mean) ** 3) / (n * std ** 3)
+
+    def _kurtosis(self, x: np.ndarray) -> float:
+        """Computes sample kurtosis (not excess)."""
+        n = len(x)
+        mean = np.mean(x)
+        std = np.std(x, ddof=0)
+        if std == 0:
+            return 3.0
+        return np.sum((x - mean) ** 4) / (n * std ** 4)
+
+    def _compute_standard_errors(self, result, param_names: list) -> dict:
+        """Computes standard errors from optimisation result."""
+        param_ses = {}
+        if hasattr(result, 'hess_inv') and result.hess_inv is not None:
+            if callable(getattr(result.hess_inv, 'todense', None)):
+                cov_matrix = result.hess_inv.todense()
+            else:
+                cov_matrix = result.hess_inv
+
+            if cov_matrix.shape == (len(param_names), len(param_names)):
+                for i, name in enumerate(param_names):
+                    param_ses[name] = np.sqrt(max(0, cov_matrix[i, i]))
+            else:
+                for name in param_names:
+                    param_ses[name] = np.nan
+        else:
+            for name in param_names:
+                param_ses[name] = np.nan
+
+        return param_ses
+
+    def sample(self, n_paths: int = 1, horizon: int = 1, dt: float = None) -> KestrelResult:
+        """
+        Simulates future paths of Merton Jump Diffusion.
+
+        Parameters
+        ----------
+        n_paths : int
+            Number of simulation paths.
+        horizon : int
+            Number of time steps to simulate.
+        dt : float, optional
+            Simulation time step. Uses fitted dt if None.
+
+        Returns
+        -------
+        KestrelResult
+            Simulation results containing log-return paths.
+        """
+        if not self.is_fitted and any(p is None for p in
+                                       [self.mu, self.sigma, self.lambda_, self.jump_mu, self.jump_sigma]):
+            raise RuntimeError("Model must be fitted or initialised with parameters before sampling.")
+
+        if dt is None:
+            dt = self._dt_ if self.is_fitted and hasattr(self, '_dt_') else 1.0
+
+        mu = self.mu_ if self.is_fitted else self.mu
+        sigma = self.sigma_ if self.is_fitted else self.sigma
+        lambda_ = self.lambda__ if self.is_fitted else self.lambda_
+        jump_mu = self.jump_mu_ if self.is_fitted else self.jump_mu
+        jump_sigma = self.jump_sigma_ if self.is_fitted else self.jump_sigma
+
+        if any(p is None for p in [mu, sigma, lambda_, jump_mu, jump_sigma]):
+            raise RuntimeError("Merton parameters must be set or estimated to sample.")
+
+        paths = np.zeros((horizon + 1, n_paths))
+        if self.is_fitted and hasattr(self, '_last_data_point'):
+            initial_val = self._last_data_point
+        else:
+            initial_val = 0.0
+
+        paths[0, :] = initial_val
+
+        for t in range(horizon):
+            # Continuous component (Brownian motion)
+            dW = np.random.normal(loc=0.0, scale=np.sqrt(dt), size=n_paths)
+            continuous_step = (mu - 0.5 * sigma ** 2) * dt + sigma * dW
+
+            # Jump component (Poisson process with normal jump sizes)
+            num_jumps = np.random.poisson(lambda_ * dt, size=n_paths)
+            jump_sizes = np.zeros(n_paths)
+
+            for i in range(n_paths):
+                if num_jumps[i] > 0:
+                    # Sum of normal jumps
+                    individual_jumps = np.random.normal(
+                        loc=jump_mu,
+                        scale=jump_sigma,
+                        size=num_jumps[i]
+                    )
+                    jump_sizes[i] = np.sum(individual_jumps)
+
+            paths[t + 1, :] = paths[t, :] + continuous_step + jump_sizes
+
+        return KestrelResult(pd.DataFrame(paths), initial_value=initial_val)
+
+    def expected_return(self) -> float:
+        """
+        Computes expected return per unit time.
+
+        E[r] = mu - 0.5*sigma^2 + lambda*jump_mu
+        """
+        mu = self.mu_ if self.is_fitted else self.mu
+        sigma = self.sigma_ if self.is_fitted else self.sigma
+        lambda_ = self.lambda__ if self.is_fitted else self.lambda_
+        jump_mu = self.jump_mu_ if self.is_fitted else self.jump_mu
+
+        if any(p is None for p in [mu, sigma, lambda_, jump_mu]):
+            raise RuntimeError("Parameters must be set or estimated first.")
+
+        return mu - 0.5 * sigma ** 2 + lambda_ * jump_mu
+
+    def total_variance(self) -> float:
+        """
+        Computes total variance per unit time.
+
+        Var[r] = sigma^2 + lambda*(jump_mu^2 + jump_sigma^2)
+        """
+        sigma = self.sigma_ if self.is_fitted else self.sigma
+        lambda_ = self.lambda__ if self.is_fitted else self.lambda_
+        jump_mu = self.jump_mu_ if self.is_fitted else self.jump_mu
+        jump_sigma = self.jump_sigma_ if self.is_fitted else self.jump_sigma
+
+        if any(p is None for p in [sigma, lambda_, jump_mu, jump_sigma]):
+            raise RuntimeError("Parameters must be set or estimated first.")
+
+        return sigma ** 2 + lambda_ * (jump_mu ** 2 + jump_sigma ** 2)

kestrel/utils/__init__.py

@@ -0,0 +1,5 @@
+"""Utility classes and functions."""
+
+from kestrel.utils.kestrel_result import KestrelResult
+
+__all__ = ["KestrelResult"]

kestrel/utils/kestrel_result.py

@@ -0,0 +1,67 @@
+# kestrel/utils/kestrel_result.py
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from typing import Optional
+
+class KestrelResult:
+    """
+    A wrapper for simulation results, providing enhanced functionality.
+
+    This class holds simulation paths, typically a pandas DataFrame,
+    and offers convenience methods for plotting and analysis.
+    """
+    def __init__(self, paths: pd.DataFrame, initial_value: Optional[float] = None):
+        if not isinstance(paths, pd.DataFrame):
+            raise TypeError("`paths` must be a pandas DataFrame.")
+        self._paths = paths
+        self._initial_value = initial_value
+
+    @property
+    def paths(self) -> pd.DataFrame:
+        """
+        Returns the underlying DataFrame of simulation paths.
+        """
+        return self._paths
+
+    def plot(self, title: str = "Simulation Paths", xlabel: str = "Time Step",
+             ylabel: str = "Value", figsize: tuple = (10, 6), **kwargs):
+        """
+        Plots the simulation paths.
+
+        Args:
+            title (str): Plot title.
+            xlabel (str): Label for the x-axis.
+            ylabel (str): Label for the y-axis.
+            figsize (tuple): Figure size (width, height).
+            **kwargs: Additional keyword arguments passed to `DataFrame.plot()`.
+        """
+        ax = self._paths.plot(figsize=figsize, title=title, legend=False, **kwargs)
+        ax.set_xlabel(xlabel)
+        ax.set_ylabel(ylabel)
+        plt.grid(True, linestyle=':', alpha=0.7)
+        plt.show()
+
+    def mean_path(self) -> pd.Series:
+        """
+        Calculates the mean path across all simulations.
+        """
+        return self._paths.mean(axis=1)
+
+    def percentile_paths(self, percentiles: list = [25, 50, 75]) -> pd.DataFrame:
+        """
+        Calculates percentile paths for the simulations.
+
+        Args:
+            percentiles (list): List of percentiles to calculate (e.g., [25, 50, 75]).
+
+        Returns:
+            pd.DataFrame: DataFrame with percentile paths.
+        """
+        return self._paths.quantile(np.array(percentiles) / 100, axis=1).T
+
+    def __repr__(self) -> str:
+        return f"KestrelResult(paths_shape={self._paths.shape}, initial_value={self._initial_value})"
+
+    def __str__(self) -> str:
+        return self.__repr__()

stokestrel-0.1.0.dist-info/METADATA

@@ -0,0 +1,234 @@
+Metadata-Version: 2.4
+Name: stokestrel
+Version: 0.1.0
+Summary: A modern stochastic modelling library for parameter estimation and Monte Carlo simulation.
+Author-email: April Kidd <bk0851@outlook.com>
+License: MIT
+Project-URL: Homepage, https://github.com/april-webm/kestrel
+Project-URL: Documentation, https://github.com/april-webm/kestrel#readme
+Project-URL: Repository, https://github.com/april-webm/kestrel
+Project-URL: Issues, https://github.com/april-webm/kestrel/issues
+Project-URL: Changelog, https://github.com/april-webm/kestrel/releases
+Keywords: stochastic,sde,monte-carlo,simulation,ornstein-uhlenbeck,brownian-motion,quantitative-finance,time-series
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Office/Business :: Financial
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20
+Requires-Dist: scipy>=1.7
+Requires-Dist: pandas>=1.3
+Requires-Dist: matplotlib>=3.4
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Dynamic: license-file
+
+# Kestrel
+
+<!-- TODO: Add kestrel image -->
+<p align="center">
+  <img src="assets/kestrel.png" alt="Kestrel" width="200">
+</p>
+
+[![PyPI version](https://img.shields.io/pypi/v/stokestrel.svg)](https://pypi.org/project/stokestrel/)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+A modern Python library for stochastic process modelling, parameter estimation, and Monte Carlo simulation.
+
+## Overview
+
+Kestrel provides a unified, scikit-learn-style interface for working with stochastic differential equations (SDEs). The library supports parameter estimation from time-series data and path simulation for a variety of continuous and jump-diffusion processes.
+
+### Supported Processes
+
+| Process | Module | Description |
+|---------|--------|-------------|
+| Brownian Motion | `kestrel.diffusion` | Standard Wiener process with drift |
+| Geometric Brownian Motion | `kestrel.diffusion` | Log-normal price dynamics (Black-Scholes) |
+| Ornstein-Uhlenbeck | `kestrel.diffusion` | Mean-reverting Gaussian process |
+| Cox-Ingersoll-Ross | `kestrel.diffusion` | Mean-reverting process with state-dependent volatility |
+| Merton Jump Diffusion | `kestrel.jump_diffusion` | GBM with Poisson-distributed jumps |
+
+### Key Features
+
+- **Consistent API**: All processes follow `fit()` / `sample()` pattern
+- **Multiple Estimation Methods**: MLE, AR(1) regression, least squares
+- **Standard Error Reporting**: Parameter uncertainty quantification
+- **Flexible Time Handling**: Automatic dt inference from DatetimeIndex
+- **Simulation Engine**: Euler-Maruyama discretisation with exact solutions where available
+
+## Installation
+
+**Requirements**: Python 3.9+
+
+```bash
+pip install stokestrel
+```
+
+For development installation:
+
+```bash
+git clone https://github.com/april-webm/kestrel.git
+cd kestrel
+pip install -e ".[dev]"
+```
+
+## Quick Start
+
+```python
+from kestrel import OUProcess
+import pandas as pd
+
+# Load or generate time-series data
+data = pd.Series([...])  # Your observed data
+
+# Fit model parameters
+model = OUProcess()
+model.fit(data, dt=1/252, method='mle')
+
+# View estimated parameters and standard errors
+print(f"Mean reversion speed: {model.theta_:.4f} ± {model.theta_se_:.4f}")
+print(f"Long-run mean: {model.mu_:.4f} ± {model.mu_se_:.4f}")
+print(f"Volatility: {model.sigma_:.4f} ± {model.sigma_se_:.4f}")
+
+# Simulate future paths
+paths = model.sample(n_paths=1000, horizon=252)
+paths.plot(title="OU Process Simulation")
+```
+
+## Usage Examples
+
+### Ornstein-Uhlenbeck Process
+
+Mean-reverting process commonly used for interest rates and volatility modelling.
+
+```python
+from kestrel import OUProcess
+
+model = OUProcess()
+model.fit(data, dt=1/252, method='mle')  # or method='ar1'
+
+# Simulate from fitted model
+simulation = model.sample(n_paths=100, horizon=50)
+```
+
+### Geometric Brownian Motion
+
+Standard model for equity prices.
+
+```python
+from kestrel import GeometricBrownianMotion
+
+model = GeometricBrownianMotion()
+model.fit(price_data, dt=1/252)
+
+# Expected price and variance at horizon
+expected = model.expected_price(t=1.0, s0=100)
+variance = model.variance_price(t=1.0, s0=100)
+```
+
+### Cox-Ingersoll-Ross Process
+
+Ensures non-negativity; suitable for interest rate modelling.
+
+```python
+from kestrel import CIRProcess
+
+model = CIRProcess()
+model.fit(rate_data, dt=1/252, method='mle')
+
+# Check Feller condition for strict positivity
+if model.feller_condition_satisfied():
+    print("Process guaranteed to remain positive")
+```
+
+### Merton Jump Diffusion
+
+Captures sudden market movements via Poisson jumps.
+
+```python
+from kestrel import MertonProcess
+
+model = MertonProcess()
+model.fit(log_returns, dt=1/252)
+
+# Jump-adjusted expected return
+total_drift = model.expected_return()
+total_var = model.total_variance()
+```
+
+## API Reference
+
+### Base Interface
+
+All stochastic processes inherit from `StochasticProcess` and implement:
+
+| Method | Description |
+|--------|-------------|
+| `fit(data, dt, method)` | Estimate parameters from time-series |
+| `sample(n_paths, horizon, dt)` | Generate Monte Carlo paths |
+| `is_fitted` | Property indicating fit status |
+| `params` | Dictionary of estimated parameters |
+
+### Fitted Attributes
+
+After calling `fit()`, estimated parameters are available as attributes with trailing underscore:
+
+```python
+model.theta_      # Estimated parameter value
+model.theta_se_   # Standard error of estimate
+```
+
+## Dependencies
+
+- numpy
+- scipy
+- pandas
+- matplotlib
+
+## Testing
+
+```bash
+pytest tests/ -v
+```
+
+## Contributing
+
+Contributions are welcome. Please ensure:
+
+1. Code follows existing style conventions
+2. New features include appropriate tests
+3. Documentation is updated accordingly
+
+## License
+
+Released under the MIT License. See [LICENSE](LICENSE) for details.
+
+## Citation
+
+If Kestrel is used in academic research, citation is appreciated:
+
+```bibtex
+@software{stokestrel,
+  title = {Stokestrel: A Modern Stochastic Modelling Library},
+  author = {Kidd, April},
+  url = {https://github.com/april-webm/kestrel},
+  version = {0.1.0},
+  year = {2024}
+}
+```