feat: add BackwardflatLinear and FlatExtrapolator2D interpolation bindings

Author: quantales

docs/api/math.md

@@ -318,6 +318,29 @@ y = [0.01, 0.015, 0.02, 0.025, 0.03, 0.035]
 interp = ql.ConvexMonotoneInterpolation(x, y, quadraticity=0.3, monotonicity=0.7)
 ```
 
+### BackwardflatLinearInterpolation
+
+```{eval-rst}
+.. autoclass:: pyquantlib.BackwardflatLinearInterpolation
+```
+
+2-D interpolation: backward-flat in the first component, linear in the second.
+
+### FlatExtrapolator2D
+
+```{eval-rst}
+.. autoclass:: pyquantlib.FlatExtrapolator2D
+```
+
+Decorator that adds flat extrapolation outside the range of any 2-D interpolation.
+
+```python
+inner = ql.BilinearInterpolation(x, y, z)
+extrap = ql.FlatExtrapolator2D(inner)
+extrap.enableExtrapolation()
+extrap(0.0, 0.0)  # clamps to boundary value
+```
+
 ### ForwardFlatInterpolation
 
 ```{eval-rst}

docs/changelog.md

@@ -23,6 +23,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `LogMixedLinearCubicNaturalSpline` convenience class
 - `SABRInterpolation` SABR smile interpolation with calibration (alpha, beta, nu, rho accessors, RMS/max error, end criteria)
 - `ConvexMonotoneInterpolation` convex monotone yield-curve interpolation (Hagan & West, 2006)
+- `BackwardflatLinearInterpolation` 2-D backward-flat/linear interpolation
+- `FlatExtrapolator2D` 2-D flat extrapolation decorator
 
 ## [0.7.0] - 2026-03-14
 

include/pyquantlib/pyquantlib.h

@@ -101,6 +101,8 @@ namespace ql_math {
     void loginterpolation(py::module_&);
     void sabrinterpolation(py::module_&);
     void convexmonotoneinterpolation(py::module_&);
+    void backwardflatlinearinterpolation(py::module_&);
+    void flatextrapolation2d(py::module_&);
     void normaldistribution(py::module_&);
     void bivariatenormaldistribution(py::module_&);
     void solvers1d(py::module_&);

pyquantlib/__init__.pyi

@@ -98,6 +98,8 @@ DECLARE_MODULE_BINDINGS(math_bindings) {
         "Forward-flat interpolation");
     ADD_MAIN_BINDING(ql_math::lagrangeinterpolation, "Lagrange interpolation");
     ADD_MAIN_BINDING(ql_math::bilinearinterpolation, "Bilinear interpolation");
+    ADD_MAIN_BINDING(ql_math::backwardflatlinearinterpolation, "Backward-flat linear 2D interpolation");
+    ADD_MAIN_BINDING(ql_math::flatextrapolation2d, "Flat extrapolation 2D");
     ADD_MAIN_BINDING(ql_math::bicubicsplineinterpolation,
         "Bicubic spline interpolation");
     ADD_MAIN_BINDING(ql_math::chebyshevinterpolation,

pyquantlib/_pyquantlib/__init__.pyi

@@ -0,0 +1,25 @@
+/*
+ * PyQuantLib: Python bindings for QuantLib
+ * https://github.com/quantales/pyquantlib
+ *
+ * Copyright (c) 2025 Yassine Idyiahia
+ * SPDX-License-Identifier: BSD-3-Clause
+ * See LICENSE for details.
+ *
+ * ---
+ * QuantLib is Copyright (c) 2000-2025 The QuantLib Authors
+ * https://www.quantlib.org/
+ */
+
+#include "pyquantlib/pyquantlib.h"
+#include "pyquantlib/interpolation_helper.h"
+#include <ql/math/interpolations/backwardflatlinearinterpolation.hpp>
+
+namespace py = pybind11;
+using namespace QuantLib;
+
+void ql_math::backwardflatlinearinterpolation(py::module_& m) {
+    pyquantlib::bind_simple_interpolation2d<BackwardflatLinearInterpolation>(
+        m, "BackwardflatLinearInterpolation",
+        "Backward-flat in first component, linear in second component.");
+}

src/math/all.cpp

@@ -0,0 +1,29 @@
+/*
+ * PyQuantLib: Python bindings for QuantLib
+ * https://github.com/quantales/pyquantlib
+ *
+ * Copyright (c) 2025 Yassine Idyiahia
+ * SPDX-License-Identifier: BSD-3-Clause
+ * See LICENSE for details.
+ *
+ * ---
+ * QuantLib is Copyright (c) 2000-2025 The QuantLib Authors
+ * https://www.quantlib.org/
+ */
+
+#include "pyquantlib/pyquantlib.h"
+#include <ql/math/interpolations/flatextrapolation2d.hpp>
+#include <pybind11/pybind11.h>
+
+namespace py = pybind11;
+using namespace QuantLib;
+
+void ql_math::flatextrapolation2d(py::module_& m) {
+    py::class_<FlatExtrapolator2D, Interpolation2D,
+               ext::shared_ptr<FlatExtrapolator2D>>(
+        m, "FlatExtrapolator2D",
+        "2-D flat extrapolation decorator.")
+        .def(py::init<const ext::shared_ptr<Interpolation2D>&>(),
+            py::arg("interpolation"),
+            "Constructs flat extrapolator wrapping a 2-D interpolation.");
+}

src/math/interpolations/backwardflatlinearinterpolation.cpp

@@ -639,3 +639,95 @@ def make():
     val = interp(2.0)
     assert math.isfinite(val)
     assert val > 0
+
+
+# ---------------------------------------------------------------------------
+# BackwardflatLinearInterpolation (2D)
+# ---------------------------------------------------------------------------
+
+def test_backwardflat_linear_2d_construction():
+    """BackwardflatLinearInterpolation constructs and evaluates."""
+    x = [1.0, 2.0, 3.0]
+    y = [10.0, 20.0, 30.0]
+    z = ql.Matrix(3, 3)
+    for i in range(3):
+        for j in range(3):
+            z[i][j] = (i + 1) * (j + 1) * 1.0
+    interp = ql.BackwardflatLinearInterpolation(x, y, z)
+    assert isinstance(interp, ql.base.Interpolation2D)
+
+
+def test_backwardflat_linear_2d_at_nodes():
+    """Backward-flat linear 2D hits node values."""
+    x = [1.0, 2.0, 3.0]
+    y = [10.0, 20.0]
+    z = ql.Matrix(2, 3)
+    z[0][0] = 1.0; z[0][1] = 2.0; z[0][2] = 3.0
+    z[1][0] = 4.0; z[1][1] = 5.0; z[1][2] = 6.0
+    interp = ql.BackwardflatLinearInterpolation(x, y, z)
+
+    assert interp(1.0, 10.0) == pytest.approx(1.0)
+    assert interp(2.0, 20.0) == pytest.approx(5.0)
+    assert interp(3.0, 20.0) == pytest.approx(6.0)
+
+
+def test_backwardflat_linear_2d_interpolation():
+    """Backward-flat in x, linear in y."""
+    x = [1.0, 2.0]
+    y = [0.0, 1.0]
+    z = ql.Matrix(2, 2)
+    z[0][0] = 10.0; z[0][1] = 20.0
+    z[1][0] = 30.0; z[1][1] = 40.0
+    interp = ql.BackwardflatLinearInterpolation(x, y, z)
+
+    # Linear in y at x=1.0
+    assert interp(1.0, 0.5) == pytest.approx(20.0)  # (10+30)/2
+
+    # Backward-flat in x: between 1 and 2, uses x=2 value
+    assert interp(1.5, 0.0) == pytest.approx(20.0)  # backflat -> z[0][1]
+
+
+# ---------------------------------------------------------------------------
+# FlatExtrapolator2D
+# ---------------------------------------------------------------------------
+
+def test_flat_extrapolator_2d_construction():
+    """FlatExtrapolator2D wraps a 2D interpolation."""
+    x = [1.0, 2.0, 3.0]
+    y = [10.0, 20.0, 30.0]
+    z = ql.Matrix(3, 3)
+    for i in range(3):
+        for j in range(3):
+            z[i][j] = float(i + j)
+    inner = ql.BilinearInterpolation(x, y, z)
+    extrap = ql.FlatExtrapolator2D(inner)
+    assert isinstance(extrap, ql.base.Interpolation2D)
+
+
+def test_flat_extrapolator_2d_within_range():
+    """FlatExtrapolator2D passes through to inner interpolation within range."""
+    x = [1.0, 2.0, 3.0]
+    y = [10.0, 20.0]
+    z = ql.Matrix(2, 3)
+    z[0][0] = 1.0; z[0][1] = 2.0; z[0][2] = 3.0
+    z[1][0] = 4.0; z[1][1] = 5.0; z[1][2] = 6.0
+    inner = ql.BilinearInterpolation(x, y, z)
+    extrap = ql.FlatExtrapolator2D(inner)
+
+    assert extrap(2.0, 15.0) == pytest.approx(inner(2.0, 15.0))
+
+
+def test_flat_extrapolator_2d_outside_range():
+    """FlatExtrapolator2D clamps to boundary values outside range."""
+    x = [1.0, 2.0]
+    y = [10.0, 20.0]
+    z = ql.Matrix(2, 2)
+    z[0][0] = 1.0; z[0][1] = 2.0
+    z[1][0] = 3.0; z[1][1] = 4.0
+    inner = ql.BilinearInterpolation(x, y, z)
+    extrap = ql.FlatExtrapolator2D(inner)
+    extrap.enableExtrapolation()
+
+    # Outside x range: clamps to boundary
+    assert extrap(0.0, 10.0) == pytest.approx(extrap(1.0, 10.0))
+    assert extrap(5.0, 20.0) == pytest.approx(extrap(2.0, 20.0))