sdevpy 1.0.8__tar.gz → 1.0.9__tar.gz

{sdevpy-1.0.8 → sdevpy-1.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sdevpy
-Version: 1.0.8
+Version: 1.0.9
 Summary: Python package for Finance
 Author-email: Sebastien Gurrieri <sebgur@gmail.com>
 Project-URL: Git page, https://github.com/sebgur/SDev.Python

{sdevpy-1.0.8 → sdevpy-1.0.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sdevpy"
-version = "1.0.8"
+version = "1.0.9"
 license-files = []
 authors = [{ name="Sebastien Gurrieri", email="sebgur@gmail.com" }]
 description = "Python package for Finance"
@@ -38,6 +38,17 @@ target-version = "py313"
 select = ["E", "F", "N", "W", "UP", "B"]
 ignore = ["E401", "I001"]
 
+[tool.coverage.run]
+omit = [
+    "sdevpy/**/__init__.py",
+    "sdevpy/projects/raschka/*"
+]
+
+[tool.coverage.report]
+exclude_lines = [
+    "if __name__ == '__main__':",
+]
+
 [project.urls]
 "Git page" = "https://github.com/sebgur/SDev.Python"
 "SDev Finance" = "http://sdev-finance.com/"

{sdevpy-1.0.8 → sdevpy-1.0.9}/sdevpy/analytics/bachelier.py

@@ -6,7 +6,7 @@ from scipy.optimize import minimize_scalar
 
 
 def price(expiry: npt.ArrayLike, strike: npt.ArrayLike, is_call: npt.ArrayLike, fwd: npt.ArrayLike,
-          vol: npt.ArrayLike) -> npt.ArrayLike:
+          vol: npt.ArrayLike) -> npt.NDArray[np.float64]:
     """ Option price under the Bachelier model """
     stdev = vol * expiry**0.5
     d = (fwd - strike) / stdev
@@ -16,22 +16,11 @@ def price(expiry: npt.ArrayLike, strike: npt.ArrayLike, is_call: npt.ArrayLike,
 
 
 def price_straddles(expiry: npt.ArrayLike, strike: npt.ArrayLike, fwd: npt.ArrayLike,
-                    vol: npt.ArrayLike) -> npt.ArrayLike:
-    """ Straddle price under the Bachelier model.
-        Note: we could improve the speed by writing the code in-line instead of
-              calling the price() function twice """
-    expiries_ = np.asarray(expiry).reshape(-1, 1)
-    prices = []
-    for i, exp_row in enumerate(expiries_):
-        k_prices = []
-        for j, k in enumerate(strike[i]):
-            iv = vol[i, j]
-            call_price = price(exp_row, k, True, fwd, iv)
-            put_price = price(exp_row, k, False, fwd, iv)
-            k_prices.append(call_price[0] + put_price[0])
-        prices.append(k_prices)
-
-    return np.asarray(prices)
+                    vol: npt.ArrayLike) -> npt.NDArray[np.float64]:
+    """ Straddle price under the Bachelier model """
+    call = price(expiry[:, None], strike, True, fwd, vol)
+    put = price(expiry[:, None], strike, False, fwd, vol)
+    return call + put
 
 
 def implied_vol_jaeckel(expiry: float, strike: float, is_call: bool, fwd: float, fwd_price: float) -> float:
@@ -81,6 +70,8 @@ def implied_vol(expiry: npt.ArrayLike, strike: npt.ArrayLike, is_call: npt.Array
     strike = np.asarray(strike, dtype=float)
     fwd_price = np.asarray(fwd_price, dtype=float)
     is_call = np.asarray(is_call, dtype=bool)
+    # expiry = float(expiry)
+    # fwd = float(fwd)
 
     #### ATM branch ####
     m = fwd - strike

{sdevpy-1.0.8 → sdevpy-1.0.9}/sdevpy/analytics/black.py

@@ -3,7 +3,6 @@ import numpy as np
 import numpy.typing as npt
 from scipy.stats import norm
 from scipy.optimize import minimize_scalar
-from sdevpy.thirdparty.py_vollib.black import implied_volatility as jaeckel
 from sdevpy.utilities.tools import isiterable
 
 
@@ -34,7 +33,7 @@ def implied_vol(expiry: float, strike: float, is_call: bool, fwd: float, fwd_pri
 
 
 def implied_vols(expiry: float, strike: npt.ArrayLike, is_call: bool, fwd: float,
-                 fwd_price: npt.ArrayLike) -> npt.ArrayLike:
+                 fwd_price: npt.ArrayLike) -> npt.NDArray[np.float64]:
     """ Black implied volatility for vector of strikes/prices """
     if isiterable(strike) and isiterable(fwd_price):
         ivs = [implied_vol(expiry, k, is_call, fwd, p) for k, p in zip(strike, fwd_price, strict=True)]
@@ -46,7 +45,7 @@ def implied_vols(expiry: float, strike: npt.ArrayLike, is_call: bool, fwd: float
 
 
 def implied_vol_newton(expiry: float, strike: npt.ArrayLike, is_call: bool, fwd: float,
-                       fwd_price: npt.ArrayLike, tol: float=1e-8, max_iter: int=50) -> npt.ArrayLike:
+                       fwd_price: npt.ArrayLike, tol: float=1e-8, max_iter: int=50) -> npt.NDArray[np.float64]:
     """ Using vectorized Newton-Raphson, with faster convergence than Brent.
         However, this method can struggle for very small vegas, so we may want to switch
         to another method (maybe Brent above) below a certain vega threshold.
@@ -66,22 +65,12 @@ def implied_vol_newton(expiry: float, strike: npt.ArrayLike, is_call: bool, fwd:
         if np.all(np.abs(diff) < tol):
             break
 
-    # if len(strike) == 1 and len(fwd_price) == 1 and len(vol) == 1: # Return a scalar if inputs are scalar
-    #     return vol[0]
-    # else:
-    #     return vol
-    return (vol.item() if vol.ndim == 0 or vol.size ==1 else vol)
-
-
-def implied_vol_jaeckel(expiry: float, strike: float, is_call: bool, fwd: float, fwd_price: float) -> float:
-    """ Black-Scholes implied volatility using P. Jaeckel's 'Let's be rational' method,
-        from package py_vollib. Install with pip install py_vollib or at
-        https://pypi.org/project/py_vollib/. Unfortunately we found it has instabilities
-        near ATM. """
-    flag = 'c' if is_call else 'p'
-    p = fwd_price
-    iv = jaeckel.implied_volatility_of_undiscounted_option_price(p, fwd, strike, expiry, flag)
-    return iv
+    # # if len(strike) == 1 and len(fwd_price) == 1 and len(vol) == 1: # Return a scalar if inputs are scalar
+    # #     return vol[0]
+    # # else:
+    # #     return vol
+    # return (vol.item() if vol.ndim == 0 or vol.size ==1 else vol)
+    return vol
 
 
 if __name__ == "__main__":
@@ -98,8 +87,8 @@ if __name__ == "__main__":
     k_space = np.linspace(20, 2180, NUM_POINTS)
     prices = price(EXPIRY, k_space, IS_CALL, f_space, VOL)
     # print(prices)
-    implied_vols = []
+    iv_results = []
     for i, k in enumerate(k_space):
-        implied_vols.append(implied_vol(EXPIRY, k, IS_CALL, f_space[i], prices[i]))
+        iv_results.append(implied_vol(EXPIRY, k, IS_CALL, f_space[i], prices[i]))
 
-    # print(implied_vols)
+    # print(iv_results)

{sdevpy-1.0.8 → sdevpy-1.0.9}/sdevpy/maths/optimization.py

@@ -39,8 +39,9 @@ def create_bounds(lw_bounds: list[float], up_bounds: list[float]):
 
 class Optimizer(ABC):
     @abstractmethod
-    def minimize(self, f, x0, args, bounds):
+    def minimize(self, f, x0, args=(), bounds=None):
         """ Minimization """
+        pass
 
 
 class SciPyOptimizer(Optimizer):

{sdevpy-1.0.8 → sdevpy-1.0.9}/sdevpy/tests/test_analytics.py

@@ -57,6 +57,20 @@ def test_black_roundtrip_newton():
 
 ############ Bachelier ############################################################################
 
+def test_bachelier_straddle_function():
+    """ Straddle prices through straddle function """
+    expiry = np.array([0.5, 1.0])
+    strike = np.array([[0.03, 0.04, 0.05],
+                       [0.035, 0.045, 0.055]])
+    fwd = 0.04
+    vol = np.full((2, 3), 0.05)
+
+    test = bachelier.price_straddles(expiry, strike, fwd, vol)
+    ref = np.asarray([[0.0293304, 0.02820948, 0.0293304], [0.04009353, 0.04009353, 0.04167612]])
+    # print(test)
+    assert np.allclose(test, ref, 1e-10)
+
+
 def test_bachelier_price_straddle():
     """ Straddle = Call + Put """
     expiry, fwd, strike, vol = 1.0, 0.04, 0.045, 0.05
@@ -129,4 +143,4 @@ def test_bachelier_roundtrip_brent():
 
 
 if __name__ == "__main__":
-    test_bachelier_roundtrip()
+    test_bachelier_straddle_function()

sdevpy-1.0.9/sdevpy/tests/test_cointegration.py

@@ -0,0 +1,96 @@
+import numpy as np
+import pandas as pd
+from statsmodels.tsa.vector_ar.vecm import coint_johansen
+from sdevpy.timeseries.cointegration import johansen_test, check_johansen_stats_fast
+
+
+# Fixed seed — strong cointegration so results are deterministic
+# _RNG = np.random.default_rng(42)
+
+
+def make_cointegrated(n=1000, a=2.0, noise_scale=0.005, seed=42):
+    """Two cointegrated series: y2 = a * y1 + small_noise.
+    Cointegrating vector (normalised): [1, -1/a].
+    """
+    rng = np.random.default_rng(seed)
+    # if rng is None:
+    #     rng = _RNG
+    y1 = np.cumsum(rng.normal(0, 1, n))
+    y2 = a * y1 + rng.normal(0, noise_scale, n)
+    dates = pd.date_range("2000-01-01", periods=n, freq="B")
+    return pd.DataFrame({"y1": y1, "y2": y2}, index=dates)
+
+
+def test_cointegration_johansen_test_weights_shape():
+    """One weight per asset (column)."""
+    df = make_cointegrated()
+    result = johansen_test(df)
+    assert len(result["weights"]) == df.shape[1]
+
+
+def test_cointegration_johansen_test_first_weight_is_one():
+    """norm_1st_eigvec() divides by evec[0][0], so weights[0] must always be 1."""
+    result = johansen_test(make_cointegrated())
+    assert np.isclose(result["weights"][0], 1.0)
+
+
+def test_cointegration_johansen_test_weight_ratio_close_to_minus_1_over_a():
+    """For y2 = a*y1 + noise the ratio w[1]/w[0] must be ≈ -1/a."""
+    a = 2.0
+    # Extra-strong cointegration and long series for a tight numerical check
+    # rng = np.random.default_rng(0)
+    df = make_cointegrated(n=2000, a=a, noise_scale=0.001)#, rng=rng)
+    w = johansen_test(df)["weights"]
+    assert abs(w[1] / w[0] - (-1.0 / a)) < 0.05
+
+
+def test_cointegration_johansen_test_basket_is_stationary():
+    """ The Johansen basket w·y must drift far less than y1 alone """
+    a = 2.0
+    df = make_cointegrated(a=a)
+    w = johansen_test(df)["weights"]
+
+    basket = df["y1"].values * w[0] + df["y2"].values * w[1]
+    basket_range = basket.max() - basket.min()
+    y1_range    = df["y1"].max() - df["y1"].min()
+    assert basket_range < 0.1 * y1_range
+
+
+def test_cointegration_johansen_test_detects_cointegration_at_5pct():
+    """A clearly cointegrated pair must pass both trace and eigen tests at 5%."""
+    result = johansen_test(make_cointegrated(n=2000, noise_scale=0.001))
+    assert result["trace (5%)"]
+    assert result["eigen (5%)"]
+
+
+def test_cointegration_johansen_test_10pct_at_least_as_liberal_as_5pct():
+    """If a series passes at 5% it must also pass at the looser 10% threshold."""
+    result = johansen_test(make_cointegrated())
+    if result["trace (5%)"]:
+        assert result["trace (10%)"]
+    if result["eigen (5%)"]:
+        assert result["eigen (10%)"]
+
+
+def test_cointegration_johansen_stats_fast_cointegrated_passes():
+    """Clearly cointegrated series must pass all four thresholds."""
+    # rng = np.random.default_rng(1)
+    df = make_cointegrated(n=2000, noise_scale=0.001)
+    res_jo = coint_johansen(df, 0, 1)
+    trace_5, trace_10, eigen_5, eigen_10 = check_johansen_stats_fast(res_jo)
+    assert trace_10, "trace test at 10% should pass for a clearly cointegrated pair"
+    assert eigen_10, "eigen test at 10% should pass for a clearly cointegrated pair"
+
+
+def test_cointegration_johansen_stats_fast_consistent_with_johansen_test():
+    """check_johansen_stats_fast results must agree with the flags in johansen_test."""
+    df = make_cointegrated()
+    high_level = johansen_test(df)
+
+    res_jo = coint_johansen(df, 0, 1)
+    trace_5, trace_10, eigen_5, eigen_10 = check_johansen_stats_fast(res_jo)
+
+    assert high_level["trace (5%)"]  == trace_5
+    assert high_level["trace (10%)"] == trace_10
+    assert high_level["eigen (5%)"]  == eigen_5
+    assert high_level["eigen (10%)"] == eigen_10

{sdevpy-1.0.8 → sdevpy-1.0.9}/sdevpy/tests/test_impliedvol.py

@@ -1,4 +1,5 @@
 import numpy as np
+from scipy.integrate import quad
 from sdevpy.utilities.tools import isequal
 from sdevpy.volatility.impliedvol.models import svi, biexp, cubicvol, vsvi, gsvi
 from sdevpy.volatility.impliedvol.impliedvol_calib import TsIvObjectiveBuilder
@@ -8,17 +9,44 @@ from sdevpy.volatility.impliedvol.models.logmix import LogMix
 from sdevpy.volatility.impliedvol.models import sabr
 
 
-def test_sabr():
-    # Test near ATM
-    expiry = 0.5
+# n_mix=1, flat vol term structure: beta=1, a=b=0.2, c=0, d=1 → stdev(t=1)=0.2
+_LOGMIX_PARAMS_1 = [1.0, 0.2, 0.2, 0.0, 1.0]
+
+
+def make_logmix1():
+    """ Quick LogMix maker """
+    m = LogMix(n_mix=1)
+    m.update_params(_LOGMIX_PARAMS_1)
+    return m
+
+
+def test_logmix_pdf():
+    model = make_logmix1()
+    expiry = 1.0
     fwd = 0.04
-    params = {'LnVol': 0.25, 'Beta': 0.4, 'Nu': 0.50, 'Rho': -0.25}
-    strikes = np.asarray([0.01, 0.04, 0.06])
-    test = sabr.sabr_from_dict(expiry, strikes, fwd, params)
-    ref = np.asarray([0.54225604, 0.25208659, 0.22711695])
+    strikes = np.asarray([0.03, 0.04, 0.05])
+    test = model.pdf(expiry, strikes, fwd)
+    ref = np.asarray([27.15024656, 49.61906844, 19.05342396])
     assert np.allclose(test, ref, 1e-10)
 
 
+def test_logmix_pdf_integrates_to_one():
+    """Integral of pdf over (0, ∞) must be ≈ 1."""
+    model = make_logmix1()
+    integral, _ = quad(lambda k: model.pdf(1.0, k, 1.0), 0.2, 6.0)
+    assert abs(integral - 1.0) < 1e-8
+
+
+def test_logmix_cdf_consistent_with_pdf():
+    """CDF(b) - CDF(a) must equal ∫_a^b pdf(k) dk"""
+    model = make_logmix1()
+    t, fwd, a, b = 1.0, 1.0, 0.8, 1.2
+
+    cdf_diff = model.cdf(t, b, fwd) - model.cdf(t, a, fwd)
+    integral, _ = quad(lambda k: model.pdf(t, k, fwd), a, b)
+    assert abs(cdf_diff - integral) < 1e-5
+
+
 def test_logmix_objective():
     surface = LogMix(2)
     t = np.asarray([0.5, 1.5, 2.5])
@@ -161,8 +189,21 @@ def test_gsvi_formula():
     assert np.allclose(test, ref, 1e-10)
 
 
+def test_sabr():
+    # Test near ATM
+    expiry = 0.5
+    fwd = 0.04
+    params = {'LnVol': 0.25, 'Beta': 0.4, 'Nu': 0.50, 'Rho': -0.25}
+    strikes = np.asarray([0.01, 0.04, 0.06])
+    test = sabr.sabr_from_dict(expiry, strikes, fwd, params)
+    ref = np.asarray([0.54225604, 0.25208659, 0.22711695])
+    assert np.allclose(test, ref, 1e-10)
+
+
 if __name__ == "__main__":
-    test_sabr()
+    test_logmix_pdf_integrates_to_one()
+    # test_logmix_pdf()
+    # test_sabr()
     # test_tssvi1_objective()
     # test_tssvi1()
     # test_svi_formula()

sdevpy-1.0.9/sdevpy/tests/test_localvol.py

@@ -0,0 +1,318 @@
+import numpy as np
+import numpy.typing as npt
+from sdevpy.volatility.localvol.localvol import InterpolatedParamLocalVol, MatrixLocalVol
+from sdevpy.volatility.impliedvol.models.svi import SviSection
+from sdevpy.volatility.localvol.dupire import dupire_formula
+from sdevpy.volatility.impliedvol.models.tssvi1 import TsSvi1
+from sdevpy.volatility.impliedvol.models.tssvi2 import TsSvi2
+from sdevpy.volatility.impliedvol.models.logmix import LogMix
+from sdevpy.volatility.localvol.localvol_calib import LvObjectiveBuilder
+from sdevpy.pde import forwardpde as fpde
+from sdevpy.analytics import black
+
+
+############### TEST HELPERS ######################################################################
+VALID_PARAMS = np.array([0.04, 0.1, 0.0, 0.0, 0.2])  # a, b, rho, m, sigma
+T_GRID    = np.array([0.25, 0.5, 1.0, 2.0])
+LOGM_GRID = np.array([-0.25, -0.2, 0.0, 0.2, 0.25])
+FLAT_VOL = 0.20
+
+# v0, vinf, b_, tau, alpha, beta, r, x0star, lambda0, gamma, delta
+FLAT_TSSVI1_PARAMS = [FLAT_VOL, FLAT_VOL, 0.0, 1.0, 0.0, 0.5, 0.0, 0.0, 0.1, 1.0, 1.0]
+
+_T_GRID  = np.array([0.5, 1.0])
+FWD     = 100.0
+FWDS    = [FWD, FWD]
+STRIKES = [np.array([90.0, 100.0, 110.0]),
+           np.array([90.0, 100.0, 110.0])]
+# REF_VOL = 0.20
+
+# a=0.04, b=0.001>0, rho=0, m=0, sigma=0.1>0 — all svi_check_params constraints satisfied
+VALID_SVI   = np.array([0.04, 0.001, 0.0, 0.0, 0.10])
+# b < 0 — fails svi_check_params immediately
+INVALID_SVI = np.array([0.04, -0.10, 0.0, 0.0, 0.10])
+
+def make_lv_by_sections(t_grid: list[float]=None, params: npt.ArrayLike=None):
+    if t_grid is None:
+        t_grid = [0.25, 0.5, 1.0, 2.0]
+    if params is None:
+        params = VALID_PARAMS
+    sections = [SviSection(t) for t in t_grid]
+    lv = InterpolatedParamLocalVol(sections)
+    for i in range(len(t_grid)):
+        lv.update_params(i, params)
+    return lv
+
+def make_vol_matrix(t_grid=T_GRID, logm_grid=LOGM_GRID):
+    """ Bilinear test surface: vol = 0.20 + 0.02*t - 0.05*logm.
+        Linear interpolation reproduces this exactly at any interior point. """
+    t, lm = np.meshgrid(t_grid, logm_grid, indexing='ij')
+    return lv_func_def(t, lm) # 0.20 + 0.02 * t - 0.05 * lm
+
+def lv_func_def(t, lm):
+    return 0.20 + 0.02 * t - 0.05 * lm
+
+def make_mlv(**kwargs):
+    """ Make MatrixLocalVol """
+    return MatrixLocalVol(T_GRID, LOGM_GRID, make_vol_matrix(), **kwargs)
+
+def make_flat_surface():
+    s = TsSvi1()
+    s.update_params(FLAT_TSSVI1_PARAMS)
+    return s
+
+def make_tssvi1():
+    s = TsSvi1()
+    s.update_params(s.initial_point())
+    return s
+
+def make_tssvi2():
+    s = TsSvi2()
+    s.update_params(s.initial_point())
+    return s
+
+def make_logmix2():
+    s = LogMix(n_mix=2)
+    s.update_params(s.initial_point())
+    return s
+
+def make_iplv(params=VALID_SVI):
+    """ Make InterpolatedParamLocalVol """
+    sections = [SviSection(t) for t in _T_GRID]
+    lv = InterpolatedParamLocalVol(sections)
+    for i in range(len(_T_GRID)):
+        lv.update_params(i, params)
+    return lv
+
+def make_prices():
+    return [black.price(exp, STRIKES[i], True, FWD, FLAT_VOL)
+            for i, exp in enumerate(_T_GRID)]
+
+def make_pde_config():
+    return fpde.PdeConfig(n_timesteps=5, n_meshes=30, mesh_vol=FLAT_VOL,
+                          scheme='rannacher', rescale_x=True, rescale_p=True)
+
+def make_builder():
+    return LvObjectiveBuilder(make_iplv(), FWDS, STRIKES, make_prices(), make_pde_config())
+
+
+##################### LV calib by sections ########################################################
+def test_lv_bysections_builder_initialize_density_integrates_to_one():
+    """ Initial lognormal density on the log-spot grid must integrate to ≈ 1 """
+    builder = make_builder()
+    old_x, _, old_p = builder.initialize()
+    assert abs(np.trapezoid(old_p, old_x) - 1.0) < 0.00001
+
+
+def test_lv_bysections_builder_set_expiry_updates_slice_state():
+    builder = make_builder()
+    old_x, old_dx, old_p = builder.initialize()
+    builder.set_expiry(0, old_x, old_dx, old_p)
+
+    assert builder.exp_idx == 0
+    assert builder.fwd == FWDS[0]
+    assert np.allclose(builder.strikes, STRIKES[0])
+    assert np.allclose(builder.cf_prices, make_prices()[0])
+
+
+def test_lv_bysections_builder_objective_feasible_params_returns_finite_nonneg():
+    """ Feasible params must produce a finite, non-negative RMSE """
+    builder = make_builder()
+    old_x, old_dx, old_p = builder.initialize()
+    builder.set_expiry(0, old_x, old_dx, old_p)
+
+    result = builder.objective(VALID_SVI)
+
+    assert np.isfinite(result)
+    assert result >= 0.0
+
+
+def test_lv_bysections_builder_calculate_vols_has_correct_length_and_positive_values():
+    """ calculate_vols() must return one positive vol per strike """
+    builder = make_builder()
+    old_x, old_dx, old_p = builder.initialize()
+    builder.set_expiry(0, old_x, old_dx, old_p)
+    builder.objective(VALID_SVI) # Populates pde_prices
+
+    vols = builder.calculate_vols()
+
+    assert len(vols) == len(STRIKES[0])
+    assert all(v > 0.0 for v in vols)
+
+
+##################### Dupire formula ##############################################################
+def test_dupire_impliedvol():
+    """ Check Dupire formula by implied vol method """
+    x = np.asarray([0.9, 1.0, 1.1])
+    test = dupire_formula(make_tssvi1(), ts=0.25, te=1.0, x=x)
+    ref = np.asarray([0.36949807, 0.2413907, 0.20621366])
+    assert np.allclose(test, ref, 1e-10)
+
+
+def test_dupire_pdf():
+    """ Check Dupire formula by PDF method """
+    x = np.asarray([0.9, 1.0, 1.1])
+    test = dupire_formula(make_logmix2(), ts=0.25, te=1.0, x=x)
+    ref = np.asarray([0.20000181, 0.20001192, 0.1999994])
+    assert np.allclose(test, ref, 1e-10)
+
+
+def test_dupire_output_shape():
+    """ Output array shape must match input x shape """
+    x = np.asarray([0.8, 0.9, 1.0, 1.1, 1.2])
+    lv = dupire_formula(make_tssvi2(), ts=0.25, te=1.0, x=x)
+    assert lv.shape == x.shape
+
+
+def test_dupire_scalar_input():
+    """ Scalar x must return a scalar (0-d array) """
+    lv = dupire_formula(make_tssvi2(), ts=0.25, te=1.0, x=1.0)
+    assert np.ndim(lv) == 0
+
+
+def test_dupire_ts_near_zero_returns_spot_vol():
+    """ When ts < t_threshold the formula falls back to black_volatility(te, x) """
+    surface = make_tssvi2()
+    x = np.asarray([0.9, 1.0, 1.1])
+    lv = dupire_formula(surface, ts=0.0, te=1.0, x=x)
+    expected = surface.black_volatility(t=1.0, k=x, f=1.0)
+    assert np.allclose(lv, expected)
+
+
+def test_dupire_flat_surface_recovers_constant_vol():
+    """ On a flat vol surface (no skew, flat term structure) Dupire LV = IV """
+    x = np.asarray([0.8, 0.9, 1.0, 1.1, 1.2])
+    lv = dupire_formula(make_flat_surface(), ts=0.5, te=1.0, x=x)
+    assert np.allclose(lv, FLAT_VOL, atol=1e-6)
+
+
+##################### LV by matrix interpolation ##################################################
+def test_lv_bymatrix_pchip_def():
+    lv = MatrixLocalVol(T_GRID, LOGM_GRID, make_vol_matrix(), interpolation='pchip')
+    assert lv.method == 'pchip'
+    lv2 = MatrixLocalVol(T_GRID, LOGM_GRID, make_vol_matrix(), interpolation='cubic')
+    assert lv2.method == 'cubic'
+
+
+def test_lv_bymatrix_value_on_grid_nodes():
+    """ Values at grid nodes must exactly reproduce the input matrix. """
+    lv = make_mlv()
+    vol_matrix = make_vol_matrix()
+    for i, t in enumerate(T_GRID):
+        for j, lm in enumerate(LOGM_GRID):
+            assert np.isclose(lv.value(t, lm), vol_matrix[i, j])
+
+
+def test_lv_bymatrix_value_interior_bilinear_exact():
+    """ Linear interpolation on a bilinear surface is exact at any interior point. """
+    lv = make_mlv()
+    t, lm = 0.75, 0.1
+    # expected = 0.20 + 0.02 * t - 0.05 * lm
+    expected = lv_func_def(t, lm)
+    assert np.isclose(lv.value(t, lm), expected, atol=1e-12)
+
+
+def test_lv_bymatrix_extrap_below_t():
+    """ t below grid must return the same value as t_grid[0]. """
+    lv = make_mlv()
+    assert np.isclose(lv.value(0.0, 0.0), lv.value(T_GRID[0], 0.0))
+
+
+def test_lv_bymatrix_extrap_above_t():
+    """ t above grid must return the same value as t_grid[-1]. """
+    lv = make_mlv()
+    assert np.isclose(lv.value(100.0, 0.0), lv.value(T_GRID[-1], 0.0))
+
+
+def test_lv_bymatrix_extrap_below_logm():
+    """ logm below grid must return the same value as logm_grid[0]. """
+    lv = make_mlv()
+    assert np.isclose(lv.value(1.0, -10.0), lv.value(1.0, LOGM_GRID[0]))
+
+
+def test_lv_bymatrix_extrap_above_logm():
+    """ logm above grid must return the same value as logm_grid[-1]. """
+    lv = make_mlv()
+    assert np.isclose(lv.value(1.0, 10.0), lv.value(1.0, LOGM_GRID[-1]))
+
+
+def test_lv_bymatrix_flat_surface_everywhere():
+    """ A flat vol surface must return the same value at all (t, logm), including outside the grid. """
+    lv = MatrixLocalVol(T_GRID, LOGM_GRID, np.full((4, 5), 0.25))
+    for t in [0.0, 0.5, 1.5, 5.0]:
+        for lm in [-1.0, 0.0, 1.0]:
+            assert np.isclose(lv.value(t, lm), 0.25)
+
+
+def test_lv_bymatrix_section_consistent_with_value():
+    """ section(t)(logm) must equal value(t, logm) for any logm. """
+    lv = make_mlv()
+    t = 0.75
+    logm = np.array([-0.15, 0.0, 0.15])
+    assert np.allclose(lv.section(t)(logm), lv.value(t, logm))
+
+
+##################### LV by sections ##############################################################
+def test_lv_sections_sorted_by_time():
+    """ Sections passed in reverse order should be stored sorted by time """
+    sections = [SviSection(t) for t in [2.0, 0.5, 1.0]]
+    lv = InterpolatedParamLocalVol(sections)
+    times = [s.time for s in lv.sections]
+    assert times == sorted(times)
+
+
+def test_lv_t_grid_matches_sections():
+    """ LV's time grid matches sections' """
+    sections = [SviSection(t) for t in [3.0, 1.0, 0.5]]
+    lv = InterpolatedParamLocalVol(sections)
+    assert lv.t_grid == [0.5, 1.0, 3.0]
+
+
+def test_lv_by_section_values():
+    """Between pillars, value() must delegate to the upper (right) section."""
+    t_grid = [0.5, 1.0, 2.0]
+    params_mid  = np.array([0.04, 0.1, 0.0, 0.0, 0.2])
+    params_high = np.array([0.09, 0.2, 0.0, 0.0, 0.3])
+    sections = [SviSection(t) for t in t_grid]
+    lv = InterpolatedParamLocalVol(sections)
+    lv.update_params(0, params_mid)
+    lv.update_params(1, params_high)
+    lv.update_params(2, params_mid)
+
+    logm = [-0.5, 0.0, 0.5]
+    test = lv.value(0.75, logm)
+    # print(test)
+    ref = np.asarray([0.52487337, 0.4472136,  0.52487337,])
+    assert np.allclose(test, ref, 1e-10)
+
+
+def test_lv_sections_return_time():
+    lv = make_lv_by_sections(t_grid=[0.5, 1.0])
+    assert lv.section(0).time == 0.5
+    assert lv.section(1).time == 1.0
+
+
+def test_lv_update_params_do_not_mutate():
+    """ Mutating the source array after update_params must not change stored params """
+    lv = make_lv_by_sections(t_grid=[1.0])
+    p = np.array([0.04, 0.1, 0.0, 0.0, 0.2])
+    lv.update_params(0, p)
+    p[0] = 999.0
+    assert lv.params(0)[0] != 999.0
+
+
+def test_lv_check_params():
+    lv = make_lv_by_sections()
+    is_ok, penalty = lv.check_params(0)
+    assert is_ok
+    assert penalty == 0.0
+
+
+def test_lv_bysections_dump_data_keys():
+    data = make_lv_by_sections().dump_data()
+    assert set(data.keys()) == {'name', 'valdate', 'snapdate', 'sections'}
+
+
+if __name__ == "__main__":
+    test_dupire_impliedvol()
+    test_dupire_pdf()