voly 0.0.142__py3-none-any.whl → 0.0.144__py3-none-any.whl

voly/client.py

@@ -343,30 +343,11 @@ class VolyClient:
                        df_hist: pd.DataFrame,
                        domain_params: Tuple[float, float, int] = (-1.5, 1.5, 1000),
                        return_domain: str = 'log_moneyness',
-                       method: str = 'garch',
+                       method: str = 'arch_returns',
+                       model_type: str = 'garch',
+                       distribution: str = 'normal',
                        **kwargs) -> Dict[str, Any]:
-        """
-        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')
-            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(f"Calculating historical density surface using {method} method")
 
         return get_hd_surface(
@@ -375,5 +356,7 @@ class VolyClient:
             domain_params=domain_params,
             return_domain=return_domain,
             method=method,
+            model_type=model_type,
+            distribution=distribution,
             **kwargs
         )

voly/core/hd.py

@@ -16,6 +16,7 @@ from voly.formulas import iv, get_domain
 from voly.models import SVIModel
 from voly.core.fit import fit_model
 from arch import arch_model
+from arch.univariate import GARCH, EGARCH
 
 
 @catch_exception
@@ -79,68 +80,151 @@ def get_historical_data(currency, lookback_days, granularity, exchange_name):
 
 
 @catch_exception
-def fit_garch_model(log_returns, n_fits=400, window_length=365):
+def parse_window_length(window_length, df_hist):
     """
-    Fit a GARCH(1,1) model to log returns.
+    Parse window length from string format (e.g., '7d', '30d') to number of data points.
+
+    Parameters:
+    -----------
+    window_length : str
+        Window length in days, formatted as '7d', '30d', etc.
+    df_hist : pd.DataFrame
+        Historical data DataFrame with datetime index.
+
+    Returns:
+    --------
+    int
+        Number of data points corresponding to the window length.
+    """
+    if not window_length.endswith('d'):
+        raise VolyError("window_length should be in format '7d', '30d', etc.")
+
+    # Extract number of days
+    days = int(window_length[:-1])
+
+    # Calculate time delta between consecutive data points
+    if len(df_hist) > 1:
+        avg_delta = (df_hist.index[-1] - df_hist.index[0]) / (len(df_hist) - 1)
+        # Convert to days and get points per day
+        days_per_point = avg_delta.total_seconds() / (24 * 60 * 60)
+        # Calculate number of points for the window
+        n_points = int(days / days_per_point)
+        return max(n_points, 10)  # Ensure at least 10 points
+    else:
+        raise VolyError("Not enough data points in df_hist to calculate granularity.")
+
+
+@catch_exception
+def fit_volatility_model(log_returns, df_hist, model_type='garch', distribution='normal', window_length='30d',
+                         n_fits=400):
+    """
+    Fit a volatility model (GARCH or EGARCH) to log returns.
 
     Args:
         log_returns: Array of log returns
+        df_hist: DataFrame with historical price data
+        model_type: Type of volatility model ('garch' or 'egarch')
+        distribution: Distribution type ('normal', 'studentst', or 'skewstudent')
+        window_length: Length of each window as a string (e.g., '30d')
         n_fits: Number of sliding windows
-        window_length: Length of each window
 
     Returns:
-        Dict with GARCH parameters and processes
+        Dict with model parameters and processes
     """
+    # Parse window length
+    window_points = parse_window_length(window_length, df_hist)
 
-    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)}")
+    if len(log_returns) < window_points + n_fits:
+        raise VolyError(f"Not enough data points. Need at least {window_points + n_fits}, got {len(log_returns)}")
 
     # Adjust window sizes if necessary
     n_fits = min(n_fits, len(log_returns) // 3)
-    window_length = min(window_length, len(log_returns) // 3)
+    window_points = min(window_points, len(log_returns) // 3)
 
-    start = window_length + n_fits
+    start = window_points + n_fits
     end = n_fits
 
-    parameters = np.zeros((n_fits, 4))  # [mu, omega, alpha, beta]
+    # Different number of parameters based on model type and distribution
+    if model_type.lower() == 'garch':
+        if distribution.lower() == 'normal':
+            n_params = 4  # mu, omega, alpha, beta
+        elif distribution.lower() == 'studentst':
+            n_params = 5  # mu, omega, alpha, beta, nu
+        else:  # skewstudent
+            n_params = 6  # mu, omega, alpha, beta, nu, lambda (skew)
+    else:  # egarch
+        if distribution.lower() == 'normal':
+            n_params = 5  # mu, omega, alpha, gamma, beta
+        elif distribution.lower() == 'studentst':
+            n_params = 6  # mu, omega, alpha, gamma, beta, nu
+        else:  # skewstudent
+            n_params = 7  # mu, omega, alpha, gamma, beta, nu, lambda (skew)
+
+    parameters = np.zeros((n_fits, n_params))
     z_process = []
 
-    logger.info(f"Fitting GARCH model with {n_fits} windows...")
+    logger.info(f"Fitting {model_type.upper()} model with {distribution} distribution using {n_fits} windows...")
 
     for i in range(n_fits):
         window = log_returns[end - i - 1:start - i - 1]
         data = window - np.mean(window)
 
-        model = arch_model(data, vol='GARCH', p=1, q=1)
         try:
-            GARCH_fit = model.fit(disp='off')
-
-            mu, omega, alpha, beta = [
-                GARCH_fit.params["mu"],
-                GARCH_fit.params["omega"],
-                GARCH_fit.params["alpha[1]"],
-                GARCH_fit.params["beta[1]"],
-            ]
-            parameters[i, :] = [mu, omega, alpha, beta]
-
-            # Calculate sigma2 and innovations for last observation
-            if i == 0:
-                sigma2_tm1 = omega / (1 - alpha - beta)
-            else:
-                e_tm1 = data.tolist()[-2]
-                sigma2_tm1 = 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)
+            # Configure model based on type and distribution
+            if model_type.lower() == 'garch':
+                model = arch_model(data, vol='GARCH', p=1, q=1, dist=distribution.lower())
+            else:  # egarch
+                model = arch_model(data, vol='EGARCH', p=1, o=1, q=1, dist=distribution.lower())
+
+            fit_result = model.fit(disp='off')
+
+            # Extract parameters based on model type and distribution
+            params_dict = fit_result.params.to_dict()
+
+            if model_type.lower() == 'garch':
+                mu = params_dict.get("mu", 0)
+                omega = params_dict.get("omega", 0)
+                alpha = params_dict.get("alpha[1]", 0)
+                beta = params_dict.get("beta[1]", 0)
+
+                if distribution.lower() == 'normal':
+                    parameters[i, :] = [mu, omega, alpha, beta]
+                elif distribution.lower() == 'studentst':
+                    nu = params_dict.get("nu", 0)
+                    parameters[i, :] = [mu, omega, alpha, beta, nu]
+                else:  # skewstudent
+                    nu = params_dict.get("nu", 0)
+                    lam = params_dict.get("lambda", 0)
+                    parameters[i, :] = [mu, omega, alpha, beta, nu, lam]
+            else:  # egarch
+                mu = params_dict.get("mu", 0)
+                omega = params_dict.get("omega", 0)
+                alpha = params_dict.get("alpha[1]", 0)
+                gamma = params_dict.get("gamma[1]", 0)
+                beta = params_dict.get("beta[1]", 0)
+
+                if distribution.lower() == 'normal':
+                    parameters[i, :] = [mu, omega, alpha, gamma, beta]
+                elif distribution.lower() == 'studentst':
+                    nu = params_dict.get("nu", 0)
+                    parameters[i, :] = [mu, omega, alpha, gamma, beta, nu]
+                else:  # skewstudent
+                    nu = params_dict.get("nu", 0)
+                    lam = params_dict.get("lambda", 0)
+                    parameters[i, :] = [mu, omega, alpha, gamma, beta, nu, lam]
+
+            # Get last innovation
+            residuals = fit_result.resid
+            conditional_vol = fit_result.conditional_volatility
+            z_t = residuals[-1] / conditional_vol[-1]
             z_process.append(z_t)
 
         except Exception as e:
-            logger.warning(f"GARCH fit failed for window {i}: {str(e)}")
+            logger.warning(f"Model fit failed for window {i}: {str(e)}")
 
     # Clean up any failed fits
     if len(z_process) < n_fits / 2:
-        raise VolyError("Too many GARCH fits failed. Check your data.")
+        raise VolyError("Too many model fits failed. Check your data.")
 
     avg_params = np.mean(parameters, axis=0)
     std_params = np.std(parameters, axis=0)
@@ -149,17 +233,38 @@ def fit_garch_model(log_returns, n_fits=400, window_length=365):
         'parameters': parameters,
         'avg_params': avg_params,
         'std_params': std_params,
-        'z_process': np.array(z_process)
+        'z_process': np.array(z_process),
+        'model_type': model_type,
+        'distribution': distribution,
+        'param_names': get_param_names(model_type, distribution)
     }
 
 
+def get_param_names(model_type, distribution):
+    """Get parameter names based on model type and distribution."""
+    if model_type.lower() == 'garch':
+        if distribution.lower() == 'normal':
+            return ['mu', 'omega', 'alpha', 'beta']
+        elif distribution.lower() == 'studentst':
+            return ['mu', 'omega', 'alpha', 'beta', 'nu']
+        else:  # skewstudent
+            return ['mu', 'omega', 'alpha', 'beta', 'nu', 'lambda']
+    else:  # egarch
+        if distribution.lower() == 'normal':
+            return ['mu', 'omega', 'alpha', 'gamma', 'beta']
+        elif distribution.lower() == 'studentst':
+            return ['mu', 'omega', 'alpha', 'gamma', 'beta', 'nu']
+        else:  # skewstudent
+            return ['mu', 'omega', 'alpha', 'gamma', 'beta', 'nu', 'lambda']
+
+
 @catch_exception
-def simulate_garch_paths(garch_model, horizon, simulations=5000, variate_parameters=True):
+def simulate_volatility_paths(vol_model, horizon, simulations=5000, variate_parameters=True):
     """
-    Simulate future paths using a fitted GARCH model.
+    Simulate future paths using a fitted volatility model.
 
     Args:
-        garch_model: Dict with GARCH model parameters
+        vol_model: Dict with volatility model parameters
         horizon: Number of steps to simulate
         simulations: Number of paths to simulate
         variate_parameters: Whether to vary parameters between simulations
@@ -167,21 +272,34 @@ def simulate_garch_paths(garch_model, horizon, simulations=5000, variate_paramet
     Returns:
         Array of simulated log returns
     """
-    parameters = garch_model['parameters']
-    z_process = garch_model['z_process']
+    parameters = vol_model['parameters']
+    z_process = vol_model['z_process']
+    model_type = vol_model['model_type']
+    distribution = vol_model['distribution']
+    param_names = vol_model['param_names']
 
     # Use mean parameters as starting point
-    pars = garch_model['avg_params'].copy()  # [mu, omega, alpha, beta]
-    bounds = garch_model['std_params'].copy()
-
-    mu, omega, alpha, beta = pars
-    logger.info(f"GARCH parameters: mu={mu:.6f}, omega={omega:.6f}, alpha={alpha:.6f}, beta={beta:.6f}")
+    pars = vol_model['avg_params'].copy()
+    bounds = vol_model['std_params'].copy()
+
+    # Log parameters
+    param_str = ", ".join([f"{name}={par:.6f}" for name, par in zip(param_names, pars)])
+    logger.info(f"{model_type.upper()} parameters: {param_str}")
+
+    # Create KDE for innovations based on distribution
+    if distribution.lower() == 'normal':
+        # Use standard normal for normal distribution
+        def sample_innovation(size=1):
+            return np.random.normal(0, 1, size=size)
+    else:
+        # Use KDE for non-normal distributions to capture empirical distribution
+        kde = stats.gaussian_kde(z_process, bw_method='silverman')  # original code doesn't include bw_method
+        z_range = np.linspace(min(z_process), max(z_process), 1000)
+        z_prob = kde(z_range)
+        z_prob = z_prob / np.sum(z_prob)
 
-    # 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)
+        def sample_innovation(size=1):
+            return np.random.choice(z_range, size=size, p=z_prob)
 
     # Simulate paths
     simulated_returns = np.zeros(simulations)
@@ -196,24 +314,63 @@ def simulate_garch_paths(garch_model, horizon, simulations=5000, variate_paramet
             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
+                # Ensure omega is positive, betas are between 0 and 1, etc.
+                if j >= 1 and new_par <= 0:
                     new_par = 0.01
                 new_pars.append(new_par)
-            mu, omega, alpha, beta = new_pars
+            sim_pars = new_pars
+        else:
+            sim_pars = pars.copy()
+
+        # Initialize variables based on model type
+        if model_type.lower() == 'garch':
+            if distribution.lower() == 'normal':
+                mu, omega, alpha, beta = sim_pars
+                sigma2 = omega / (1 - alpha - beta)
+            elif distribution.lower() == 'studentst':
+                mu, omega, alpha, beta, nu = sim_pars
+                sigma2 = omega / (1 - alpha - beta)
+            else:  # skewstudent
+                mu, omega, alpha, beta, nu, lam = sim_pars
+                sigma2 = omega / (1 - alpha - beta)
+        else:  # egarch
+            if distribution.lower() == 'normal':
+                mu, omega, alpha, gamma, beta = sim_pars
+                log_sigma2 = omega / (1 - beta)
+                sigma2 = np.exp(log_sigma2)
+            elif distribution.lower() == 'studentst':
+                mu, omega, alpha, gamma, beta, nu = sim_pars
+                log_sigma2 = omega / (1 - beta)
+                sigma2 = np.exp(log_sigma2)
+            else:  # skewstudent
+                mu, omega, alpha, gamma, beta, nu, lam = sim_pars
+                log_sigma2 = omega / (1 - beta)
+                sigma2 = np.exp(log_sigma2)
 
-        # Initial values
-        sigma2 = omega / (1 - alpha - beta)
         returns_sum = 0
 
         # Simulate path
         for _ in range(horizon):
-            # Sample from innovation distribution
-            z = np.random.choice(z_range, p=z_prob)
-
-            # Calculate return and update volatility
-            e = z * np.sqrt(sigma2)
-            returns_sum += e + mu
-            sigma2 = omega + alpha * e ** 2 + beta * sigma2
+            # Sample innovation
+            z = sample_innovation()
+
+            # Update volatility and returns based on model type
+            if model_type.lower() == 'garch':
+                # Calculate return
+                e = z * np.sqrt(sigma2)
+                returns_sum += e + mu
+
+                # Update GARCH volatility
+                sigma2 = omega + alpha * e ** 2 + beta * sigma2
+            else:  # egarch
+                # Calculate return
+                e = z * np.sqrt(sigma2)
+                returns_sum += e + mu
+
+                # Update EGARCH volatility
+                abs_z = abs(z)
+                log_sigma2 = omega + beta * log_sigma2 + alpha * (abs_z - np.sqrt(2 / np.pi)) + gamma * z
+                sigma2 = np.exp(log_sigma2)
 
         simulated_returns[i] = returns_sum
 
@@ -224,7 +381,9 @@ 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',
+                   method: str = 'arch_returns',
+                   model_type: str = 'garch',
+                   distribution: str = 'normal',
                    **kwargs) -> Dict[str, Any]:
     """
     Generate historical density surface from historical price data.
@@ -234,13 +393,15 @@ def get_hd_surface(model_results: pd.DataFrame,
         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')
-        method: Method to use for HD estimation ('hist_returns' or 'garch')
+        method: Method to use for HD estimation ('hist_returns' or 'arch_returns')
+        model_type: Type of volatility model to use ('garch' or 'egarch')
+        distribution: Distribution to use ('normal', 'studentst', or 'skewstudent')
         **kwargs: Additional parameters for specific methods:
-            For 'garch' method:
+            For volatility models ('garch'/'egarch' 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)
+                window_length: Length of sliding windows as string (default: '30d')
+                variate_parameters: Whether to vary parameters (default: True)
                 bandwidth: KDE bandwidth (default: 'silverman')
             For 'hist_returns' method:
                 bandwidth: KDE bandwidth (default: 'silverman')
@@ -248,7 +409,6 @@ def get_hd_surface(model_results: pd.DataFrame,
     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]
@@ -263,28 +423,46 @@ def get_hd_surface(model_results: pd.DataFrame,
     else:
         raise VolyError("Cannot determine granularity from df_hist.")
 
+    # Validate model_type and distribution
+    valid_model_types = ['garch', 'egarch']
+    valid_distributions = ['normal', 'studentst', 'skewstudent']
+
+    if model_type.lower() not in valid_model_types:
+        raise VolyError(f"Invalid model_type: {model_type}. Must be one of {valid_model_types}")
+
+    if distribution.lower() not in valid_distributions:
+        raise VolyError(f"Invalid distribution: {distribution}. Must be one of {valid_distributions}")
+
     # Get method-specific parameters
-    if method == 'garch':
+    if method == 'arch_returns':
         n_fits = kwargs.get('n_fits', 400)
         simulations = kwargs.get('simulations', 5000)
-        window_length = kwargs.get('window_length', 365)
+        window_length = kwargs.get('window_length', '30d')
         variate_parameters = kwargs.get('variate_parameters', True)
         bandwidth = kwargs.get('bandwidth', 'silverman')
-        logger.info(f"Using GARCH method with {n_fits} fits, {simulations} simulations")
+        logger.info(
+            f"Using {model_type.upper()} method with {distribution} distribution, {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'.")
+        raise VolyError(f"Unknown method: {method}. Use 'hist_returns', 'arch_returns'.")
 
     # 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)
+    # Fit volatility model once if using garch/egarch method
+    vol_model = None
+    if method == 'arch_returns':
+        vol_model = fit_volatility_model(
+            log_returns,
+            df_hist,
+            model_type=model_type,
+            distribution=distribution,
+            window_length=window_length,
+            n_fits=n_fits
+        )
 
     pdf_surface = {}
     cdf_surface = {}
@@ -311,7 +489,7 @@ def get_hd_surface(model_results: pd.DataFrame,
         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)
+            # Standard returns-based method
             # 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()
@@ -341,16 +519,16 @@ def get_hd_surface(model_results: pd.DataFrame,
             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}")
+        elif method == 'arch_returns':
+            # Volatility model-based method
+            if vol_model is None:
+                logger.warning(f"Volatility model fitting failed, skipping maturity {i}")
                 continue
 
-            # Simulate paths with the GARCH model
+            # Simulate paths with the volatility model
             horizon = max(1, int(tau_days_float))
-            simulated_returns, simulated_mu = simulate_garch_paths(
-                garch_model,
+            simulated_returns, simulated_mu = simulate_volatility_paths(
+                vol_model,
                 horizon,
                 simulations,
                 variate_parameters
@@ -377,15 +555,16 @@ def get_hd_surface(model_results: pd.DataFrame,
             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]
-            }
+            # Include volatility model params in moments
+            avg_params = vol_model['avg_params']
+            param_names = vol_model['param_names']
+            model_params = {name: value for name, value in zip(param_names, avg_params)}
+            model_params['model_type'] = model_type
+            model_params['distribution'] = distribution
+
+            # Add persistence for GARCH-type models
+            if model_type.lower() == 'garch':
+                model_params['persistence'] = model_params.get('alpha', 0) + model_params.get('beta', 0)
         else:
             continue  # Skip this maturity if method is invalid
 
@@ -406,7 +585,7 @@ def get_hd_surface(model_results: pd.DataFrame,
             pdf_m = pdf_lm / M
             pdf_k = pdf_lm / K
             pdf_r = pdf_lm / (1 + R)
-        else:  # 'garch'
+        else:  # volatility models
             pdf_m = pdf_values
             pdf_lm = pdf_m * M
             pdf_k = pdf_lm / K
@@ -420,19 +599,19 @@ def get_hd_surface(model_results: pd.DataFrame,
         if return_domain == 'log_moneyness':
             x = LM
             pdf = pdf_lm
-            moments = get_all_moments(x, pdf, model_params if method == 'garch' else None)
+            moments = get_all_moments(x, pdf, model_params if method in ['garch', 'egarch'] else None)
         elif return_domain == 'moneyness':
             x = M
             pdf = pdf_m
-            moments = get_all_moments(x, pdf, model_params if method == 'garch' else None)
+            moments = get_all_moments(x, pdf, model_params if method in ['garch', 'egarch'] else None)
         elif return_domain == 'returns':
             x = R
             pdf = pdf_r
-            moments = get_all_moments(x, pdf, model_params if method == 'garch' else None)
+            moments = get_all_moments(x, pdf, model_params if method in ['garch', 'egarch'] else None)
         elif return_domain == 'strikes':
             x = K
             pdf = pdf_k
-            moments = get_all_moments(x, pdf, model_params if method == 'garch' else None)
+            moments = get_all_moments(x, pdf, model_params if method in ['garch', 'egarch'] else None)
         else:
             raise VolyError(f"Unsupported return_domain: {return_domain}")
 
@@ -445,7 +624,8 @@ def get_hd_surface(model_results: pd.DataFrame,
     # Create DataFrame with moments
     moments = pd.DataFrame(all_moments).T
 
-    logger.info(f"Historical density calculation complete using {method} method")
+    logger.info(
+        f"Historical density calculation complete using {method} method with {model_type} model and {distribution} distribution")
 
     return {
         'pdf_surface': pdf_surface,

{voly-0.0.142.dist-info → voly-0.0.144.dist-info}/METADATA

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

{voly-0.0.142.dist-info → voly-0.0.144.dist-info}/RECORD

@@ -1,5 +1,5 @@
 voly/__init__.py,sha256=8xyDk7rFCn_MOD5hxuv5cxxKZvBVRiSIM7TgaMPpwpw,211
-voly/client.py,sha256=Lj3YY6P1VBQD5C_psPh2pSxCMVvFjRBybrMrs4e9qXI,14249
+voly/client.py,sha256=UzgvwLf5SsNkvv3-Zdzej5nJ4pxoS-UCP8LjFMh3LFo,13229
 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=K2X0isAchumuRPcc5RSEkMOR5sOeb_I3twwqAZYYL1A,16809
+voly/core/hd.py,sha256=fIV97Xe5P-Aj_oGFDla5dZxAvfdk8Cjnb7DRCWnbSOY,25251
 voly/core/interpolate.py,sha256=JkK172-FXyhesW3hY4pEeuJWG3Bugq7QZXbeKoRpLuo,5305
 voly/core/rnd.py,sha256=masjK4WrVb925gPGboD8iDAaEN7FY7S4OHYthHPtA3o,13613
 voly/utils/__init__.py,sha256=E05mWatyC-PDOsCxQV1p5Xi1IgpOomxrNURyCx_gB-w,200
 voly/utils/logger.py,sha256=4-_2bVJmq17Q0d7Rd2mPg1AeR8gxv6EPvcmBDMFWcSM,1744
-voly-0.0.142.dist-info/licenses/LICENSE,sha256=wcHIVbE12jfcBOai_wqBKY6xvNQU5E909xL1zZNq_2Q,1065
-voly-0.0.142.dist-info/METADATA,sha256=BLz0X2tkaiZqfL5cYXcihLfbrZra3AQRrRXPXrNkS5w,4115
-voly-0.0.142.dist-info/WHEEL,sha256=DK49LOLCYiurdXXOXwGJm6U4DkHkg4lcxjhqwRa0CP4,91
-voly-0.0.142.dist-info/top_level.txt,sha256=ZfLw2sSxF-LrKAkgGjOmeTcw6_gD-30zvtdEY5W4B7c,5
-voly-0.0.142.dist-info/RECORD,,
+voly-0.0.144.dist-info/licenses/LICENSE,sha256=wcHIVbE12jfcBOai_wqBKY6xvNQU5E909xL1zZNq_2Q,1065
+voly-0.0.144.dist-info/METADATA,sha256=tU78Lvzik5rL9RhVKuW8jG7nMCqG2R5JN14-yOjY07s,4115
+voly-0.0.144.dist-info/WHEEL,sha256=DK49LOLCYiurdXXOXwGJm6U4DkHkg4lcxjhqwRa0CP4,91
+voly-0.0.144.dist-info/top_level.txt,sha256=ZfLw2sSxF-LrKAkgGjOmeTcw6_gD-30zvtdEY5W4B7c,5
+voly-0.0.144.dist-info/RECORD,,