voly 0.0.86__py3-none-any.whl → 0.0.87__py3-none-any.whl

voly/core/fit.py

@@ -20,13 +20,13 @@ warnings.filterwarnings("ignore")
 
 
 @catch_exception
-def calculate_residuals(params: List[float], ytm: float, option_chain: pd.DataFrame,
+def calculate_residuals(params: List[float], t: float, option_chain: pd.DataFrame,
                         model: Any = SVIModel) -> np.ndarray:
     """Calculate residuals between market and model implied volatilities."""
-    maturity_data = option_chain[option_chain['ytm'] == ytm]
+    maturity_data = option_chain[option_chain['t'] == t]
     w = np.array([model.svi(x, *params) for x in maturity_data['log_moneyness']])
     iv_actual = maturity_data['mark_iv'].values
-    return iv_actual - np.sqrt(w / ytm)
+    return iv_actual - np.sqrt(w / t)
 
 
 @catch_exception
@@ -57,22 +57,21 @@ def fit_model(option_chain: pd.DataFrame,
     column_dtypes = {
         's': float,
         'u': float,
+        't': float,
+        'r': float,
+        'oi': float,
+        'volume': float,
         'maturity_date': 'datetime64[ns]',
-        'dtm': float,
-        'ytm': float,
         'a': float,
         'b': float,
+        'sigma': float,
         'rho': float,
         'm': float,
-        'sigma': float,
         'nu': float,
         'psi': float,
         'p': float,
         'c': float,
         'nu_tilde': float,
-        'oi': float,
-        'volume': float,
-        'r': float,
         'fit_success': bool,
         'cost': float,
         'optimality': float,
@@ -84,8 +83,8 @@ def fit_model(option_chain: pd.DataFrame,
     }
 
     # Get unique maturities and sort them
-    unique_ytms = sorted(option_chain['ytm'].unique())
-    maturity_names = [option_chain[option_chain['ytm'] == ytm]['maturity_name'].iloc[0] for ytm in unique_ytms]
+    unique_ts = sorted(option_chain['t'].unique())
+    maturity_names = [option_chain[option_chain['t'] == t]['maturity_name'].iloc[0] for t in unique_ts]
 
     # Store results in a dictionary first
     results_data = {col: [] for col in column_dtypes.keys()}
@@ -95,11 +94,10 @@ def fit_model(option_chain: pd.DataFrame,
 
     s = option_chain['index_price'].iloc[-1]
 
-    for ytm in unique_ytms:
+    for t in unique_ts:
         # Get data for this maturity
-        maturity_data = option_chain[option_chain['ytm'] == ytm]
+        maturity_data = option_chain[option_chain['t'] == t]
         maturity_name = maturity_data['maturity_name'].iloc[0]
-        dtm = maturity_data['dtm'].iloc[0]
 
         logger.info(f"Optimizing for {maturity_name}...")
 
@@ -108,7 +106,7 @@ def fit_model(option_chain: pd.DataFrame,
             result = least_squares(
                 calculate_residuals,
                 initial_params,
-                args=(ytm, option_chain, SVIModel),
+                args=(t, option_chain, SVIModel),
                 bounds=param_bounds,
                 max_nfev=1000
             )
@@ -120,7 +118,7 @@ def fit_model(option_chain: pd.DataFrame,
 
         # Calculate model predictions for statistics
         w = np.array([SVIModel.svi(x, *result.x) for x in maturity_data['log_moneyness']])
-        iv_model = np.sqrt(w / ytm)
+        iv_model = np.sqrt(w / t)
         iv_market = maturity_data['mark_iv'].values
 
         # Calculate statistics
@@ -138,27 +136,26 @@ def fit_model(option_chain: pd.DataFrame,
         r = maturity_data['interest_rate'].iloc[0] if 'interest_rate' in maturity_data.columns else 0
 
         # Calculate Jump-Wing parameters
-        nu, psi, p, c, nu_tilde = SVIModel.raw_to_jw_params(a, b, sigma, rho, m, ytm)
+        nu, psi, p, c, nu_tilde = SVIModel.raw_to_jw_params(a, b, sigma, rho, m, t)
 
         # Store values in the results dictionary with proper types
         results_data['s'].append(float(s))
         results_data['u'].append(float(u))
+        results_data['t'].append(float(t))
+        results_data['r'].append(float(r))
+        results_data['oi'].append(float(oi))
+        results_data['volume'].append(float(volume))
         results_data['maturity_date'].append(maturity_data['maturity_date'].iloc[0])
-        results_data['dtm'].append(float(dtm))
-        results_data['ytm'].append(float(ytm))
         results_data['a'].append(float(a))
         results_data['b'].append(float(b))
-        results_data['rho'].append(float(rho))
-        results_data['m'].append(float(m))
         results_data['sigma'].append(float(sigma))
+        results_data['m'].append(float(m))
+        results_data['rho'].append(float(rho))
         results_data['nu'].append(float(nu))
         results_data['psi'].append(float(psi))
         results_data['p'].append(float(p))
         results_data['c'].append(float(c))
         results_data['nu_tilde'].append(float(nu_tilde))
-        results_data['oi'].append(float(oi))
-        results_data['volume'].append(float(volume))
-        results_data['r'].append(float(r))
         results_data['fit_success'].append(bool(result.success))
         results_data['cost'].append(float(result.cost))
         results_data['optimality'].append(float(result.optimality))
@@ -189,7 +186,7 @@ def fit_model(option_chain: pd.DataFrame,
 
 @catch_exception
 def get_iv_surface(model_results: pd.DataFrame,
-                   log_moneyness_params: Tuple[float, float, int] = (-1.5, 1.5, 1000),
+                   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]]:
     """
     Generate implied volatility surface using optimized SVI parameters.
@@ -198,8 +195,8 @@ def get_iv_surface(model_results: pd.DataFrame,
 
     Parameters:
     - model_results: DataFrame from fit_model() or interpolate_model(). Maturity names or DTM as Index
-    - log_moneyness_params: Tuple of (min, max, num_points) for the moneyness grid
-    - return_domain: Domain for x-axis values ('log_moneyness', 'moneyness', 'strikes', 'delta')
+    - domain_params: Tuple of (min, max, num_points) for the log-moneyness array
+    - return_domain: Domain for x-axis values ('log_moneyness', 'moneyness', 'returns', 'strikes', 'delta')
 
     Returns:
     - Tuple of (iv_surface, x_surface)
@@ -207,14 +204,13 @@ def get_iv_surface(model_results: pd.DataFrame,
       x_surface: Dictionary mapping maturity/dtm names to requested x domain arrays
     """
     # Check if required columns are present
-    required_columns = ['a', 'b', 'rho', 'm', 'sigma', 'ytm']
+    required_columns = ['a', 'b', 'sigma', 'rho', 'm', 't']
     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}")
 
     # Generate implied volatility surface in log-moneyness domain
-    min_m, max_m, num_points = log_moneyness_params
-    log_moneyness_array = np.linspace(min_m, max_m, num=num_points)
+    LM = np.linspace(domain_params[0], domain_params[1], domain_params[2])
 
     iv_surface = {}
     x_surface = {}
@@ -229,21 +225,17 @@ def get_iv_surface(model_results: pd.DataFrame,
             model_results.loc[i, 'rho'],
             model_results.loc[i, 'm']
         ]
-        ytm = model_results.loc[i, 'ytm']
+        s = model_results.loc[i, 's'],
+        r = model_results.loc[i, 'r'],
+        t = model_results.loc[i, 't']
 
         # Calculate implied volatility
-        w_svi = np.array([SVIModel.svi(x, *params) for x in log_moneyness_array])
-        iv_array = np.sqrt(w_svi / ytm)
-        iv_surface[i] = iv_array
+        w = np.array([SVIModel.svi(x, *params) for x in LM])
+        o = np.sqrt(w / t)
+        iv_surface[i] = o
 
         # Calculate x domain for this maturity/dtm
-        x_surface[i] = get_x_domain(
-            log_moneyness_params=log_moneyness_params,
-            return_domain=return_domain,
-            s=model_results.loc[i, 's'],
-            r=model_results.loc[i, 'r'],
-            iv_array=iv_array,
-            ytm=ytm
-        )
+        x = get_domain(domain_params, s, o, r, t, return_domain)
+        x_surface[i] = x
 
     return iv_surface, x_surface

voly/core/interpolate.py

@@ -36,7 +36,7 @@ def interpolate_model(fit_results: pd.DataFrame,
         raise VolyError("Fit results DataFrame is empty or None")
 
     # Extract years to maturity from fit_results
-    original_ytms = fit_results['ytm'].values
+    original_ytms = fit_results['t'].values
 
     if len(original_ytms) < 2:
         raise VolyError("Need at least two maturities in fit_results to interpolate")
@@ -68,14 +68,13 @@ def interpolate_model(fit_results: pd.DataFrame,
                 "Extrapolation may give unreliable results.")
 
     # Columns to interpolate
-    param_columns = ['u', 'a', 'b', 'rho', 'm', 'sigma', 'nu', 'psi', 'p', 'c', 'nu_tilde']
+    param_columns = ['u', 'a', 'b', 'sigma', 'rho', 'm', 'nu', 'psi', 'p', 'c', 'nu_tilde']
 
     # Create empty DataFrame for interpolated results
     interpolated_df = pd.DataFrame(index=[f"{day}d" for day in target_days])
 
     # Generate YTM and maturity dates for interpolated results
-    interpolated_df['dtm'] = target_days
-    interpolated_df['ytm'] = [day / 365.25 for day in target_days]
+    interpolated_df['t'] = target_years
 
     # Calculate maturity dates
     now = dt.datetime.now()
@@ -120,8 +119,8 @@ def interpolate_model(fit_results: pd.DataFrame,
                 interpolated_df[param] = f(target_years)
 
     # Ensure consistent ordering of columns with expected structure
-    expected_columns = ['s', 'u', 'maturity_date', 'dtm', 'ytm', 'a', 'b', 'rho', 'm', 'sigma',
-                        'nu', 'psi', 'p', 'c', 'nu_tilde', 'r']
+    expected_columns = ['s', 'u', 't', 'r', 'maturity_date', 'a', 'b', 'sigma', 'rho', 'm',
+                        'nu', 'psi', 'p', 'c', 'nu_tilde']
 
     # Create final column order based on available columns
     column_order = [col for col in expected_columns if col in interpolated_df.columns]