voly 0.0.138__py3-none-any.whl → 0.0.140__py3-none-any.whl

voly/client.py

@@ -20,7 +20,7 @@ from voly.formulas import (
 from voly.core.data import fetch_option_chain, process_option_chain
 from voly.core.fit import fit_model, get_iv_surface
 from voly.core.rnd import get_rnd_surface
-from voly.core.hd import get_historical_data, get_hd_surface, get_garch_hd_surface
+from voly.core.hd import get_historical_data, get_hd_surface
 from voly.core.interpolate import interpolate_model
 from voly.core.charts import (
     plot_all_smiles, plot_raw_parameters, plot_jw_parameters, plot_fit_performance, plot_3d_surface,
@@ -342,59 +342,38 @@ class VolyClient:
     def get_hd_surface(model_results: pd.DataFrame,
                        df_hist: pd.DataFrame,
                        domain_params: Tuple[float, float, int] = (-1.5, 1.5, 1000),
-                       return_domain: str = 'log_moneyness') -> Dict[str, Any]:
-
-        logger.info("Calculating historical density surface")
-
-        return get_hd_surface(
-            model_results=model_results,
-            df_hist=df_hist,
-            domain_params=domain_params,
-            return_domain=return_domain
-        )
-
-    @staticmethod
-    def get_garch_hd_surface(model_results: pd.DataFrame,
-                             df_hist: pd.DataFrame,
-                             domain_params: Tuple[float, float, int] = (-1.5, 1.5, 1000),
-                             return_domain: str = 'log_moneyness',
-                             n_fits: int = 400,
-                             simulations: int = 5000,
-                             window_length: int = 365,
-                             variate_parameters: bool = True,
-                             bandwidth: float = 0.15) -> Dict[str, Any]:
+                       return_domain: str = 'log_moneyness',
+                       method: str = 'garch',
+                       **kwargs) -> Dict[str, Any]:
         """
-        Generate historical density using GARCH(1,1) model and Monte Carlo simulation.
-
-        This method implements the approach from SPD Trading, using:
-        1. GARCH(1,1) model fit with sliding windows
-        2. Monte Carlo simulation with innovation resampling
-        3. Kernel density estimation of terminal prices
+        Generate historical density surface from historical price data.
 
         Parameters:
             model_results: DataFrame with model parameters and maturities
             df_hist: DataFrame with historical price data
             domain_params: Tuple of (min, max, num_points) for x-domain
             return_domain: Domain for x-axis values ('log_moneyness', 'moneyness', 'returns', 'strikes')
-            n_fits: Number of sliding windows for GARCH parameter estimation
-            simulations: Number of Monte Carlo simulations
-            window_length: Length of each sliding window for GARCH estimation
-            variate_parameters: Whether to vary GARCH parameters between simulations
-            bandwidth: Bandwidth for KDE of final density
+            method: Method to use for HD estimation ('hist_returns' or 'garch')
+            **kwargs: Additional parameters for specific methods:
+                For 'garch' method:
+                    n_fits: Number of sliding windows (default: 400)
+                    simulations: Number of Monte Carlo simulations (default: 5000)
+                    window_length: Length of sliding windows (default: 365)
+                    variate_parameters: Whether to vary GARCH parameters (default: True)
+                    bandwidth: KDE bandwidth (default: 'silverman')
+                For 'hist_returns' method:
+                    bandwidth: KDE bandwidth (default: 'silverman')
 
         Returns:
             Dictionary containing pdf_surface, cdf_surface, x_surface, and moments
         """
-        logger.info("Calculating GARCH historical density surface")
+        logger.info(f"Calculating historical density surface using {method} method")
 
-        return get_garch_hd_surface(
+        return get_hd_surface(
             model_results=model_results,
             df_hist=df_hist,
             domain_params=domain_params,
             return_domain=return_domain,
-            n_fits=n_fits,
-            simulations=simulations,
-            window_length=window_length,
-            variate_parameters=variate_parameters,
-            bandwidth=bandwidth
+            method=method,
+            **kwargs
         )

voly/core/hd.py

@@ -79,189 +79,40 @@ def get_historical_data(currency, lookback_days, granularity, exchange_name):
 
 
 @catch_exception
-def get_hd_surface(model_results: pd.DataFrame,
-                   df_hist: pd.DataFrame,
-                   domain_params: Tuple[float, float, int] = (-1.5, 1.5, 1000),
-                   return_domain: str = 'log_moneyness') -> Tuple[
-    Dict[str, np.ndarray], Dict[str, np.ndarray], Dict[str, np.ndarray], pd.DataFrame]:
-
-    # Check if required columns are present
-    required_columns = ['s', 't', 'r']
-    missing_columns = [col for col in required_columns if col not in model_results.columns]
-    if missing_columns:
-        raise VolyError(f"Required columns missing in model_results: {missing_columns}")
-
-    # Determine granularity from df_hist
-    if len(df_hist) > 1:
-        # Calculate minutes between consecutive timestamps
-        minutes_diff = (df_hist.index[1] - df_hist.index[0]).total_seconds() / 60
-        minutes_per_period = int(minutes_diff)
-    else:
-        VolyError("Cannot determine granularity from df_hist.")
-        return
-
-    pdf_surface = {}
-    cdf_surface = {}
-    x_surface = {}
-    all_moments = {}
-
-    # Process each maturity
-    for i in model_results.index:
-        # Get parameters for this maturity
-        s = model_results.loc[i, 's']
-        r = model_results.loc[i, 'r']
-        t = model_results.loc[i, 't']
-
-        LM = get_domain(domain_params, s, r, None, t, 'log_moneyness')
-        M = get_domain(domain_params, s, r, None, t, 'moneyness')
-        R = get_domain(domain_params, s, r, None, t, 'returns')
-        K = get_domain(domain_params, s, r, None, t, 'log_moneyness')
-
-        # Filter historical data for this maturity's lookback period
-        start_date = dt.datetime.now() - dt.timedelta(days=int(t * 365.25))
-        maturity_hist = df_hist[df_hist.index >= start_date].copy()
-
-        if len(maturity_hist) < 2:
-            logger.warning(f"Not enough historical data for maturity {i}, skipping.")
-            continue
-
-        # Calculate the number of periods that match the time to expiry
-        n_periods = int(t * 365.25 * 24 * 60 / minutes_per_period)
-
-        # Compute returns and weights
-        maturity_hist['returns'] = np.log(maturity_hist['close'] / maturity_hist['close'].shift(1)) * np.sqrt(n_periods)
-        maturity_hist = maturity_hist.dropna()
-
-        returns = maturity_hist['returns'].values
-
-        if len(returns) < 10:
-            logger.warning(f"Not enough valid returns for maturity {i}, skipping.")
-            continue
-
-        mu_scaled = returns.mean()
-        sigma_scaled = returns.std()
-
-        # Correct Girsanov adjustment to match the risk-neutral mean
-        expected_risk_neutral_mean = (r - 0.5 * sigma_scaled ** 2) * np.sqrt(t)
-        adjustment = mu_scaled - expected_risk_neutral_mean
-        adj_returns = returns - adjustment  # Shift the mean to risk-neutral
-
-        # Create HD and Normalize
-        f = stats.gaussian_kde(adj_returns, bw_method='silverman')
-        hd_lm = f(LM)
-        hd_lm = np.maximum(hd_lm, 0)
-        total_area = np.trapz(hd_lm, LM)
-        if total_area > 0:
-            pdf_lm = hd_lm / total_area
-        else:
-            logger.warning(f"Total area is zero for maturity {i}, skipping.")
-            continue
-
-        pdf_k = pdf_lm / K
-        pdf_m = pdf_k * s
-        pdf_r = pdf_lm / (1 + R)
+def fit_garch_model(log_returns, n_fits=400, window_length=365):
+    """
+    Fit a GARCH(1,1) model to log returns.
 
-        cdf = np.concatenate(([0], np.cumsum(pdf_lm[:-1] * np.diff(LM))))
+    Args:
+        log_returns: Array of log returns
+        n_fits: Number of sliding windows
+        window_length: Length of each window
 
-        if return_domain == 'log_moneyness':
-            x = LM
-            pdf = pdf_lm
-            moments = get_all_moments(x, pdf)
-        elif return_domain == 'moneyness':
-            x = M
-            pdf = pdf_m
-            moments = get_all_moments(x, pdf)
-        elif return_domain == 'returns':
-            x = R
-            pdf = pdf_r
-            moments = get_all_moments(x, pdf)
-        elif return_domain == 'strikes':
-            x = K
-            pdf = pdf_k
-            moments = get_all_moments(x, pdf)
+    Returns:
+        Dict with GARCH parameters and processes
+    """
 
-        # Store results
-        pdf_surface[i] = pdf
-        cdf_surface[i] = cdf
-        x_surface[i] = x
-        all_moments[i] = moments
+    if len(log_returns) < window_length + n_fits:
+        raise VolyError(f"Not enough data points. Need at least {window_length + n_fits}, got {len(log_returns)}")
 
-    # Create a DataFrame with moments using the same index as model_results
-    moments = pd.DataFrame(all_moments).T
+    # Adjust window sizes if necessary
+    n_fits = min(n_fits, len(log_returns) // 3)
+    window_length = min(window_length, len(log_returns) // 3)
 
-    return {
-        'pdf_surface': pdf_surface,
-        'cdf_surface': cdf_surface,
-        'x_surface': x_surface,
-        'moments': moments
-    }
+    start = window_length + n_fits
+    end = n_fits
 
+    parameters = np.zeros((n_fits, 4))  # [mu, omega, alpha, beta]
+    z_process = []
 
-class GARCHModel:
-    """
-    GARCH(1,1) model for volatility modeling and simulation.
+    logger.info(f"Fitting GARCH model with {n_fits} windows...")
 
-    Fits a GARCH(1,1) model to historical returns and simulates future paths
-    for historical density estimation.
-    """
+    for i in range(n_fits):
+        window = log_returns[end - i - 1:start - i - 1]
+        data = window - np.mean(window)
 
-    def __init__(self,
-                 data: np.ndarray,
-                 data_name: str,
-                 n_fits: int = 400,
-                 window_length: int = 365,
-                 z_h: float = 0.1):
-        """
-        Initialize the GARCH model.
-
-        Args:
-            data: Array of log returns
-            data_name: Identifier for the dataset
-            n_fits: Number of sliding windows to use for parameter estimation
-            window_length: Length of each sliding window
-            z_h: Bandwidth factor for kernel density estimation of innovations
-        """
-        self.data = data
-        self.data_name = data_name
-        self.n_fits = n_fits
-        self.window_length = window_length
-        self.z_h = z_h
-
-        # Parameters to be created during fitting and simulation
-        self.parameters = None
-        self.e_process = None
-        self.z_process = None
-        self.sigma2_process = None
-        self.z_dens = None
-        self.simulated_log_returns = None
-        self.simulated_tau_mu = None
-
-    def fit(self):
-        """
-        Fit GARCH(1,1) model to historical data using sliding windows.
-
-        For each window, estimates parameters (ω, α, β) and extracts innovations.
-        """
-
-        if len(self.data) < self.window_length + self.n_fits:
-            raise VolyError(
-                f"Not enough data points. Need at least {self.window_length + self.n_fits}, got {len(self.data)}")
-
-        start = self.window_length + self.n_fits
-        end = self.n_fits
-
-        parameters = np.zeros((self.n_fits, 4))
-        z_process = []
-        e_process = []
-        sigma2_process = []
-
-        logger.info(f"Fitting GARCH model with {self.n_fits} windows...")
-
-        for i in range(self.n_fits):
-            window = self.data[end - i - 1:start - i - 1]
-            data = window - np.mean(window)
-
-            model = arch_model(data, vol='GARCH', p=1, q=1)
+        model = arch_model(data, vol='GARCH', p=1, q=1)
+        try:
             GARCH_fit = model.fit(disp='off')
 
             mu, omega, alpha, beta = [
@@ -272,157 +123,132 @@ class GARCHModel:
             ]
             parameters[i, :] = [mu, omega, alpha, beta]
 
+            # Calculate sigma2 and innovations for last observation
             if i == 0:
                 sigma2_tm1 = omega / (1 - alpha - beta)
             else:
-                sigma2_tm1 = sigma2_process[-1]
+                e_tm1 = data.tolist()[-2]
+                sigma2_tm1 = omega + alpha * e_tm1 ** 2 + beta * sigma2_tm1
 
-            e_t = data.tolist()[-1]  # last observed log-return
-            e_tm1 = data.tolist()[-2]  # previous observed log-return
-            sigma2_t = omega + alpha * e_tm1 ** 2 + beta * sigma2_tm1
+            e_t = data.tolist()[-1]
+            sigma2_t = omega + alpha * data.tolist()[-2] ** 2 + beta * sigma2_tm1
             z_t = e_t / np.sqrt(sigma2_t)
-
-            e_process.append(e_t)
             z_process.append(z_t)
-            sigma2_process.append(sigma2_t)
-
-        self.parameters = parameters
-        self.e_process = e_process
-        self.z_process = z_process
-        self.sigma2_process = sigma2_process
-
-        # Kernel density estimation for innovations
-        z_dens_x = np.linspace(min(self.z_process), max(self.z_process), 500)
-        h_dyn = self.z_h * (np.max(z_process) - np.min(z_process))
-
-        # Use scipy's gaussian_kde for innovation distribution
-        kde = stats.gaussian_kde(np.array(z_process), bw_method=h_dyn)
-        z_dens_y = kde(z_dens_x)
-
-        self.z_dens = {"x": z_dens_x, "y": z_dens_y}
-
-        logger.info("GARCH model fitting complete")
 
-    def _GARCH_simulate(self, pars, horizon):
-        """
-        Simulate a single GARCH path to specified horizon.
+        except Exception as e:
+            logger.warning(f"GARCH fit failed for window {i}: {str(e)}")
 
-        Args:
-            pars: Tuple of (mu, omega, alpha, beta)
-            horizon: Number of steps to simulate
+    # Clean up any failed fits
+    if len(z_process) < n_fits / 2:
+        raise VolyError("Too many GARCH fits failed. Check your data.")
 
-        Returns:
-            Tuple of (sigma2_process, e_process) of simulated values
-        """
-        mu, omega, alpha, beta = pars
-        burnin = horizon * 2
-        sigma2 = [omega / (1 - alpha - beta)]
-        e = [self.data.tolist()[-1] - mu]  # last observed log-return mean adjusted
+    avg_params = np.mean(parameters, axis=0)
+    std_params = np.std(parameters, axis=0)
 
-        # Convert density to probability weights
-        weights = self.z_dens["y"] / np.sum(self.z_dens["y"])
-
-        for _ in range(horizon + burnin):
-            sigma2_tp1 = omega + alpha * e[-1] ** 2 + beta * sigma2[-1]
-            # Sample from the estimated innovation distribution
-            z_tp1 = np.random.choice(self.z_dens["x"], 1, p=weights)[0]
-            e_tp1 = z_tp1 * np.sqrt(sigma2_tp1)
-            sigma2.append(sigma2_tp1)
-            e.append(e_tp1)
-
-        return sigma2[-horizon:], e[-horizon:]
+    return {
+        'parameters': parameters,
+        'avg_params': avg_params,
+        'std_params': std_params,
+        'z_process': np.array(z_process)
+    }
 
-    def _variate_pars(self, pars, bounds):
-        """
-        Add variation to GARCH parameters for simulation uncertainty.
 
-        Args:
-            pars: Array of mean parameters [mu, omega, alpha, beta]
-            bounds: Standard deviation bounds for parameters
+@catch_exception
+def simulate_garch_paths(garch_model, horizon, simulations=5000, variate_parameters=True):
+    """
+    Simulate future paths using a fitted GARCH model.
 
-        Returns:
-            Array of slightly varied parameters
-        """
-        new_pars = []
-        for i, (par, bound) in enumerate(zip(pars, bounds)):
-            var = bound ** 2 / self.n_fits
-            new_par = np.random.normal(par, var, 1)[0]
-            if (new_par <= 0) and (i >= 1):
-                new_par = 0.01
-            new_pars.append(new_par)
-        return new_pars
+    Args:
+        garch_model: Dict with GARCH model parameters
+        horizon: Number of steps to simulate
+        simulations: Number of paths to simulate
+        variate_parameters: Whether to vary parameters between simulations
 
-    def simulate_paths(self, horizon, simulations=5000, variate_parameters=True):
-        """
-        Simulate multiple GARCH paths using Monte Carlo.
+    Returns:
+        Array of simulated log returns
+    """
+    parameters = garch_model['parameters']
+    z_process = garch_model['z_process']
 
-        Args:
-            horizon: Number of steps to simulate (days)
-            simulations: Number of Monte Carlo simulations
-            variate_parameters: Whether to add variation to GARCH parameters
+    # Use mean parameters as starting point
+    pars = garch_model['avg_params'].copy()  # [mu, omega, alpha, beta]
+    bounds = garch_model['std_params'].copy()
 
-        Returns:
-            Tuple of (simulated_log_returns, simulated_tau_mu)
-        """
-        if self.parameters is None:
-            self.fit()
+    mu, omega, alpha, beta = pars
+    logger.info(f"GARCH parameters: mu={mu:.6f}, omega={omega:.6f}, alpha={alpha:.6f}, beta={beta:.6f}")
 
-        pars = np.mean(self.parameters, axis=0).tolist()  # [mu, omega, alpha, beta]
-        bounds = np.std(self.parameters, axis=0).tolist()
+    # Create KDE for innovations
+    kde = stats.gaussian_kde(z_process)
+    z_range = np.linspace(min(z_process), max(z_process), 1000)
+    z_prob = kde(z_range)
+    z_prob = z_prob / np.sum(z_prob)
 
-        logger.info(f"Simulating {simulations} GARCH paths for {horizon} steps...")
-        logger.info(f"GARCH parameters: mu={pars[0]:.6f}, omega={pars[1]:.6f}, alpha={pars[2]:.6f}, beta={pars[3]:.6f}")
+    # Simulate paths
+    simulated_returns = np.zeros(simulations)
 
-        np.random.seed(42)  # For reproducibility
+    for i in range(simulations):
+        if (i + 1) % (simulations // 10) == 0:
+            logger.info(f"Simulation progress: {i + 1}/{simulations}")
 
-        new_pars = pars.copy()  # start with unchanged parameters
-        simulated_log_returns = np.zeros(simulations)
-        simulated_tau_mu = np.zeros(simulations)
+        # Optionally vary parameters
+        if variate_parameters and (i + 1) % (simulations // 20) == 0:
+            new_pars = []
+            for j, (par, bound) in enumerate(zip(pars, bounds)):
+                var = bound ** 2 / len(parameters)
+                new_par = np.random.normal(par, var)
+                if j >= 1 and new_par <= 0:  # Ensure omega, alpha, beta are positive
+                    new_par = 0.01
+                new_pars.append(new_par)
+            mu, omega, alpha, beta = new_pars
 
-        for i in range(simulations):
-            if ((i + 1) % (simulations // 10) == 0):
-                logger.info(f"Simulation progress: {i + 1}/{simulations}")
+        # Initial values
+        sigma2 = omega / (1 - alpha - beta)
+        returns_sum = 0
 
-            if ((i + 1) % (simulations // 20) == 0) and variate_parameters:
-                new_pars = self._variate_pars(pars, bounds)
+        # Simulate path
+        for _ in range(horizon):
+            # Sample from innovation distribution
+            z = np.random.choice(z_range, p=z_prob)
 
-            sigma2, e = self._GARCH_simulate(new_pars, horizon)
-            simulated_log_returns[i] = np.sum(e)  # Sum log returns over horizon
-            simulated_tau_mu[i] = horizon * pars[0]  # Total drift
+            # Calculate return and update volatility
+            e = z * np.sqrt(sigma2)
+            returns_sum += e + mu
+            sigma2 = omega + alpha * e ** 2 + beta * sigma2
 
-        self.simulated_log_returns = simulated_log_returns
-        self.simulated_tau_mu = simulated_tau_mu
+        simulated_returns[i] = returns_sum
 
-        return simulated_log_returns, simulated_tau_mu
+    return simulated_returns, mu * horizon
 
 
-@catch_exception
-def get_garch_hd_surface(model_results: pd.DataFrame,
-                         df_hist: pd.DataFrame,
-                         domain_params: Tuple[float, float, int] = (-1.5, 1.5, 1000),
-                         return_domain: str = 'log_moneyness',
-                         n_fits: int = 400,
-                         simulations: int = 5000,
-                         window_length: int = 365,
-                         variate_parameters: bool = True,
-                         bandwidth: float = 0.15) -> Dict[str, Any]:
+def get_hd_surface(model_results: pd.DataFrame,
+                   df_hist: pd.DataFrame,
+                   domain_params: Tuple[float, float, int] = (-1.5, 1.5, 1000),
+                   return_domain: str = 'log_moneyness',
+                   method: str = 'garch',
+                   **kwargs) -> Dict[str, Any]:
     """
-    Generate historical density surface using GARCH(1,1) model and Monte Carlo simulation.
+    Generate historical density surface from historical price data.
 
     Parameters:
         model_results: DataFrame with model parameters and maturities
-        df_hist: DataFrame with historical price data (must have 'close' column)
+        df_hist: DataFrame with historical price data
         domain_params: Tuple of (min, max, num_points) for x-domain
         return_domain: Domain for x-axis values ('log_moneyness', 'moneyness', 'returns', 'strikes')
-        n_fits: Number of sliding windows for GARCH parameter estimation
-        simulations: Number of Monte Carlo simulations
-        window_length: Length of each sliding window for GARCH estimation
-        variate_parameters: Whether to vary GARCH parameters between simulations
-        bandwidth: Bandwidth for kernel density estimation of final density
+        method: Method to use for HD estimation ('hist_returns' or 'garch')
+        **kwargs: Additional parameters for specific methods:
+            For 'garch' method:
+                n_fits: Number of sliding windows (default: 400)
+                simulations: Number of Monte Carlo simulations (default: 5000)
+                window_length: Length of sliding windows (default: 365)
+                variate_parameters: Whether to vary GARCH parameters (default: True)
+                bandwidth: KDE bandwidth (default: 'silverman')
+            For 'hist_returns' method:
+                bandwidth: KDE bandwidth (default: 'silverman')
 
     Returns:
         Dictionary containing pdf_surface, cdf_surface, x_surface, and moments
     """
+
     # Check if required columns are present
     required_columns = ['s', 't', 'r']
     missing_columns = [col for col in required_columns if col not in model_results.columns]
@@ -437,10 +263,29 @@ def get_garch_hd_surface(model_results: pd.DataFrame,
     else:
         raise VolyError("Cannot determine granularity from df_hist.")
 
-    # Calculate log returns based on the determined granularity
+    # Get method-specific parameters
+    if method == 'garch':
+        n_fits = kwargs.get('n_fits', 400)
+        simulations = kwargs.get('simulations', 5000)
+        window_length = kwargs.get('window_length', 365)
+        variate_parameters = kwargs.get('variate_parameters', True)
+        bandwidth = kwargs.get('bandwidth', 'silverman')
+        logger.info(f"Using GARCH method with {n_fits} fits, {simulations} simulations")
+    elif method == 'hist_returns':
+        bandwidth = kwargs.get('bandwidth', 'silverman')
+        logger.info(f"Using returns-based KDE method with bandwidth {bandwidth}")
+    else:
+        raise VolyError(f"Unknown method: {method}. Use 'hist_returns' or 'garch'.")
+
+    # Calculate log returns from price history
     log_returns = np.log(df_hist['close'] / df_hist['close'].shift(1)) * 100
     log_returns = log_returns.dropna().values
 
+    # Fit GARCH model once if using garch method
+    garch_model = None
+    if method == 'garch':
+        garch_model = fit_garch_model(log_returns, n_fits, window_length)
+
     pdf_surface = {}
     cdf_surface = {}
     x_surface = {}
@@ -453,97 +298,141 @@ def get_garch_hd_surface(model_results: pd.DataFrame,
         r = model_results.loc[i, 'r']  # Risk-free rate
         t = model_results.loc[i, 't']  # Time to maturity in years
 
-        # Fix for very short-term maturities - use floating-point days
-        tau_days_float = t * 365.25  # Exact number of days (as float)
-        tau_day = max(1, int(tau_days_float))  # Ensure minimum of 1 day for simulation
-
-        logger.info(f"Processing GARCH HD for maturity {i} (t={t:.4f} years, {tau_days_float:.2f} days)")
-
-        # Calculate the number of periods that match the time to expiry
-        n_periods = max(1, int(t * 365.25 * 24 * 60 / minutes_per_period))
-
-        # Initialize GARCH model
-        garch_model = GARCHModel(
-            data=log_returns,
-            data_name=str(i),
-            n_fits=min(n_fits, len(log_returns) // 3),
-            window_length=min(window_length, len(log_returns) // 3),
-            z_h=0.1
-        )
-
-        # Simulate paths
-        simulated_log_returns, simulated_tau_mu = garch_model.simulate_paths(
-            horizon=tau_day,
-            simulations=simulations,
-            variate_parameters=variate_parameters
-        )
-
-        # Scale the simulated returns to match target time horizon
-        # Use floating-point days to avoid division by zero
-        scaling_factor = np.sqrt(n_periods / tau_days_float)
-        scaled_log_returns = simulated_log_returns * scaling_factor
-
-        # Risk-neutral adjustment (Girsanov transformation)
-        # Calculate empirical mean and volatility of the scaled returns
-        mu_scaled = scaled_log_returns.mean()
-        sigma_scaled = scaled_log_returns.std()
-
-        # Expected risk-neutral drift
-        expected_risk_neutral_mean = (r - 0.5 * (sigma_scaled / 100) ** 2) * 100 * np.sqrt(t)
-
-        # Calculate adjustment to shift physical to risk-neutral measure
-        adjustment = mu_scaled - expected_risk_neutral_mean
-
-        # Adjust the returns to the risk-neutral measure
-        risk_neutral_log_returns = scaled_log_returns - adjustment
-
-        # Convert to terminal prices using the risk-neutral returns
-        simulated_prices = s * np.exp(risk_neutral_log_returns / 100)
-
-        # Convert to moneyness domain
-        simulated_moneyness = s / simulated_prices
-
-        # Get x domain grid based on requested return_domain
+        # Get domain grids
         LM = np.linspace(domain_params[0], domain_params[1], domain_params[2])
         M = np.exp(LM)  # Moneyness
         R = M - 1  # Returns
         K = s / M  # Strike prices
 
-        # Perform kernel density estimation in moneyness domain
-        kde = stats.gaussian_kde(simulated_moneyness, bw_method=bandwidth)
-        pdf_m = kde(M)
+        # For time scaling calculations
+        tau_days_float = t * 365.25  # Exact number of days
+        n_periods = max(1, int(t * 365.25 * 24 * 60 / minutes_per_period))
+
+        logger.info(f"Processing HD for maturity {i} (t={t:.4f} years, {tau_days_float:.2f} days)")
+
+        if method == 'hist_returns':
+            # Standard returns-based method (your existing implementation)
+            # Filter historical data for this maturity's lookback period
+            start_date = pd.Timestamp.now() - pd.Timedelta(days=int(t * 365.25))
+            maturity_hist = df_hist[df_hist.index >= start_date].copy()
+
+            if len(maturity_hist) < 10:
+                logger.warning(f"Not enough historical data for maturity {i}, skipping.")
+                continue
+
+            # Calculate scaled returns
+            maturity_hist['log_returns'] = np.log(maturity_hist['close'] / maturity_hist['close'].shift(1)) * np.sqrt(
+                n_periods)
+            maturity_hist = maturity_hist.dropna()
+
+            returns = maturity_hist['log_returns'].values
+            if len(returns) < 2:
+                logger.warning(f"Not enough valid returns for maturity {i}, skipping.")
+                continue
+
+            # Girsanov adjustment to shift to risk-neutral measure
+            mu_scaled = returns.mean()
+            sigma_scaled = returns.std()
+            expected_risk_neutral_mean = (r - 0.5 * sigma_scaled ** 2) * np.sqrt(t)
+            adjustment = mu_scaled - expected_risk_neutral_mean
+            adj_returns = returns - adjustment
+
+            # Create HD and normalize
+            f = stats.gaussian_kde(adj_returns, bw_method=bandwidth)
+            pdf_values = f(LM)
+
+        elif method == 'garch':
+            # GARCH-based method
+            if garch_model is None:
+                logger.warning(f"GARCH model fitting failed, skipping maturity {i}")
+                continue
+
+            # Simulate paths with the GARCH model
+            horizon = max(1, int(tau_days_float))
+            simulated_returns, simulated_mu = simulate_garch_paths(
+                garch_model,
+                horizon,
+                simulations,
+                variate_parameters
+            )
+
+            # Scale the simulated returns to match target time horizon
+            scaling_factor = np.sqrt(n_periods / tau_days_float)
+            scaled_returns = simulated_returns * scaling_factor
+
+            # Risk-neutral adjustment
+            mu_scaled = scaled_returns.mean()
+            sigma_scaled = scaled_returns.std()
+            expected_risk_neutral_mean = (r - 0.5 * (sigma_scaled / 100) ** 2) * 100 * np.sqrt(t)
+            adjustment = mu_scaled - expected_risk_neutral_mean
+            risk_neutral_returns = scaled_returns - adjustment
+
+            # Convert to terminal prices
+            simulated_prices = s * np.exp(risk_neutral_returns / 100)
+
+            # Convert to moneyness domain
+            simulated_moneyness = s / simulated_prices
+
+            # Perform KDE to get PDF
+            kde = stats.gaussian_kde(simulated_moneyness, bw_method=bandwidth)
+            pdf_values = kde(M)
+
+            # Include GARCH params in moments
+            avg_params = garch_model['avg_params']
+            model_params = {
+                'mu': avg_params[0],
+                'omega': avg_params[1],
+                'alpha': avg_params[2],
+                'beta': avg_params[3],
+                'persistence': avg_params[2] + avg_params[3]
+            }
+        else:
+            continue  # Skip this maturity if method is invalid
 
         # Ensure density integrates to 1
         dx = LM[1] - LM[0]
-        total_area = np.sum(pdf_m * dx)
-        pdf_m = pdf_m / total_area
+        total_area = np.sum(pdf_values * dx)
+        if total_area <= 0:
+            logger.warning(f"Invalid density (area <= 0) for maturity {i}, skipping.")
+            continue
+
+        pdf_values = pdf_values / total_area
+
+        # Common processing for both methods
 
-        # Transform to other domains as needed
-        pdf_lm = pdf_m * M  # Transform to log-moneyness domain
-        pdf_k = pdf_lm / K  # Transform to strike domain
-        pdf_r = pdf_lm / (1 + R)  # Transform to returns domain
+        # Transform densities to various domains
+        if method == 'hist_returns':
+            pdf_lm = pdf_values
+            pdf_m = pdf_lm / M
+            pdf_k = pdf_lm / K
+            pdf_r = pdf_lm / (1 + R)
+        else:  # 'garch'
+            pdf_m = pdf_values
+            pdf_lm = pdf_m * M
+            pdf_k = pdf_lm / K
+            pdf_r = pdf_lm / (1 + R)
 
         # Calculate CDF
-        cdf = np.cumsum(pdf_lm) * dx
-        cdf = np.minimum(cdf / cdf[-1], 1.0)  # Normalize and cap at 1.0
+        cdf = np.cumsum(pdf_lm * dx)
+        cdf = np.minimum(cdf / cdf[-1], 1.0)
 
-        # Select appropriate domain for return
+        # Select appropriate domain and calculate moments
         if return_domain == 'log_moneyness':
             x = LM
             pdf = pdf_lm
-            moments = get_all_moments(x, pdf)
+            moments = get_all_moments(x, pdf, model_params if method == 'garch' else None)
         elif return_domain == 'moneyness':
             x = M
             pdf = pdf_m
-            moments = get_all_moments(x, pdf)
+            moments = get_all_moments(x, pdf, model_params if method == 'garch' else None)
         elif return_domain == 'returns':
             x = R
             pdf = pdf_r
-            moments = get_all_moments(x, pdf)
+            moments = get_all_moments(x, pdf, model_params if method == 'garch' else None)
         elif return_domain == 'strikes':
             x = K
             pdf = pdf_k
-            moments = get_all_moments(x, pdf)
+            moments = get_all_moments(x, pdf, model_params if method == 'garch' else None)
         else:
             raise VolyError(f"Unsupported return_domain: {return_domain}")
 
@@ -556,7 +445,7 @@ def get_garch_hd_surface(model_results: pd.DataFrame,
     # Create DataFrame with moments
     moments = pd.DataFrame(all_moments).T
 
-    logger.info("GARCH historical density calculation complete")
+    logger.info(f"Historical density calculation complete using {method} method")
 
     return {
         'pdf_surface': pdf_surface,

voly/core/rnd.py

@@ -165,7 +165,7 @@ def rookley(domain_params, s, r, o, t, return_domain):
 
 
 @catch_exception
-def get_all_moments(x, pdf):
+def get_all_moments(x, pdf, model_params=None):
     mean = np.trapz(x * pdf, x)  # E[X]
     median = x[np.searchsorted(np.cumsum(pdf * np.diff(x, prepend=x[0])), 0.5)]  # Median (50th percentile)
     mode = x[np.argmax(pdf)]  # Mode (peak of PDF)
@@ -213,6 +213,11 @@ def get_all_moments(x, pdf):
         'o3n': o3n,
         'o4n': o4n
     }
+
+    # Add model parameters if provided
+    if model_params is not None:
+        moments.update(model_params)
+
     return moments
 
 

{voly-0.0.138.dist-info → voly-0.0.140.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voly
-Version: 0.0.138
+Version: 0.0.140
 Summary: Options & volatility research package
 Author-email: Manu de Cara <manu.de.cara@gmail.com>
 License: MIT

{voly-0.0.138.dist-info → voly-0.0.140.dist-info}/RECORD

@@ -1,5 +1,5 @@
 voly/__init__.py,sha256=8xyDk7rFCn_MOD5hxuv5cxxKZvBVRiSIM7TgaMPpwpw,211
-voly/client.py,sha256=9Q_j4F72laro5OnA2IqAZhD2Vr-6QSaaz-vKRxk8KGs,15089
+voly/client.py,sha256=Lj3YY6P1VBQD5C_psPh2pSxCMVvFjRBybrMrs4e9qXI,14249
 voly/exceptions.py,sha256=PBsbn1vNMvKcCJwwJ4lBO6glD85jo1h2qiEmD7ArAjs,92
 voly/formulas.py,sha256=G_soRiPwQlHy6milOAj6TdmBWr-fNZpMvm0joXAMZ90,10767
 voly/models.py,sha256=o-pHujGfr5Gn8ItckMzLI4Q8yaX9FQaV8UjCxv2zgTY,3364
@@ -7,13 +7,13 @@ voly/core/__init__.py,sha256=bu6fS2I1Pj9fPPnl-zY3L7NqrZSY5Zy6NY2uMUvdhKs,183
 voly/core/charts.py,sha256=E21OZB5lTY4YL2flgaFJ6s5g3_ExtAQT2zryZZxLPyM,12735
 voly/core/data.py,sha256=pDeuYhP0GX4RbtlqByvsE3rfHcIkix0BU5MLW8sKIeI,8935
 voly/core/fit.py,sha256=Tb9eeG7e_2dQTcqt6aqEwFrZdy6jR9rSNqe6tzOdVhQ,9245
-voly/core/hd.py,sha256=rxi0WrPvuDVB5CYP-d6z5BukOklJDdmYDZEPLnQc47w,20845
+voly/core/hd.py,sha256=K2X0isAchumuRPcc5RSEkMOR5sOeb_I3twwqAZYYL1A,16809
 voly/core/interpolate.py,sha256=JkK172-FXyhesW3hY4pEeuJWG3Bugq7QZXbeKoRpLuo,5305
-voly/core/rnd.py,sha256=Bs44AzbAYn1Z8e-Og026BKN9Bu-7A4yH3i639uxXc_A,10116
+voly/core/rnd.py,sha256=GG4cZpWChy8ptIwanuullkx3Bai50rFjqa9E-D9q2_Q,10246
 voly/utils/__init__.py,sha256=E05mWatyC-PDOsCxQV1p5Xi1IgpOomxrNURyCx_gB-w,200
 voly/utils/logger.py,sha256=4-_2bVJmq17Q0d7Rd2mPg1AeR8gxv6EPvcmBDMFWcSM,1744
-voly-0.0.138.dist-info/licenses/LICENSE,sha256=wcHIVbE12jfcBOai_wqBKY6xvNQU5E909xL1zZNq_2Q,1065
-voly-0.0.138.dist-info/METADATA,sha256=GH6kDbnu0DcTJAdPo9rS0yI-4DCHwvwn6Lp1_Kgrb_8,4115
-voly-0.0.138.dist-info/WHEEL,sha256=DK49LOLCYiurdXXOXwGJm6U4DkHkg4lcxjhqwRa0CP4,91
-voly-0.0.138.dist-info/top_level.txt,sha256=ZfLw2sSxF-LrKAkgGjOmeTcw6_gD-30zvtdEY5W4B7c,5
-voly-0.0.138.dist-info/RECORD,,
+voly-0.0.140.dist-info/licenses/LICENSE,sha256=wcHIVbE12jfcBOai_wqBKY6xvNQU5E909xL1zZNq_2Q,1065
+voly-0.0.140.dist-info/METADATA,sha256=6hSGujPj6Hbvl2sk8ru_YmxlQ28IpUNXZASJC-iaoLY,4115
+voly-0.0.140.dist-info/WHEEL,sha256=DK49LOLCYiurdXXOXwGJm6U4DkHkg4lcxjhqwRa0CP4,91
+voly-0.0.140.dist-info/top_level.txt,sha256=ZfLw2sSxF-LrKAkgGjOmeTcw6_gD-30zvtdEY5W4B7c,5
+voly-0.0.140.dist-info/RECORD,,