voly 0.0.152__py3-none-any.whl → 0.0.154__py3-none-any.whl

voly/core/rnd.py

@@ -9,154 +9,9 @@ from typing import Dict, List, Tuple, Optional, Union, Any, Callable
 from voly.utils.logger import logger, catch_exception
 from voly.exceptions import VolyError
 from voly.models import SVIModel
-from voly.formulas import bs, d1, d2, get_domain
+from voly.formulas import bs, d1, d2
 from scipy import stats
-
-
-@catch_exception
-def _prepare_domains(domain_params, s, r, o, t):
-    """
-    Calculate domain arrays for different representations (log_moneyness, moneyness, etc.).
-
-    Parameters:
-    -----------
-    domain_params : tuple
-        (min_log_moneyness, max_log_moneyness, num_points)
-    s : float
-        Spot price
-    r : float
-        Risk-free rate
-    o : ndarray
-        Implied volatility array
-    t : float
-        Time to expiry in years
-
-    Returns:
-    --------
-    dict
-        Dictionary containing arrays for different domains
-    """
-    domains = {}
-    domains['log_moneyness'] = get_domain(domain_params, s, r, o, t, 'log_moneyness')
-    domains['moneyness'] = get_domain(domain_params, s, r, o, t, 'moneyness')
-    domains['returns'] = get_domain(domain_params, s, r, o, t, 'returns')
-    domains['strikes'] = get_domain(domain_params, s, r, o, t, 'strikes')
-    domains['delta'] = get_domain(domain_params, s, r, o, t, 'delta')
-
-    # Precompute differentials for integration
-    domains['dx'] = domains['log_moneyness'][1] - domains['log_moneyness'][0]
-
-    return domains
-
-
-@catch_exception
-def _normalize_density(pdf_values, dx):
-    """
-    Normalize a probability density function to integrate to 1.
-
-    Parameters:
-    -----------
-    pdf_values : ndarray
-        Array of PDF values
-    dx : float
-        Grid spacing
-
-    Returns:
-    --------
-    ndarray
-        Normalized PDF values
-    """
-    total_area = np.sum(pdf_values * dx)
-    if total_area <= 0:
-        logger.warning("PDF area is negative or zero, using absolute values")
-        total_area = np.sum(np.abs(pdf_values) * dx)
-
-    return pdf_values / total_area
-
-
-@catch_exception
-def _transform_to_domains(rnd_k, domains):
-    """
-    Transform density from strike domain to other domains.
-
-    Parameters:
-    -----------
-    rnd_k : ndarray
-        PDF in strike domain
-    domains : dict
-        Domain arrays
-
-    Returns:
-    --------
-    dict
-        Dictionary of PDFs in different domains
-    """
-    LM = domains['log_moneyness']
-    M = domains['moneyness']
-    K = domains['strikes']
-    R = domains['returns']
-    dx = domains['dx']
-
-    # Calculate PDF in different domains
-    rnd_lm = rnd_k * K  # Convert to log-moneyness domain
-    pdf_lm = _normalize_density(rnd_lm, dx)
-
-    # Transform to other domains
-    pdf_k = pdf_lm / K
-    pdf_m = pdf_k * domains['strikes'][0]  # s = K[0] * M[0]
-    pdf_r = pdf_lm / (1 + R)
-
-    # For delta domain, need special handling due to non-monotonicity
-    pdf_d1 = stats.norm.pdf(d1(domains['strikes'][0], K, 0, domains['delta'][0], 1, option_type='call'))
-    dd_dK = pdf_d1 / (domains['delta'][0] * np.sqrt(1) * K)
-    pdf_d = pdf_k / dd_dK
-
-    # Calculate CDF
-    cdf = np.cumsum(pdf_lm * dx)
-    cdf = np.minimum(cdf / cdf[-1], 1.0)  # Ensure max value is 1
-
-    return {
-        'log_moneyness': pdf_lm,
-        'moneyness': pdf_m,
-        'returns': pdf_r,
-        'strikes': pdf_k,
-        'delta': pdf_d,
-        'cdf': cdf
-    }
-
-
-@catch_exception
-def _select_domain_results(pdfs, domains, return_domain):
-    """
-    Select results for the requested domain.
-
-    Parameters:
-    -----------
-    pdfs : dict
-        PDFs in different domains
-    domains : dict
-        Domain arrays
-    return_domain : str
-        Requested domain
-
-    Returns:
-    --------
-    tuple
-        (pdf, cdf, x, moments)
-    """
-    if return_domain == 'delta':
-        # Special handling for delta domain due to potential non-monotonicity
-        D = domains['delta']
-        pdf_d = pdfs['delta']
-        sort_idx = np.argsort(D)
-        x = D[sort_idx]
-        pdf = pdf_d[sort_idx]
-    else:
-        x = domains[return_domain]
-        pdf = pdfs[return_domain]
-
-    moments = get_all_moments(x, pdf)
-    return pdf, pdfs['cdf'], x, moments
+from voly.utils.density import prepare_domains, normalize_density, transform_to_domains, select_domain_results
 
 
 @catch_exception
@@ -177,7 +32,7 @@ def breeden(domain_params, s, r, o, t, return_domain):
     t : float
         Time to expiry in years
     return_domain : str
-        Domain for results ('log_moneyness', 'moneyness', 'returns', 'strikes', 'delta')
+        Domain for results ('log_moneyness', 'moneyness', 'returns', 'strikes')
 
     Returns:
     --------
@@ -185,8 +40,9 @@ def breeden(domain_params, s, r, o, t, return_domain):
         (pdf, cdf, x, moments)
     """
     # Prepare domain arrays
-    domains = _prepare_domains(domain_params, s, r, o, t)
+    domains = prepare_domains(domain_params, s)
     K = domains['strikes']
+    dx = domains['dx']
 
     # Calculate option prices and derivatives
     c = bs(s, K, r, o, t, option_type='call')
@@ -196,11 +52,21 @@ def breeden(domain_params, s, r, o, t, return_domain):
     # Calculate RND in strike domain and apply discount factor
     rnd_k = np.maximum(np.exp(r * t) * c2, 0)
 
+    # Transform to log-moneyness domain first
+    LM = domains['log_moneyness']
+    rnd_lm = rnd_k * K  # Convert to log-moneyness domain
+    pdf_lm = normalize_density(rnd_lm, dx)
+
     # Transform to other domains
-    pdfs = _transform_to_domains(rnd_k, domains)
+    pdfs = transform_to_domains(pdf_lm, domains)
 
     # Return results for requested domain
-    return _select_domain_results(pdfs, domains, return_domain)
+    pdf, cdf, x = select_domain_results(pdfs, domains, return_domain)
+
+    # Calculate moments
+    moments = get_all_moments(x, pdf)
+
+    return pdf, cdf, x, moments
 
 
 @catch_exception
@@ -221,7 +87,7 @@ def rookley(domain_params, s, r, o, t, return_domain):
     t : float
         Time to expiry in years
     return_domain : str
-        Domain for results ('log_moneyness', 'moneyness', 'returns', 'strikes', 'delta')
+        Domain for results ('log_moneyness', 'moneyness', 'returns', 'strikes')
 
     Returns:
     --------
@@ -229,9 +95,10 @@ def rookley(domain_params, s, r, o, t, return_domain):
         (pdf, cdf, x, moments)
     """
     # Prepare domain arrays
-    domains = _prepare_domains(domain_params, s, r, o, t)
+    domains = prepare_domains(domain_params, s)
     M = domains['moneyness']
     K = domains['strikes']
+    dx = domains['dx']
 
     # Calculate volatility derivatives with respect to moneyness
     o1 = np.gradient(o, M)
@@ -287,11 +154,21 @@ def rookley(domain_params, s, r, o, t, return_domain):
     # Calculate RND in strike domain and apply discount factor
     rnd_k = np.maximum(ert * s * dd_c_K, 0)
 
+    # Transform to log-moneyness domain first
+    LM = domains['log_moneyness']
+    rnd_lm = rnd_k * K  # Convert to log-moneyness domain
+    pdf_lm = normalize_density(rnd_lm, dx)
+
     # Transform to other domains
-    pdfs = _transform_to_domains(rnd_k, domains)
+    pdfs = transform_to_domains(pdf_lm, domains)
 
     # Return results for requested domain
-    return _select_domain_results(pdfs, domains, return_domain)
+    pdf, cdf, x = select_domain_results(pdfs, domains, return_domain)
+
+    # Calculate moments
+    moments = get_all_moments(x, pdf)
+
+    return pdf, cdf, x, moments
 
 
 @catch_exception
@@ -433,7 +310,7 @@ def get_rnd_surface(model_results: pd.DataFrame,
     domain_params : tuple
         (min_log_moneyness, max_log_moneyness, num_points)
     return_domain : str
-        Domain for results ('log_moneyness', 'moneyness', 'returns', 'strikes', 'delta')
+        Domain for results ('log_moneyness', 'moneyness', 'returns', 'strikes')
     method : str
         Method for RND estimation ('rookley' or 'breeden')
 
@@ -453,7 +330,7 @@ def get_rnd_surface(model_results: pd.DataFrame,
         raise VolyError(f"Invalid method: {method}. Must be 'rookley' or 'breeden'")
 
     # Validate return_domain
-    valid_domains = ['log_moneyness', 'moneyness', 'returns', 'strikes', 'delta']
+    valid_domains = ['log_moneyness', 'moneyness', 'returns', 'strikes']
     if return_domain not in valid_domains:
         raise VolyError(f"Invalid return_domain: {return_domain}. Must be one of {valid_domains}")
 

voly/utils/density.py

@@ -0,0 +1,155 @@
+"""
+Common utility functions for probability density calculations.
+
+This module contains shared utility functions for working with probability
+densities across different domains, used by both RND and HD calculations.
+"""
+
+import numpy as np
+from typing import Dict, Tuple, List, Any
+from scipy import stats
+from voly.utils.logger import catch_exception
+from voly.formulas import d1, d2
+
+
+@catch_exception
+def prepare_domains(domain_params: Tuple[float, float, int],
+                    s: float) -> Dict[str, np.ndarray]:
+    """
+    Calculate domain arrays for different representations.
+
+    Parameters:
+    -----------
+    domain_params : Tuple[float, float, int]
+        (min_log_moneyness, max_log_moneyness, num_points)
+    s : float
+        Spot price
+
+    Returns:
+    --------
+    Dict[str, np.ndarray]
+        Dictionary containing arrays for different domains
+    """
+    # Create log-moneyness grid
+    LM = np.linspace(domain_params[0], domain_params[1], domain_params[2])
+
+    # Calculate other domains
+    M = np.exp(LM)  # Moneyness
+    R = M - 1  # Returns
+    K = s / M  # Strike prices
+
+    # Precompute differentials for integration
+    dx = LM[1] - LM[0]
+
+    return {
+        'log_moneyness': LM,
+        'moneyness': M,
+        'returns': R,
+        'strikes': K,
+        'dx': dx
+    }
+
+
+@catch_exception
+def normalize_density(pdf_values: np.ndarray,
+                      dx: float) -> np.ndarray:
+    """
+    Normalize a probability density function to integrate to 1.
+
+    Parameters:
+    -----------
+    pdf_values : np.ndarray
+        Array of PDF values
+    dx : float
+        Grid spacing
+
+    Returns:
+    --------
+    np.ndarray
+        Normalized PDF values
+    """
+    total_area = np.trapz(pdf_values, dx=dx)
+
+    if total_area <= 0:
+        # If area is negative or zero, use absolute values
+        total_area = np.trapz(np.abs(pdf_values), dx=dx)
+
+    # Handle very small values to prevent division by zero
+    if abs(total_area) < 1e-10:
+        return np.zeros_like(pdf_values)
+
+    return pdf_values / total_area
+
+
+@catch_exception
+def transform_to_domains(pdf_lm: np.ndarray,
+                         domains: Dict[str, np.ndarray]) -> Dict[str, np.ndarray]:
+    """
+    Transform density from log-moneyness domain to other domains.
+
+    Parameters:
+    -----------
+    pdf_lm : np.ndarray
+        PDF in log-moneyness domain
+    domains : Dict[str, np.ndarray]
+        Domain arrays
+
+    Returns:
+    --------
+    Dict[str, np.ndarray]
+        Dictionary of PDFs in different domains
+    """
+    LM = domains['log_moneyness']
+    M = domains['moneyness']
+    K = domains['strikes']
+    R = domains['returns']
+    dx = domains['dx']
+
+    # Transform to other domains
+    pdf_m = pdf_lm / 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)  # Ensure max value is 1
+
+    return {
+        'log_moneyness': pdf_lm,
+        'moneyness': pdf_m,
+        'returns': pdf_r,
+        'strikes': pdf_k,
+        'cdf': cdf
+    }
+
+
+@catch_exception
+def select_domain_results(pdfs: Dict[str, np.ndarray],
+                          domains: Dict[str, np.ndarray],
+                          return_domain: str) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """
+    Select results for the requested domain.
+
+    Parameters:
+    -----------
+    pdfs : Dict[str, np.ndarray]
+        PDFs in different domains
+    domains : Dict[str, np.ndarray]
+        Domain arrays
+    return_domain : str
+        Requested domain
+
+    Returns:
+    --------
+    Tuple[np.ndarray, np.ndarray, np.ndarray]
+        (pdf, cdf, x) in the requested domain
+    """
+    if return_domain not in domains or return_domain not in pdfs:
+        valid_domains = set(domains.keys()).intersection(set(pdfs.keys()))
+        raise ValueError(f"Invalid return_domain: {return_domain}. Must be one of {valid_domains}")
+
+    x = domains[return_domain]
+    pdf = pdfs[return_domain]
+    cdf = pdfs['cdf']
+
+    return pdf, cdf, x

{voly-0.0.152.dist-info → voly-0.0.154.dist-info}/METADATA

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

{voly-0.0.152.dist-info → voly-0.0.154.dist-info}/RECORD

@@ -1,5 +1,5 @@
 voly/__init__.py,sha256=8xyDk7rFCn_MOD5hxuv5cxxKZvBVRiSIM7TgaMPpwpw,211
-voly/client.py,sha256=Jlep-VUW0jFW6dX6AE13CUsbG78u1UeNaWNLW7g2l08,13414
+voly/client.py,sha256=JCofJv9BsLHh5E-NQ-1Y2IB0PbZBhE7OqT_bcDL-ktM,14355
 voly/exceptions.py,sha256=PBsbn1vNMvKcCJwwJ4lBO6glD85jo1h2qiEmD7ArAjs,92
 voly/formulas.py,sha256=G_soRiPwQlHy6milOAj6TdmBWr-fNZpMvm0joXAMZ90,10767
 voly/models.py,sha256=o-pHujGfr5Gn8ItckMzLI4Q8yaX9FQaV8UjCxv2zgTY,3364
@@ -7,13 +7,14 @@ 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=inw1AfGKgOfFsuiYELxcCrnRs8fM0JIKlO4L2MQBBC8,30431
+voly/core/hd.py,sha256=_JLdeNlnwZPafs4oRO_ydGrG6aqgcZKo_HQ503Ifo0s,8525
 voly/core/interpolate.py,sha256=JkK172-FXyhesW3hY4pEeuJWG3Bugq7QZXbeKoRpLuo,5305
-voly/core/rnd.py,sha256=AvGsITB52-Ti9AOA2lj2N4UAyJUtD-Bs37HRwLbzRsA,16043
+voly/core/rnd.py,sha256=3rhIA2rN2jcw2JvXDFsZgA62RZVgepshNculwo2X9zc,12912
 voly/utils/__init__.py,sha256=E05mWatyC-PDOsCxQV1p5Xi1IgpOomxrNURyCx_gB-w,200
+voly/utils/density.py,sha256=fUJf1AsbyqwxBlhAP53RvcI4KxVEmRRtXXW1WSMFTFE,4017
 voly/utils/logger.py,sha256=4-_2bVJmq17Q0d7Rd2mPg1AeR8gxv6EPvcmBDMFWcSM,1744
-voly-0.0.152.dist-info/licenses/LICENSE,sha256=wcHIVbE12jfcBOai_wqBKY6xvNQU5E909xL1zZNq_2Q,1065
-voly-0.0.152.dist-info/METADATA,sha256=ojr_D--Jhv-Ldsfql3-PGcx0TAFaxMADg37TaYsKyNI,4115
-voly-0.0.152.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-voly-0.0.152.dist-info/top_level.txt,sha256=ZfLw2sSxF-LrKAkgGjOmeTcw6_gD-30zvtdEY5W4B7c,5
-voly-0.0.152.dist-info/RECORD,,
+voly-0.0.154.dist-info/licenses/LICENSE,sha256=wcHIVbE12jfcBOai_wqBKY6xvNQU5E909xL1zZNq_2Q,1065
+voly-0.0.154.dist-info/METADATA,sha256=BqU2_2IpUkTunLU5iY2t1yiKGi3-yy0NHriboOKX88k,4115
+voly-0.0.154.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+voly-0.0.154.dist-info/top_level.txt,sha256=ZfLw2sSxF-LrKAkgGjOmeTcw6_gD-30zvtdEY5W4B7c,5
+voly-0.0.154.dist-info/RECORD,,