From 490046dd6bee7f37afa9fca29e1b486bc5695b36 Mon Sep 17 00:00:00 2001
From: paolodelia99 <paolo.delia99@gmail.com>
Date: Sun, 12 Oct 2025 22:07:03 +0200
Subject: [PATCH 01/11] Added first fx vol utils classes from ORE

---
 QuantLib.vcxproj                              |   4 +
 QuantLib.vcxproj.filters                      |  12 +
 ql/CMakeLists.txt                             |   4 +
 .../volatility/equityfx/Makefile.am           |   4 +
 .../equityfx/blackvariancecurve.cpp           |  18 +-
 .../equityfx/blackvariancecurve.hpp           |   4 +-
 .../blackvariancetimeextrapolation.hpp        | 101 ++++++++
 .../equityfx/blackvolsurfacedelta.cpp         | 238 ++++++++++++++++++
 .../equityfx/blackvolsurfacedelta.hpp         | 177 +++++++++++++
 .../equityfx/blackvoltermstructure.hpp        |   6 +
 .../volatility/equityfx/fxsmilesection.hpp    |  55 ++++
 test-suite/CMakeLists.txt                     |   1 +
 test-suite/Makefile.am                        |   1 +
 test-suite/blackvolsurfacedelta.cpp           | 102 ++++++++
 test-suite/testsuite.vcxproj                  |   1 +
 test-suite/testsuite.vcxproj.filters          |   3 +
 16 files changed, 724 insertions(+), 7 deletions(-)
 create mode 100644 ql/termstructures/volatility/equityfx/blackvariancetimeextrapolation.hpp
 create mode 100644 ql/termstructures/volatility/equityfx/blackvolsurfacedelta.cpp
 create mode 100644 ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp
 create mode 100644 ql/termstructures/volatility/equityfx/fxsmilesection.hpp
 create mode 100644 test-suite/blackvolsurfacedelta.cpp

diff --git a/QuantLib.vcxproj b/QuantLib.vcxproj
index 366c4417e73..3e9f2eb8c5a 100644
--- a/QuantLib.vcxproj
+++ b/QuantLib.vcxproj
@@ -1727,8 +1727,11 @@
     <ClInclude Include="ql\termstructures\volatility\equityfx\blackconstantvol.hpp" />
     <ClInclude Include="ql\termstructures\volatility\equityfx\blackvariancecurve.hpp" />
     <ClInclude Include="ql\termstructures\volatility\equityfx\blackvariancesurface.hpp" />
+    <ClInclude Include="ql\termstructures\volatility\equityfx\blackvariancetimeextrapolation.hpp" />
+    <ClInclude Include="ql\termstructures\volatility\equityfx\blackvolsurfacedelta.hpp" />
     <ClInclude Include="ql\termstructures\volatility\equityfx\blackvoltermstructure.hpp" />
     <ClInclude Include="ql\termstructures\volatility\equityfx\fixedlocalvolsurface.hpp" />
+    <ClInclude Include="ql\termstructures\volatility\equityfx\fxsmilesection.hpp" />
     <ClInclude Include="ql\termstructures\volatility\equityfx\gridmodellocalvolsurface.hpp" />
     <ClInclude Include="ql\termstructures\volatility\equityfx\hestonblackvolsurface.hpp" />
     <ClInclude Include="ql\termstructures\volatility\equityfx\impliedvoltermstructure.hpp" />
@@ -2753,6 +2756,7 @@
     <ClCompile Include="ql\termstructures\volatility\equityfx\andreasenhugevolatilityinterpl.cpp" />
     <ClCompile Include="ql\termstructures\volatility\equityfx\blackvariancecurve.cpp" />
     <ClCompile Include="ql\termstructures\volatility\equityfx\blackvariancesurface.cpp" />
+    <ClCompile Include="ql\termstructures\volatility\equityfx\blackvolsurfacedelta.cpp" />
     <ClCompile Include="ql\termstructures\volatility\equityfx\blackvoltermstructure.cpp" />
     <ClCompile Include="ql\termstructures\volatility\equityfx\fixedlocalvolsurface.cpp" />
     <ClCompile Include="ql\termstructures\volatility\equityfx\gridmodellocalvolsurface.cpp" />
diff --git a/QuantLib.vcxproj.filters b/QuantLib.vcxproj.filters
index 5214b5342da..74839fb564f 100644
--- a/QuantLib.vcxproj.filters
+++ b/QuantLib.vcxproj.filters
@@ -2049,6 +2049,12 @@
     <ClInclude Include="ql\termstructures\volatility\equityfx\blackvariancesurface.hpp">
       <Filter>termstructures\volatility\equityfx</Filter>
     </ClInclude>
+    <ClInclude Include="ql\termstructures\volatility\equityfx\blackvariancetimeextrapolation.hpp">
+      <Filter>termstructures\volatility\equityfx</Filter>
+    </ClInclude>
+    <ClInclude Include="ql\termstructures\volatility\equityfx\blackvolsurfacedelta.hpp">
+      <Filter>termstructures\volatility\equityfx</Filter>
+    </ClInclude>
     <ClInclude Include="ql\termstructures\volatility\equityfx\blackvoltermstructure.hpp">
       <Filter>termstructures\volatility\equityfx</Filter>
     </ClInclude>
@@ -4245,6 +4251,9 @@
     <ClInclude Include="ql\termstructures\volatility\equityfx\fixedlocalvolsurface.hpp">
       <Filter>termstructures\volatility\equityfx</Filter>
     </ClInclude>
+    <ClInclude Include="ql\termstructures\volatility\equityfx\fxsmilesection.hpp">
+      <Filter>termstructures\volatility\equityfx</Filter>
+    </ClInclude>
     <ClInclude Include="ql\methods\finitedifferences\operators\fdmlocalvolfwdop.hpp">
       <Filter>methods\finitedifferences\operators</Filter>
     </ClInclude>
@@ -5600,6 +5609,9 @@
     <ClCompile Include="ql\termstructures\volatility\equityfx\blackvariancesurface.cpp">
       <Filter>termstructures\volatility\equityfx</Filter>
     </ClCompile>
+    <ClCompile Include="ql\termstructures\volatility\equityfx\blackvolsurfacedelta.cpp">
+      <Filter>termstructures\volatility\equityfx</Filter>
+    </ClCompile>
     <ClCompile Include="ql\termstructures\volatility\equityfx\blackvoltermstructure.cpp">
       <Filter>termstructures\volatility\equityfx</Filter>
     </ClCompile>
diff --git a/ql/CMakeLists.txt b/ql/CMakeLists.txt
index fd644d1f506..469a6d351bb 100644
--- a/ql/CMakeLists.txt
+++ b/ql/CMakeLists.txt
@@ -835,6 +835,7 @@ set(QL_SOURCES
     termstructures/volatility/equityfx/andreasenhugevolatilityinterpl.cpp
     termstructures/volatility/equityfx/blackvariancecurve.cpp
     termstructures/volatility/equityfx/blackvariancesurface.cpp
+    termstructures/volatility/equityfx/blackvolsurfacedelta.cpp
     termstructures/volatility/equityfx/blackvoltermstructure.cpp
     termstructures/volatility/equityfx/fixedlocalvolsurface.cpp
     termstructures/volatility/equityfx/gridmodellocalvolsurface.cpp
@@ -2103,8 +2104,11 @@ set(QL_HEADERS
     termstructures/volatility/equityfx/blackconstantvol.hpp
     termstructures/volatility/equityfx/blackvariancecurve.hpp
     termstructures/volatility/equityfx/blackvariancesurface.hpp
+    termstructures/volatility/equityfx/blackvariancetimeextrapolation.hpp
+    termstructures/volatility/equityfx/blackvolsurfacedelta.hpp
     termstructures/volatility/equityfx/blackvoltermstructure.hpp
     termstructures/volatility/equityfx/fixedlocalvolsurface.hpp
+    termstructures/volatility/equityfx/fxsmilesection.hpp
     termstructures/volatility/equityfx/gridmodellocalvolsurface.hpp
     termstructures/volatility/equityfx/hestonblackvolsurface.hpp
     termstructures/volatility/equityfx/impliedvoltermstructure.hpp
diff --git a/ql/termstructures/volatility/equityfx/Makefile.am b/ql/termstructures/volatility/equityfx/Makefile.am
index 38dbbf31eb6..997f501732f 100644
--- a/ql/termstructures/volatility/equityfx/Makefile.am
+++ b/ql/termstructures/volatility/equityfx/Makefile.am
@@ -10,8 +10,11 @@ this_include_HEADERS = \
     blackconstantvol.hpp \
     blackvariancecurve.hpp \
     blackvariancesurface.hpp \
+    blackvariancetimeextrapolation.hpp \
+    blackvolsurfacedelta.hpp \
     blackvoltermstructure.hpp \
     fixedlocalvolsurface.hpp \
+    fxsmilesection.hpp \
     gridmodellocalvolsurface.hpp \
     hestonblackvolsurface.hpp \
     impliedvoltermstructure.hpp \
@@ -27,6 +30,7 @@ cpp_files = \
     andreasenhugevolatilityadapter.cpp \
     blackvariancecurve.cpp \
     blackvariancesurface.cpp \
+    blackvolsurfacedelta.cpp \
     blackvoltermstructure.cpp \
     fixedlocalvolsurface.cpp \
     gridmodellocalvolsurface.cpp \
diff --git a/ql/termstructures/volatility/equityfx/blackvariancecurve.cpp b/ql/termstructures/volatility/equityfx/blackvariancecurve.cpp
index 2a2a6847057..0047ab512e3 100644
--- a/ql/termstructures/volatility/equityfx/blackvariancecurve.cpp
+++ b/ql/termstructures/volatility/equityfx/blackvariancecurve.cpp
@@ -20,6 +20,7 @@
 
 #include <ql/math/interpolations/linearinterpolation.hpp>
 #include <ql/termstructures/volatility/equityfx/blackvariancecurve.hpp>
+#include <ql/termstructures/volatility/equityfx/blackvariancetimeextrapolation.hpp>
 #include <utility>
 
 namespace QuantLib {
@@ -28,9 +29,10 @@ namespace QuantLib {
                                            const std::vector<Date>& dates,
                                            const std::vector<Volatility>& blackVolCurve,
                                            DayCounter dayCounter,
-                                           bool forceMonotoneVariance)
+                                           bool forceMonotoneVariance,
+                                           BlackVolTimeExtrapolation timeExtrapolation)
     : BlackVarianceTermStructure(referenceDate), dayCounter_(std::move(dayCounter)),
-      maxDate_(dates.back()) {
+      maxDate_(dates.back()), timeExtrapolation_(timeExtrapolation) {
 
         QL_REQUIRE(dates.size()==blackVolCurve.size(),
                    "mismatch between date vector and black vol vector");
@@ -62,11 +64,15 @@ namespace QuantLib {
     }
 
     Real BlackVarianceCurve::blackVarianceImpl(Time t, Real) const {
-        if (t<=times_.back()) {
-            return varianceCurve_(t, true);
-        } else {
+        if (t <= times_.back() || timeExtrapolation_ == BlackVolTimeExtrapolation::UseInterpolatorVariance) {
+            return std::max(varianceCurve_(t, true), 0.0);
+        } else if (timeExtrapolation_ == BlackVolTimeExtrapolation::FlatVolatility) {
             // extrapolate with flat vol
-            return varianceCurve_(times_.back(), true)*t/times_.back();
+            return timeExtrapolatationBlackVarianceFlat(t, times_, varianceCurve_);
+        } else if (timeExtrapolation_ == BlackVolTimeExtrapolation::UseInterpolatorVolatility) {
+            return timeExtrapolatationBlackVarianceInVolatility(t, times_, varianceCurve_);
+        } else {
+            QL_FAIL("Unknown time extrapolation method");
         }
     }
 
diff --git a/ql/termstructures/volatility/equityfx/blackvariancecurve.hpp b/ql/termstructures/volatility/equityfx/blackvariancecurve.hpp
index cc34f71c79a..8b2dbf0e02a 100644
--- a/ql/termstructures/volatility/equityfx/blackvariancecurve.hpp
+++ b/ql/termstructures/volatility/equityfx/blackvariancecurve.hpp
@@ -50,7 +50,8 @@ namespace QuantLib {
                            const std::vector<Date>& dates,
                            const std::vector<Volatility>& blackVolCurve,
                            DayCounter dayCounter,
-                           bool forceMonotoneVariance = true);
+                           bool forceMonotoneVariance = true,
+                           BlackVolTimeExtrapolation timeExtrapolation = BlackVolTimeExtrapolation::FlatVolatility);
         //! \name TermStructure interface
         //@{
         DayCounter dayCounter() const override { return dayCounter_; }
@@ -84,6 +85,7 @@ namespace QuantLib {
         std::vector<Time> times_;
         std::vector<Real> variances_;
         Interpolation varianceCurve_;
+        BlackVolTimeExtrapolation timeExtrapolation_;
     };
 
 
diff --git a/ql/termstructures/volatility/equityfx/blackvariancetimeextrapolation.hpp b/ql/termstructures/volatility/equityfx/blackvariancetimeextrapolation.hpp
new file mode 100644
index 00000000000..dff4066db04
--- /dev/null
+++ b/ql/termstructures/volatility/equityfx/blackvariancetimeextrapolation.hpp
@@ -0,0 +1,101 @@
+/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*
+ Copyright (C) 2025 AcadiaSoft Inc.
+
+ This file is part of QuantLib, a free-software/open-source library
+ for financial quantitative analysts and developers - http://quantlib.org/
+
+ QuantLib is free software: you can redistribute it and/or modify it
+ under the terms of the QuantLib license.  You should have received a
+ copy of the license along with this program; if not, please email
+ <quantlib-dev@lists.sf.net>. The license is also available online at
+ <http://quantlib.org/license.shtml>.
+
+ This program is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ FOR A PARTICULAR PURPOSE.  See the license for more details.
+*/
+
+/*! \file blackvariancetimeextrapolation.hpp
+    \brief Utility function for time extrapolation in Black volatility in black variance term structures
+*/
+#pragma once
+
+#include <functional>
+#include <ql/math/comparison.hpp>
+#include <ql/math/interpolation.hpp>
+#include <ql/math/interpolations/interpolation2d.hpp>
+#include <ql/math/interpolations/linearinterpolation.hpp>
+
+namespace QuantLib {
+
+    namespace {
+        Real linearExtrapolation(const double t, const std::array<double, 2>& times, const std::array<double, 2>& variances);
+
+        inline Real linearExtrapolation(const double t, const std::array<double, 2>& times,
+                                        const std::array<double, 2>& variances) {
+            QL_REQUIRE(t > times[1], "t must be greater than times[1]");
+            QL_REQUIRE(times[1] > times[0], "times must be sorted");
+            QL_REQUIRE(variances[1] >= variances[0], "variances must be non-decreasing");
+            std::array<double, 2> vols;
+            vols[0] = close_enough(times[0], 0.0) ? 0.0 : std::sqrt(variances[0] / times[0]);
+            vols[1] = close_enough(times[1], 0.0) ? 0.0 : std::sqrt(variances[1] / times[1]);
+            LinearInterpolation interpolation(times.begin(), times.end(), vols.begin());
+            return std::max(interpolation(t, true), 0.0);
+        }
+    } // namespace
+
+
+
+    //! Extrapolate black variance using flat vol extrapolation in time direction
+    Real timeExtrapolatationBlackVarianceFlat(const Time t, const std::vector<double>& times,
+        const Interpolation& varianceCurve);
+
+    //! Extrapolate black variance using flat vol extrapolation in time direction
+    template <typename F>
+    Real timeExtrapolatationBlackVarianceFlat(const Time t, const Real strike, const std::vector<double>& times,
+                                            const F& varianceSurface) {
+        return std::max(varianceSurface(times.back(), strike, true), 0.0) / times.back() * t;
+    }
+
+
+    //! Extrapolate black variance in vol space and time direction using interpolation
+    //! Takes black variances convert them to volatilities and then linearly extrapolates
+    //! the volatilities in time direction
+    Real timeExtrapolatationBlackVarianceInVolatility(const Time t, const std::vector<double>& times,
+        const Interpolation& varianceCurve);
+
+    //! Extrapolate black variance in vol space and time direction using interpolation
+    //! Takes black variances convert them to volatilities and then linearly extrapolates
+    //! the volatilities in time direction
+    template <typename F>
+    Real timeExtrapolatationBlackVarianceInVolatility(const Time t, const Real strike, const std::vector<double>& times,
+                                                    const F& varianceSurface) {
+        Size ind1 = times.size() - 2;
+        Size ind2 = times.size() - 1;
+        std::array<Real, 2> xs{times[ind1], times[ind2]};
+        std::array<Real, 2> variances;
+        variances[0] = varianceSurface(xs[0], strike, true);
+        variances[1] = varianceSurface(xs[1], strike, true);
+        Real v = linearExtrapolation(t, xs, variances);
+        return v * v * t;
+    }
+
+    inline Real timeExtrapolatationBlackVarianceFlat(const Time t, const std::vector<double>& times,
+                                                    const Interpolation& varianceCurve) {
+        return std::max(varianceCurve(times.back(), true), 0.0) / times.back() * t;
+    }
+
+    inline Real timeExtrapolatationBlackVarianceInVolatility(const Time t, const std::vector<double>& times,
+                                                            const Interpolation& varianceCurve) {
+        Size ind1 = times.size() - 2;
+        Size ind2 = times.size() - 1;
+        std::array<Real, 2> xs{times[ind1], times[ind2]};
+        std::array<Real, 2> variances;
+        variances[0] = varianceCurve(xs[0], true);
+        variances[1] = varianceCurve(xs[1], true);
+        Real v = linearExtrapolation(t, xs, variances);
+        return v * v * t;
+    }
+} // namespace QuantLib
\ No newline at end of file
diff --git a/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.cpp b/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.cpp
new file mode 100644
index 00000000000..47921a695fb
--- /dev/null
+++ b/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.cpp
@@ -0,0 +1,238 @@
+/*
+ Copyright (C) 2019 Quaternion Risk Management Ltd
+ Copyright (C) 2022 Skandinaviska Enskilda Banken AB (publ)
+ All rights reserved.
+
+ This file is part of ORE, a free-software/open-source library
+ for transparent pricing and risk analysis - http://opensourcerisk.org
+
+ ORE is free software: you can redistribute it and/or modify it
+ under the terms of the Modified BSD License.  You should have received a
+ copy of the license along with this program.
+ The license is also available online at <http://opensourcerisk.org>
+
+ This program is distributed on the basis that it will form a useful
+ contribution to risk analytics and model standardisation, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the license for more details.
+*/
+
+#include <ql/errors.hpp>
+#include <ql/experimental/fx/blackdeltacalculator.hpp>
+#include <ql/math/interpolations/cubicinterpolation.hpp>
+#include <ql/math/interpolations/linearinterpolation.hpp>
+#include <ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp>
+
+using namespace std;
+
+namespace QuantLib {
+
+    InterpolatedFxSmileSection::InterpolatedFxSmileSection(Real spot, Real rd, Real rf, Time t,
+                                                    const std::vector<Real>& strikes,
+                                                    const std::vector<Volatility>& vols, InterpolationMethod method,
+                                                    bool flatExtrapolation)
+        : FxSmileSection(spot, rd, rf, t), strikes_(strikes), vols_(vols), flatExtrapolation_(flatExtrapolation) {
+
+        if (method == InterpolationMethod::Linear)
+            interpolator_ = Linear().interpolate(strikes_.begin(), strikes_.end(), vols_.begin());
+        else if (method == InterpolationMethod::NaturalCubic)
+            interpolator_ =
+                Cubic(CubicInterpolation::Kruger, true).interpolate(strikes_.begin(), strikes_.end(), vols_.begin());
+        else if (method == InterpolationMethod::FinancialCubic)
+            interpolator_ = Cubic(CubicInterpolation::Kruger, true, CubicInterpolation::SecondDerivative, 0.0,
+                                CubicInterpolation::FirstDerivative)
+                                .interpolate(strikes_.begin(), strikes_.end(), vols_.begin());
+        else if (method == InterpolationMethod::CubicSpline)
+            interpolator_ = CubicNaturalSpline(strikes_.begin(), strikes_.end(), vols_.begin());
+        else {
+            QL_FAIL("Invalid method " << (int)method);
+        }
+    }
+
+    Volatility InterpolatedFxSmileSection::volatility(Real strike) const {
+        if (flatExtrapolation_) {
+            if (strike < strikes_.front())
+                return vols_.front();
+            else if (strike > strikes_.back())
+                return vols_.back();
+        }
+        // and then call the interpolator with extrapolation on
+        return interpolator_(strike, true);
+    }
+
+    BlackVolatilitySurfaceDelta::BlackVolatilitySurfaceDelta(
+        Date referenceDate, const std::vector<Date>& dates, const std::vector<Real>& putDeltas,
+        const std::vector<Real>& callDeltas, bool hasAtm, const Matrix& blackVolMatrix, const DayCounter& dayCounter,
+        const Calendar& cal, const Handle<Quote>& spot, const Handle<YieldTermStructure>& domesticTS,
+        const Handle<YieldTermStructure>& foreignTS, DeltaVolQuote::DeltaType dt, DeltaVolQuote::AtmType at,
+        ext::optional<DeltaVolQuote::DeltaType> atmDeltaType, const Period& switchTenor, DeltaVolQuote::DeltaType ltdt,
+        DeltaVolQuote::AtmType ltat, ext::optional<QuantLib::DeltaVolQuote::DeltaType> longTermAtmDeltaType,
+        InterpolatedFxSmileSection::InterpolationMethod im, bool flatStrikeExtrapolation,
+        QuantLib::BlackVolTimeExtrapolation timeExtrapolation)
+        : BlackVolatilityTermStructure(referenceDate, cal, Following, dayCounter), dates_(dates), times_(dates.size(), 0),
+        putDeltas_(putDeltas), callDeltas_(callDeltas), hasAtm_(hasAtm), spot_(spot), domesticTS_(domesticTS),
+        foreignTS_(foreignTS), dt_(dt), at_(at), atmDeltaType_(atmDeltaType), switchTenor_(switchTenor), ltdt_(ltdt),
+        ltat_(ltat), longTermAtmDeltaType_(longTermAtmDeltaType), interpolationMethod_(im),
+        flatStrikeExtrapolation_(flatStrikeExtrapolation), timeExtrapolation_(timeExtrapolation) {
+
+        // If ATM delta type is not given, set it to dt
+        if (!atmDeltaType_)
+            atmDeltaType_ = dt_;
+        if (!longTermAtmDeltaType_)
+            longTermAtmDeltaType_ = ltdt_;
+
+        // set switch time
+        switchTime_ = switchTenor_ == 0 * Days ? QL_MAX_REAL : timeFromReference(optionDateFromTenor(switchTenor));
+
+        QL_REQUIRE(dates.size() > 1, "at least 1 date required");
+        // this has already been done for dates
+        for (Size i = 0; i < dates.size(); i++) {
+            QL_REQUIRE(referenceDate < dates[i], "Dates must be greater than reference date");
+            times_[i] = timeFromReference(dates[i]);
+            if (i > 0) {
+                QL_REQUIRE(times_[i] > times_[i - 1], "dates must be sorted unique!");
+            }
+        }
+
+        // check size of matrix
+        Size n = putDeltas.size() + (hasAtm ? 1 : 0) + callDeltas.size();
+        QL_REQUIRE(n > 0, "Need at least one delta");
+        QL_REQUIRE(blackVolMatrix.columns() == n, "Invalid number of columns in blackVolMatrix, got "
+                                                    << blackVolMatrix.columns() << " but have " << n << " deltas");
+        QL_REQUIRE(blackVolMatrix.rows() == dates.size(), "Invalid number of rows in blackVolMatrix, got "
+                                                            << blackVolMatrix.rows() << " but have " << dates.size()
+                                                            << " dates");
+
+        // build interpolators for each delta
+        // TODO: template this so it can be changed
+        bool forceMonotoneVariance = false;
+        for (Size i = 0; i < n; i++) {
+            vector<Volatility> vols(dates.size());
+            for (Size j = 0; j < dates.size(); j++) {
+                vols[j] = blackVolMatrix[j][i];
+            }
+
+            // BlackVarianceCurve will make a local copy of vols and dates
+            interpolators_.push_back(QuantLib::ext::make_shared<BlackVarianceCurve>(
+                referenceDate, dates, vols, dayCounter, forceMonotoneVariance,
+                timeExtrapolation));
+        }
+
+        // register
+        registerWith(spot_);
+        registerWith(domesticTS_);
+        registerWith(foreignTS_);
+    }
+
+    QuantLib::ext::shared_ptr<FxSmileSection> BlackVolatilitySurfaceDelta::blackVolSmile(Time t) const {
+
+        Real spot = spot_->value();
+        DiscountFactor dDiscount = domesticTS_->discount(t);
+        DiscountFactor fDiscount = foreignTS_->discount(t);
+
+        DeltaVolQuote::AtmType at;
+        DeltaVolQuote::DeltaType dt;
+        DeltaVolQuote::DeltaType atmDt;
+        if (t < switchTime_ && !close_enough(t, switchTime_)) {
+            at = at_;
+            dt = dt_;
+            atmDt = *atmDeltaType_;
+        } else {
+            at = ltat_;
+            dt = ltdt_;
+            atmDt = *longTermAtmDeltaType_;
+        }
+
+        // Store smile section in map. Use strikes as key and vols as values for automatic sorting by strike.
+        // If we have already have a strike from a previous delta, we do not overwrite it.
+        auto comp = [](Real a, Real b) { return !close(a, b) && a < b; };
+        map<Real, Real, decltype(comp)> smileSection(comp);
+        Size i = 0;
+        for (Real delta : putDeltas_) {
+            Real vol = interpolators_.at(i)->blackVol(t, 1, true);
+            try {
+                BlackDeltaCalculator bdc(Option::Put, dt, spot, dDiscount, fDiscount, vol * sqrt(t));
+                Real strike = bdc.strikeFromDelta(delta);
+                if (smileSection.count(strike) == 0)
+                    smileSection[strike] = vol;
+            } catch (const std::exception& e) {
+                QL_FAIL("BlackVolatilitySurfaceDelta: Error during calculating put strike at delta " << delta << ": "
+                                                                                                    << e.what());
+            }
+            i++;
+        }
+        if (hasAtm_) {
+            Real vol = interpolators_.at(i)->blackVol(t, 1, true);
+            try {
+                BlackDeltaCalculator bdc(Option::Put, atmDt, spot, dDiscount, fDiscount, vol * sqrt(t));
+                Real strike = bdc.atmStrike(at);
+                if (smileSection.count(strike) == 0)
+                    smileSection[strike] = vol;
+            } catch (const std::exception& e) {
+                QL_FAIL("BlackVolatilitySurfaceDelta: Error during calculating atm strike: " << e.what());
+            }
+            i++;
+        }
+        for (Real delta : callDeltas_) {
+            Real vol = interpolators_.at(i)->blackVol(t, 1, true);
+            try {
+                BlackDeltaCalculator bdc(Option::Call, dt, spot, dDiscount, fDiscount, vol * sqrt(t));
+                Real strike = bdc.strikeFromDelta(delta);
+                if (smileSection.count(strike) == 0)
+                    smileSection[strike] = vol;
+            } catch (const std::exception& e) {
+                QL_FAIL("BlackVolatilitySurfaceDelta: Error during calculating call strike at delta " << delta << ": "
+                                                                                                    << e.what());
+            }
+            i++;
+        }
+
+        // sort and extract to vectors
+        vector<Real> strikes;
+        strikes.reserve(smileSection.size());
+        vector<Real> vols;
+        vols.reserve(smileSection.size());
+        for (const auto& kv : smileSection) {
+            strikes.push_back(kv.first);
+            vols.push_back(kv.second);
+        }
+
+        // now build smile from strikes and vols
+        QL_REQUIRE(!vols.empty(),
+                "BlackVolatilitySurfaceDelta::blackVolSmile(" << t << "): no strikes given, this is unexpected.");
+        if (vols.size() == 1) {
+            // handle the situation that we only have one strike (might occur for e.g. t=0)
+            return QuantLib::ext::make_shared<ConstantFxSmileSection>(vols.front());
+        } else {
+            // we have at least two strikes
+            return QuantLib::ext::make_shared<InterpolatedFxSmileSection>(spot, dDiscount, fDiscount, t, strikes, vols,
+                                                                        interpolationMethod_, flatStrikeExtrapolation_);
+        }
+    }
+
+    QuantLib::ext::shared_ptr<FxSmileSection> BlackVolatilitySurfaceDelta::blackVolSmile(const Date& d) const {
+        return blackVolSmile(timeFromReference(d));
+    }
+
+    Real BlackVolatilitySurfaceDelta::forward(Time t) const {
+        return spot_->value() * foreignTS_->discount(t) / domesticTS_->discount(t); // TODO
+    }
+
+    Volatility BlackVolatilitySurfaceDelta::blackVolImpl(Time t, Real strike) const {
+        // If asked for strike == 0, just return the ATM value.
+        double tme =
+            (t > times_.back() && timeExtrapolation_ == BlackVolTimeExtrapolation::FlatVolatility) ? times_.back() : t;
+
+        if (strike == 0 || strike == Null<Real>()) {
+            if (hasAtm_) {
+                // ask the ATM interpolator directly
+                return interpolators_[putDeltas_.size()]->blackVol(tme, Null<Real>(), true);
+            } else {
+                // set strike to be fwd and we will return ATMF
+                strike = forward(tme);
+            }
+        }
+        return blackVolSmile(tme)->volatility(strike);
+    }
+
+} // namespace QuantLib
diff --git a/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp b/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp
new file mode 100644
index 00000000000..c9adf3a3bc8
--- /dev/null
+++ b/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp
@@ -0,0 +1,177 @@
+/*
+ Copyright (C) 2019 Quaternion Risk Management Ltd
+ Copyright (C) 2022 Skandinaviska Enskilda Banken AB (publ)
+ All rights reserved.
+
+ This file is part of ORE, a free-software/open-source library
+ for transparent pricing and risk analysis - http://opensourcerisk.org
+
+ ORE is free software: you can redistribute it and/or modify it
+ under the terms of the Modified BSD License.  You should have received a
+ copy of the license along with this program.
+ The license is also available online at <http://opensourcerisk.org>
+
+ This program is distributed on the basis that it will form a useful
+ contribution to risk analytics and model standardisation, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the license for more details.
+*/
+
+/*! \file blackvolsurfacedelta.hpp
+ \brief Black volatility surface based on delta
+ \ingroup termstructures
+ */
+
+#ifndef quantlib_black_variance_surface_delta_hpp
+#define quantlib_black_variance_surface_delta_hpp
+
+#include <ql/experimental/fx/deltavolquote.hpp>
+#include <ql/math/interpolation.hpp>
+#include <ql/math/matrix.hpp>
+#include <ql/termstructures/volatility/equityfx/blackvariancecurve.hpp>
+#include <ql/termstructures/volatility/equityfx/blackvoltermstructure.hpp>
+#include <ql/termstructures/yieldtermstructure.hpp>
+#include <ql/time/calendar.hpp>
+#include <ql/time/daycounter.hpp>
+#include <ql/termstructures/volatility/equityfx/fxsmilesection.hpp>
+
+namespace QuantLib {
+
+    class InterpolatedFxSmileSection : public FxSmileSection {
+    public:
+        //! Supported interpolation methods
+        enum class InterpolationMethod { Linear, NaturalCubic, FinancialCubic, CubicSpline };
+
+        //! ctor
+        InterpolatedFxSmileSection(Real spot, Real rd, Real rf, Time t, const std::vector<Real>& strikes,
+                                const std::vector<Volatility>& vols, InterpolationMethod method,
+                                bool flatExtrapolation = false);
+
+        Volatility volatility(Real strike) const override;
+
+        //! \name Inspectors
+        //@{
+        const std::vector<Real>& strikes() const { return strikes_; }
+        const std::vector<Volatility>& volatilities() const { return vols_; }
+        //@}
+
+    private:
+        Interpolation interpolator_;
+        std::vector<Real> strikes_;
+        std::vector<Volatility> vols_;
+        bool flatExtrapolation_;
+    };
+
+    class ConstantFxSmileSection : public FxSmileSection {
+    public:
+        //! ctor
+        ConstantFxSmileSection(const Volatility vol) : vol_(vol) {}
+
+        Volatility volatility(Real strike) const override { return vol_; }
+
+        //! \name Inspectors
+        //@{
+        const Volatility volatility() const { return vol_; }
+        //@}
+
+    private:
+        Volatility vol_;
+    };
+
+    //! Abstract Black volatility surface based on delta
+    //!  \ingroup termstructures
+    class BlackVolatilitySurfaceDelta : public BlackVolatilityTermStructure {
+    public:
+        BlackVolatilitySurfaceDelta(Date referenceDate, const std::vector<Date>& dates, const std::vector<Real>& putDeltas,
+                                    const std::vector<Real>& callDeltas, bool hasAtm, const Matrix& blackVolMatrix,
+                                    const DayCounter& dayCounter, const Calendar& cal, const Handle<Quote>& spot,
+                                    const Handle<YieldTermStructure>& domesticTS,
+                                    const Handle<YieldTermStructure>& foreignTS,
+                                    DeltaVolQuote::DeltaType dt = DeltaVolQuote::DeltaType::Spot,
+                                    DeltaVolQuote::AtmType at = DeltaVolQuote::AtmType::AtmDeltaNeutral,
+                                    ext::optional<DeltaVolQuote::DeltaType> atmDeltaType = ext::nullopt,
+                                    const Period& switchTenor = 0 * Days,
+                                    DeltaVolQuote::DeltaType ltdt = DeltaVolQuote::DeltaType::Fwd,
+                                    DeltaVolQuote::AtmType ltat = DeltaVolQuote::AtmType::AtmDeltaNeutral,
+                                    ext::optional<DeltaVolQuote::DeltaType> longTermAtmDeltaType = ext::nullopt,
+                                    InterpolatedFxSmileSection::InterpolationMethod interpolationMethod =
+                                        InterpolatedFxSmileSection::InterpolationMethod::Linear,
+                                    bool flatStrikeExtrapolation = true,
+                                    BlackVolTimeExtrapolation timeExtrapolation =
+                                        BlackVolTimeExtrapolation::FlatVolatility);
+
+        //! \name TermStructure interface
+        //@{
+        Date maxDate() const override { return Date::maxDate(); }
+        //@}
+        //! \name VolatilityTermStructure interface
+        //@{
+        Real minStrike() const override { return 0; }
+        Real maxStrike() const override { return QL_MAX_REAL; }
+        //@}
+        //! \name Visitability
+        //@{
+        virtual void accept(AcyclicVisitor&) override;
+        //@}
+
+        //! \name Inspectors
+        //@{
+        const std::vector<Date>& dates() const { return dates_; }
+        //@}
+
+        //! Return an FxSmile for the time t
+        /*! Note the smile does not observe the spot or YTS handles, it will
+        *  not update when they change.
+        *
+        *  This is not really FX specific
+        */
+        ext::shared_ptr<FxSmileSection> blackVolSmile(Time t) const;
+
+        ext::shared_ptr<FxSmileSection> blackVolSmile(const Date& d) const;
+
+    protected:
+        virtual Volatility blackVolImpl(Time t, Real strike) const override;
+
+    private:
+        std::vector<Date> dates_;
+        std::vector<Time> times_;
+
+        std::vector<Real> putDeltas_;
+        std::vector<Real> callDeltas_;
+        bool hasAtm_;
+        std::vector<ext::shared_ptr<BlackVarianceCurve> > interpolators_;
+
+        Handle<Quote> spot_;
+        Handle<YieldTermStructure> domesticTS_;
+        Handle<YieldTermStructure> foreignTS_;
+
+        DeltaVolQuote::DeltaType dt_;
+        DeltaVolQuote::AtmType at_;
+        ext::optional<DeltaVolQuote::DeltaType> atmDeltaType_;
+        Period switchTenor_;
+        DeltaVolQuote::DeltaType ltdt_;
+        DeltaVolQuote::AtmType ltat_;
+        ext::optional<DeltaVolQuote::DeltaType> longTermAtmDeltaType_;
+
+        InterpolatedFxSmileSection::InterpolationMethod interpolationMethod_;
+        bool flatStrikeExtrapolation_;
+        BlackVolTimeExtrapolation timeExtrapolation_;
+        Real switchTime_;
+
+        // calculate forward for time $t$
+        Real forward(Time t) const;
+    };
+
+    // inline definitions
+
+    inline void BlackVolatilitySurfaceDelta::accept(AcyclicVisitor& v) {
+        Visitor<BlackVolatilitySurfaceDelta>* v1 = dynamic_cast<Visitor<BlackVolatilitySurfaceDelta>*>(&v);
+        if (v1 != 0)
+            v1->visit(*this);
+        else
+            BlackVolatilityTermStructure::accept(v);
+    }
+
+} // namespace QuantLib
+
+#endif
diff --git a/ql/termstructures/volatility/equityfx/blackvoltermstructure.hpp b/ql/termstructures/volatility/equityfx/blackvoltermstructure.hpp
index 7c09145b532..83ae1d1df20 100644
--- a/ql/termstructures/volatility/equityfx/blackvoltermstructure.hpp
+++ b/ql/termstructures/volatility/equityfx/blackvoltermstructure.hpp
@@ -30,6 +30,12 @@
 
 namespace QuantLib {
 
+    enum class BlackVolTimeExtrapolation {
+        FlatVolatility,
+        UseInterpolatorVariance,
+        UseInterpolatorVolatility,
+    };
+
     //! Black-volatility term structure
     /*! This abstract class defines the interface of concrete
         Black-volatility term structures which will be derived from
diff --git a/ql/termstructures/volatility/equityfx/fxsmilesection.hpp b/ql/termstructures/volatility/equityfx/fxsmilesection.hpp
new file mode 100644
index 00000000000..a6bf508cc15
--- /dev/null
+++ b/ql/termstructures/volatility/equityfx/fxsmilesection.hpp
@@ -0,0 +1,55 @@
+/*
+ Copyright (C) 2017 Quaternion Risk Management Ltd
+ All rights reserved.
+
+ This file is part of ORE, a free-software/open-source library
+ for transparent pricing and risk analysis - http://opensourcerisk.org
+
+ ORE is free software: you can redistribute it and/or modify it
+ under the terms of the Modified BSD License.  You should have received a
+ copy of the license along with this program.
+ The license is also available online at <http://opensourcerisk.org>
+
+ This program is distributed on the basis that it will form a useful
+ contribution to risk analytics and model standardisation, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the license for more details.
+*/
+
+/*! \file fxsmilesection.hpp
+    \brief FX smile section assuming a strike/volatility space
+    \ingroup termstructures
+*/
+
+#ifndef quantlib_fx_smile_section_hpp
+#define quantlib_fx_smile_section_hpp
+
+#include <ql/types.hpp>
+
+namespace QuantLib {
+
+    //! FX SmileSection
+    //! \ingroup termstructures
+    class FxSmileSection {
+    public:
+        FxSmileSection() : spot_(0.0), rd_(0.0), rf_(0.0), expiryTime_(0.0) {}
+        FxSmileSection(Real spot, Real rd, Real rf, Time t) : spot_(spot), rd_(rd), rf_(rf), expiryTime_(t) {}
+        virtual ~FxSmileSection(){};
+
+        virtual Volatility volatility(Real strike) const = 0;
+
+        Time expiryTime() const { return expiryTime_; }
+
+        DiscountFactor domesticDiscount() const { return std::exp(-rd_ * expiryTime()); }
+        DiscountFactor foreignDiscount() const { return std::exp(-rf_ * expiryTime()); }
+
+    protected:
+        Real spot_;
+        Real rd_;
+        Real rf_;
+        Time expiryTime_;
+    };
+
+}
+
+#endif
diff --git a/test-suite/CMakeLists.txt b/test-suite/CMakeLists.txt
index 0a3ca245113..6fec73ac93b 100644
--- a/test-suite/CMakeLists.txt
+++ b/test-suite/CMakeLists.txt
@@ -17,6 +17,7 @@ set(QL_TEST_SOURCES
     blackdeltacalculator.cpp
 	blackcalculator.cpp
     blackformula.cpp
+    blackvolsurfacedelta.cpp
     bondforward.cpp
     bonds.cpp
     brownianbridge.cpp
diff --git a/test-suite/Makefile.am b/test-suite/Makefile.am
index b275faf9a8e..92809b5ec8c 100644
--- a/test-suite/Makefile.am
+++ b/test-suite/Makefile.am
@@ -18,6 +18,7 @@ QL_TEST_SRCS = \
 	blackcalculator.cpp \
 	blackdeltacalculator.cpp \
 	blackformula.cpp \
+	blackvolsurfacedelta.cpp \
 	bondforward.cpp \
 	bonds.cpp \
 	brownianbridge.cpp \
diff --git a/test-suite/blackvolsurfacedelta.cpp b/test-suite/blackvolsurfacedelta.cpp
new file mode 100644
index 00000000000..160ecc15dbf
--- /dev/null
+++ b/test-suite/blackvolsurfacedelta.cpp
@@ -0,0 +1,102 @@
+/*
+ Copyright (C) 2019 Quaternion Risk Management Ltd
+ Copyright (C) 2020 Skandinaviska Enskilda Banken AB (publ)
+ All rights reserved.
+
+ This file is part of ORE, a free-software/open-source library
+ for transparent pricing and risk analysis - http://opensourcerisk.org
+
+ ORE is free software: you can redistribute it and/or modify it
+ under the terms of the Modified BSD License.  You should have received a
+ copy of the license along with this program.
+ The license is also available online at <http://opensourcerisk.org>
+
+ This program is distributed on the basis that it will form a useful
+ contribution to risk analytics and model standardisation, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the license for more details.
+*/
+
+#include "toplevelfixture.hpp"
+#include <boost/make_shared.hpp>
+#include <boost/test/unit_test.hpp>
+#include <ql/quotes/simplequote.hpp>
+#include <ql/termstructures/yield/flatforward.hpp>
+#include <ql/time/calendars/target.hpp>
+#include <ql/time/daycounters/actualactual.hpp>
+#include <ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp>
+
+using namespace boost::unit_test_framework;
+using namespace QuantLib;
+using namespace std;
+
+BOOST_FIXTURE_TEST_SUITE(QuantLibTests, TopLevelFixture)
+
+BOOST_AUTO_TEST_SUITE(BlackVolSurfaceDeltaTest)
+
+BOOST_AUTO_TEST_CASE(testBlackVolSurfaceDeltaConstantVol) {
+
+    BOOST_TEST_MESSAGE("Testing BlackVolatilitySurfaceDelta...");
+
+    Volatility constVol = 0.10; // 10%
+
+    Date refDate(1, Jan, 2010);
+    Settings::instance().evaluationDate() = refDate;
+
+    // Setup a 2x2
+    vector<Date> dates = { Date(1, Jan, 2011), Date(1, Jan, 2012) };
+    vector<Real> putDeltas = { -0.25 };
+    vector<Real> callDeltas = { 0.25 };
+    bool hasAtm = false;
+    Matrix blackVolMatrix(2, 2, constVol);
+
+    // dummy spot and zero yield curve
+    Handle<Quote> spot(ext::make_shared<SimpleQuote>(1.0));
+    Handle<YieldTermStructure> dts(ext::make_shared<FlatForward>(0, TARGET(), 0.011, ActualActual(ActualActual::ISDA)));
+    Handle<YieldTermStructure> fts(ext::make_shared<FlatForward>(0, TARGET(), 0.012, ActualActual(ActualActual::ISDA)));
+
+    // build a vol surface
+    BOOST_TEST_MESSAGE("Build Surface");
+    BlackVolatilitySurfaceDelta surface(refDate, dates, putDeltas, callDeltas, hasAtm, blackVolMatrix, ActualActual(ActualActual::ISDA),
+                                        TARGET(), spot, dts, fts);
+
+    // ask for volatility at lots of points, should be constVol at every point
+    // make sure we ask for vols outside 25D and 2Y
+    for (Time t : { 0.25, 0.5, 1.0, 1.5, 2.0, 2.5, 10.0 }) {
+        for (Real k = 0.5; k < 2.0; k += 0.05) {
+            Volatility vol = surface.blackVol(t, k);
+            BOOST_CHECK_EQUAL(vol, constVol);
+        }
+    }
+}
+
+BOOST_AUTO_TEST_CASE(testInterpolatedFxSmileSectionConstruction) {
+
+    BOOST_TEST_MESSAGE("Testing InterpolatedFxSmileSection...");
+    // Set up the parameters with some arbitrary data
+    Real spot = 100;
+    Real rd = 0.05;
+    Real rf = 0.03;
+    Time t = 1.0;
+    vector<Real> strikes = { 90, 100, 110 };
+    vector<Volatility> vols = { 0.15, 0.1, 0.15 };
+    vector<InterpolatedFxSmileSection::InterpolationMethod> methods = {
+        InterpolatedFxSmileSection::InterpolationMethod::Linear,
+        InterpolatedFxSmileSection::InterpolationMethod::FinancialCubic,
+        InterpolatedFxSmileSection::InterpolationMethod::NaturalCubic,
+        InterpolatedFxSmileSection::InterpolationMethod::CubicSpline
+    };
+
+    // Construct the smile section
+    ext::shared_ptr<InterpolatedFxSmileSection> section;
+    for (auto method : methods) {
+        BOOST_TEST_MESSAGE("Trying to construct InterpolatedFxSmileSection with interpolation method: " << Integer(method) << ".");
+        BOOST_CHECK_NO_THROW(section =
+                                ext::make_shared<InterpolatedFxSmileSection>(spot, rd, rf, t, strikes, vols, method));
+        BOOST_CHECK_EQUAL(section->volatility(strikes.at(1)), vols.at(1));
+    }
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test-suite/testsuite.vcxproj b/test-suite/testsuite.vcxproj
index cf47e1d30c8..9af2e569023 100644
--- a/test-suite/testsuite.vcxproj
+++ b/test-suite/testsuite.vcxproj
@@ -662,6 +662,7 @@
     <ClCompile Include="blackcalculator.cpp" />
     <ClCompile Include="blackdeltacalculator.cpp" />
     <ClCompile Include="blackformula.cpp" />
+    <ClCompile Include="blackvolsurfacedelta.cpp" /> 
     <ClCompile Include="bondforward.cpp" />
     <ClCompile Include="bonds.cpp" />
     <ClCompile Include="brownianbridge.cpp" />
diff --git a/test-suite/testsuite.vcxproj.filters b/test-suite/testsuite.vcxproj.filters
index efc3dc42436..ee1e23f1947 100644
--- a/test-suite/testsuite.vcxproj.filters
+++ b/test-suite/testsuite.vcxproj.filters
@@ -50,6 +50,9 @@
     <ClCompile Include="blackformula.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="blackvolsurfacedelta.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
     <ClCompile Include="bonds.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>

From be091ed5e7f2d6812f232bf271b5b4c1b6000fb7 Mon Sep 17 00:00:00 2001
From: paolodelia99 <paolo.delia99@gmail.com>
Date: Fri, 17 Oct 2025 09:42:02 +0200
Subject: [PATCH 02/11] Add unit test for BlackVolatilitySurfaceDelta with
 non-constant volatility

---
 .../equityfx/blackvolsurfacedelta.cpp         | 14 +++---
 test-suite/blackvolsurfacedelta.cpp           | 49 +++++++++++++++++++
 2 files changed, 56 insertions(+), 7 deletions(-)

diff --git a/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.cpp b/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.cpp
index 47921a695fb..4ccad33a6d5 100644
--- a/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.cpp
+++ b/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.cpp
@@ -66,9 +66,9 @@ namespace QuantLib {
         const Calendar& cal, const Handle<Quote>& spot, const Handle<YieldTermStructure>& domesticTS,
         const Handle<YieldTermStructure>& foreignTS, DeltaVolQuote::DeltaType dt, DeltaVolQuote::AtmType at,
         ext::optional<DeltaVolQuote::DeltaType> atmDeltaType, const Period& switchTenor, DeltaVolQuote::DeltaType ltdt,
-        DeltaVolQuote::AtmType ltat, ext::optional<QuantLib::DeltaVolQuote::DeltaType> longTermAtmDeltaType,
+        DeltaVolQuote::AtmType ltat, ext::optional<DeltaVolQuote::DeltaType> longTermAtmDeltaType,
         InterpolatedFxSmileSection::InterpolationMethod im, bool flatStrikeExtrapolation,
-        QuantLib::BlackVolTimeExtrapolation timeExtrapolation)
+        BlackVolTimeExtrapolation timeExtrapolation)
         : BlackVolatilityTermStructure(referenceDate, cal, Following, dayCounter), dates_(dates), times_(dates.size(), 0),
         putDeltas_(putDeltas), callDeltas_(callDeltas), hasAtm_(hasAtm), spot_(spot), domesticTS_(domesticTS),
         foreignTS_(foreignTS), dt_(dt), at_(at), atmDeltaType_(atmDeltaType), switchTenor_(switchTenor), ltdt_(ltdt),
@@ -113,7 +113,7 @@ namespace QuantLib {
             }
 
             // BlackVarianceCurve will make a local copy of vols and dates
-            interpolators_.push_back(QuantLib::ext::make_shared<BlackVarianceCurve>(
+            interpolators_.push_back(ext::make_shared<BlackVarianceCurve>(
                 referenceDate, dates, vols, dayCounter, forceMonotoneVariance,
                 timeExtrapolation));
         }
@@ -124,7 +124,7 @@ namespace QuantLib {
         registerWith(foreignTS_);
     }
 
-    QuantLib::ext::shared_ptr<FxSmileSection> BlackVolatilitySurfaceDelta::blackVolSmile(Time t) const {
+    ext::shared_ptr<FxSmileSection> BlackVolatilitySurfaceDelta::blackVolSmile(Time t) const {
 
         Real spot = spot_->value();
         DiscountFactor dDiscount = domesticTS_->discount(t);
@@ -202,15 +202,15 @@ namespace QuantLib {
                 "BlackVolatilitySurfaceDelta::blackVolSmile(" << t << "): no strikes given, this is unexpected.");
         if (vols.size() == 1) {
             // handle the situation that we only have one strike (might occur for e.g. t=0)
-            return QuantLib::ext::make_shared<ConstantFxSmileSection>(vols.front());
+            return ext::make_shared<ConstantFxSmileSection>(vols.front());
         } else {
             // we have at least two strikes
-            return QuantLib::ext::make_shared<InterpolatedFxSmileSection>(spot, dDiscount, fDiscount, t, strikes, vols,
+            return ext::make_shared<InterpolatedFxSmileSection>(spot, dDiscount, fDiscount, t, strikes, vols,
                                                                         interpolationMethod_, flatStrikeExtrapolation_);
         }
     }
 
-    QuantLib::ext::shared_ptr<FxSmileSection> BlackVolatilitySurfaceDelta::blackVolSmile(const Date& d) const {
+    ext::shared_ptr<FxSmileSection> BlackVolatilitySurfaceDelta::blackVolSmile(const Date& d) const {
         return blackVolSmile(timeFromReference(d));
     }
 
diff --git a/test-suite/blackvolsurfacedelta.cpp b/test-suite/blackvolsurfacedelta.cpp
index 160ecc15dbf..e81e07fb1bf 100644
--- a/test-suite/blackvolsurfacedelta.cpp
+++ b/test-suite/blackvolsurfacedelta.cpp
@@ -70,6 +70,55 @@ BOOST_AUTO_TEST_CASE(testBlackVolSurfaceDeltaConstantVol) {
     }
 }
 
+BOOST_AUTO_TEST_CASE(testBlackVolSurfaceDeltaNonConstantVol) {
+
+    BOOST_TEST_MESSAGE("Testing BlackVolatilitySurfaceDelta with non constant vol surface...");
+
+    std::vector<std::vector<Volatility>> vols = {
+        {0.15, 0.13, 0.135}, // 1M
+        {0.14, 0.11, 0.125}, // 6M
+        {0.13, 0.10, 0.12}, // 1Y
+        {0.125, 0.095, 0.115}, // 2Y
+    };
+
+    Date refDate(1, Jan, 2010);
+    Settings::instance().evaluationDate() = refDate;
+
+    // Setup a 2x2
+    vector<Date> dates = { 
+        refDate + Period(1, Months), 
+        refDate + Period(6, Months),
+        refDate + Period(1, Years),
+        refDate + Period(2, Years)
+    };
+    vector<Real> putDeltas = { -0.25 };
+    vector<Real> callDeltas = { 0.25 };
+    bool hasAtm = true;
+    Matrix blackVolMatrix(4, 3);
+
+    for (Size i = 0; i < vols.size(); ++i) {
+        for (Size j = 0; j < vols.at(0).size(); ++j) {
+            blackVolMatrix[i][j] = vols[i][j];
+        }
+    }
+
+    // dummy spot and zero yield curve
+    Handle<Quote> spot(ext::make_shared<SimpleQuote>(1.18));
+    Handle<YieldTermStructure> dts(ext::make_shared<FlatForward>(0, TARGET(), 0.02, ActualActual(ActualActual::ISDA)));
+    Handle<YieldTermStructure> fts(ext::make_shared<FlatForward>(0, TARGET(), 0.035, ActualActual(ActualActual::ISDA)));
+
+    // build a vol surface
+    BOOST_TEST_MESSAGE("Build Surface");
+    BlackVolatilitySurfaceDelta surface(refDate, dates, putDeltas, callDeltas, hasAtm, blackVolMatrix, ActualActual(ActualActual::ISDA),
+                                        TARGET(), spot, dts, fts);
+
+    // ask for volatility at lots of points, should be constVol at every point
+    // make sure we ask for vols outside 25D and 2Y
+    auto smile1M = surface.blackVolSmile(refDate + Period(1, Months));
+    BOOST_CHECK_CLOSE(smile1M->volatility(1.18), 0.13010360399, 1e-8);
+    
+}
+
 BOOST_AUTO_TEST_CASE(testInterpolatedFxSmileSectionConstruction) {
 
     BOOST_TEST_MESSAGE("Testing InterpolatedFxSmileSection...");

From 5d346f81dfcf0d5442eb889ff2a44af23ac02d2a Mon Sep 17 00:00:00 2001
From: paolodelia99 <paolo.delia99@gmail.com>
Date: Tue, 4 Nov 2025 12:25:32 +0100
Subject: [PATCH 03/11] make InterpolatedFxSmileSection lazy, possibility to
 pass handle<quote> for the vols

---
 .../equityfx/blackvolsurfacedelta.cpp         | 54 ++++++++---
 .../equityfx/blackvolsurfacedelta.hpp         | 20 +++-
 test-suite/blackvolsurfacedelta.cpp           | 92 +++++++++++++------
 3 files changed, 123 insertions(+), 43 deletions(-)

diff --git a/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.cpp b/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.cpp
index 4ccad33a6d5..4931f97fd42 100644
--- a/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.cpp
+++ b/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.cpp
@@ -18,6 +18,7 @@
 */
 
 #include <ql/errors.hpp>
+#include <ql/quotes/simplequote.hpp>
 #include <ql/experimental/fx/blackdeltacalculator.hpp>
 #include <ql/math/interpolations/cubicinterpolation.hpp>
 #include <ql/math/interpolations/linearinterpolation.hpp>
@@ -31,8 +32,48 @@ namespace QuantLib {
                                                     const std::vector<Real>& strikes,
                                                     const std::vector<Volatility>& vols, InterpolationMethod method,
                                                     bool flatExtrapolation)
-        : FxSmileSection(spot, rd, rf, t), strikes_(strikes), vols_(vols), flatExtrapolation_(flatExtrapolation) {
+        : FxSmileSection(spot, rd, rf, t), strikes_(strikes), vols_(vols), volHandles_(vols.size()), flatExtrapolation_(flatExtrapolation) {
+        for (Size i = 0; i < vols.size(); ++i)
+            volHandles_[i] = Handle<Quote>(ext::shared_ptr<Quote>(new SimpleQuote(vols[i])));
 
+        initializeInterpolator(method);
+    }
+
+    InterpolatedFxSmileSection::InterpolatedFxSmileSection(Real spot, Real rd, Real rf, Time t,
+                                                    const std::vector<Real>& strikes,
+                                                    const std::vector<Handle<Quote>>& volHandles, InterpolationMethod method,
+                                                    bool flatExtrapolation)
+        : FxSmileSection(spot, rd, rf, t), strikes_(strikes), vols_(volHandles.size()),
+        volHandles_(volHandles), flatExtrapolation_(flatExtrapolation) {
+        for (auto& volHandle : volHandles)
+            LazyObject::registerWith(volHandle);
+        
+        initializeInterpolator(method);
+    }
+
+    Volatility InterpolatedFxSmileSection::volatility(Real strike) const {
+        calculate();
+        if (flatExtrapolation_) {
+            if (strike < strikes_.front())
+                return vols_.front();
+            else if (strike > strikes_.back())
+                return vols_.back();
+        }
+        // and then call the interpolator with extrapolation on
+        return interpolator_(strike, true);
+    }
+
+    void InterpolatedFxSmileSection::performCalculations() const {
+        for (Size i = 0; i < volHandles_.size(); ++i)
+            vols_[i] = volHandles_[i]->value();
+        interpolator_.update();
+    }
+
+    void InterpolatedFxSmileSection::update() {
+        LazyObject::update();
+    }
+
+    void InterpolatedFxSmileSection::initializeInterpolator(InterpolationMethod method) const {
         if (method == InterpolationMethod::Linear)
             interpolator_ = Linear().interpolate(strikes_.begin(), strikes_.end(), vols_.begin());
         else if (method == InterpolationMethod::NaturalCubic)
@@ -49,17 +90,6 @@ namespace QuantLib {
         }
     }
 
-    Volatility InterpolatedFxSmileSection::volatility(Real strike) const {
-        if (flatExtrapolation_) {
-            if (strike < strikes_.front())
-                return vols_.front();
-            else if (strike > strikes_.back())
-                return vols_.back();
-        }
-        // and then call the interpolator with extrapolation on
-        return interpolator_(strike, true);
-    }
-
     BlackVolatilitySurfaceDelta::BlackVolatilitySurfaceDelta(
         Date referenceDate, const std::vector<Date>& dates, const std::vector<Real>& putDeltas,
         const std::vector<Real>& callDeltas, bool hasAtm, const Matrix& blackVolMatrix, const DayCounter& dayCounter,
diff --git a/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp b/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp
index c9adf3a3bc8..35253a370d1 100644
--- a/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp
+++ b/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp
@@ -37,7 +37,7 @@
 
 namespace QuantLib {
 
-    class InterpolatedFxSmileSection : public FxSmileSection {
+    class InterpolatedFxSmileSection : public FxSmileSection, LazyObject {
     public:
         //! Supported interpolation methods
         enum class InterpolationMethod { Linear, NaturalCubic, FinancialCubic, CubicSpline };
@@ -46,19 +46,31 @@ namespace QuantLib {
         InterpolatedFxSmileSection(Real spot, Real rd, Real rf, Time t, const std::vector<Real>& strikes,
                                 const std::vector<Volatility>& vols, InterpolationMethod method,
                                 bool flatExtrapolation = false);
+        
+        InterpolatedFxSmileSection(Real spot, Real rd, Real rf, Time t, const std::vector<Real>& strikes,
+                                const std::vector<Handle<Quote>>& volsHandles, InterpolationMethod method,
+                                bool flatExtrapolation = false);
 
         Volatility volatility(Real strike) const override;
 
+
+        void performCalculations() const override;
+        void update() override;
         //! \name Inspectors
         //@{
         const std::vector<Real>& strikes() const { return strikes_; }
-        const std::vector<Volatility>& volatilities() const { return vols_; }
+        const std::vector<Volatility>& volatilities() const {
+            return vols_;
+         }
         //@}
 
     private:
-        Interpolation interpolator_;
+        void initializeInterpolator(InterpolationMethod method) const;
+
+        mutable Interpolation interpolator_;
         std::vector<Real> strikes_;
-        std::vector<Volatility> vols_;
+        mutable std::vector<Volatility> vols_;
+        std::vector<Handle<Quote>> volHandles_;
         bool flatExtrapolation_;
     };
 
diff --git a/test-suite/blackvolsurfacedelta.cpp b/test-suite/blackvolsurfacedelta.cpp
index e81e07fb1bf..aea99d6d067 100644
--- a/test-suite/blackvolsurfacedelta.cpp
+++ b/test-suite/blackvolsurfacedelta.cpp
@@ -34,6 +34,71 @@ BOOST_FIXTURE_TEST_SUITE(QuantLibTests, TopLevelFixture)
 
 BOOST_AUTO_TEST_SUITE(BlackVolSurfaceDeltaTest)
 
+BOOST_AUTO_TEST_CASE(testInterpolatedFxSmileSectionConstruction) {
+
+    BOOST_TEST_MESSAGE("Testing InterpolatedFxSmileSection...");
+    // Set up the parameters with some arbitrary data
+    Real spot = 100;
+    Real rd = 0.05;
+    Real rf = 0.03;
+    Time t = 1.0;
+    vector<Real> strikes = { 90, 100, 110 };
+    vector<Volatility> vols = { 0.15, 0.1, 0.15 };
+    vector<InterpolatedFxSmileSection::InterpolationMethod> methods = {
+        InterpolatedFxSmileSection::InterpolationMethod::Linear,
+        InterpolatedFxSmileSection::InterpolationMethod::FinancialCubic,
+        InterpolatedFxSmileSection::InterpolationMethod::NaturalCubic,
+        InterpolatedFxSmileSection::InterpolationMethod::CubicSpline
+    };
+
+    // Construct the smile section
+    ext::shared_ptr<InterpolatedFxSmileSection> section;
+    for (auto method : methods) {
+        BOOST_TEST_MESSAGE("Trying to construct InterpolatedFxSmileSection with interpolation method: " << Integer(method) << ".");
+        BOOST_CHECK_NO_THROW(section =
+                                ext::make_shared<InterpolatedFxSmileSection>(spot, rd, rf, t, strikes, vols, method));
+        BOOST_CHECK_EQUAL(section->volatility(strikes.at(1)), vols.at(1));
+    }
+}
+
+BOOST_AUTO_TEST_CASE(testInterpolatedFxSmileSectionConstructionWithHandles) {
+
+    BOOST_TEST_MESSAGE("Testing InterpolatedFxSmileSection using Handles...");
+    // Set up the parameters with some arbitrary data
+    Real spot = 100;
+    Real rd = 0.05;
+    Real rf = 0.03;
+    Time t = 1.0;
+
+    auto vol90 = ext::shared_ptr<SimpleQuote>(new SimpleQuote(0.15));
+    auto vol100 = ext::shared_ptr<SimpleQuote>(new SimpleQuote(0.1));
+    auto vol110 = ext::shared_ptr<SimpleQuote>(new SimpleQuote(0.13));
+    auto vol90Handle = Handle<Quote>(vol90);
+    auto vol100Handle = Handle<Quote>(vol100);
+    auto vol110Handle = Handle<Quote>(vol110);
+
+    vector<Real> strikes = { 90, 100, 110 };
+    vector<Handle<Quote>> vols = {
+        vol90Handle, 
+        vol100Handle, 
+        vol110Handle 
+    };
+
+    auto method = InterpolatedFxSmileSection::InterpolationMethod::CubicSpline;
+    auto section = ext::make_shared<InterpolatedFxSmileSection>(spot, rd, rf, t, strikes, vols, method);
+    
+    Real strikeToTest = 95.0;
+    Real expectedVol95 = 0.11749999999;
+
+    BOOST_CHECK_CLOSE(section->volatility(strikeToTest), expectedVol95, 1e-8);
+
+    // Test the updated interpolation after the update of a quote
+    vol90->setValue(0.13);
+    Real expectedVol95AfterMove = 0.109375;
+
+    BOOST_CHECK_CLOSE(section->volatility(strikeToTest), expectedVol95AfterMove, 1e-8);
+}
+
 BOOST_AUTO_TEST_CASE(testBlackVolSurfaceDeltaConstantVol) {
 
     BOOST_TEST_MESSAGE("Testing BlackVolatilitySurfaceDelta...");
@@ -119,33 +184,6 @@ BOOST_AUTO_TEST_CASE(testBlackVolSurfaceDeltaNonConstantVol) {
     
 }
 
-BOOST_AUTO_TEST_CASE(testInterpolatedFxSmileSectionConstruction) {
-
-    BOOST_TEST_MESSAGE("Testing InterpolatedFxSmileSection...");
-    // Set up the parameters with some arbitrary data
-    Real spot = 100;
-    Real rd = 0.05;
-    Real rf = 0.03;
-    Time t = 1.0;
-    vector<Real> strikes = { 90, 100, 110 };
-    vector<Volatility> vols = { 0.15, 0.1, 0.15 };
-    vector<InterpolatedFxSmileSection::InterpolationMethod> methods = {
-        InterpolatedFxSmileSection::InterpolationMethod::Linear,
-        InterpolatedFxSmileSection::InterpolationMethod::FinancialCubic,
-        InterpolatedFxSmileSection::InterpolationMethod::NaturalCubic,
-        InterpolatedFxSmileSection::InterpolationMethod::CubicSpline
-    };
-
-    // Construct the smile section
-    ext::shared_ptr<InterpolatedFxSmileSection> section;
-    for (auto method : methods) {
-        BOOST_TEST_MESSAGE("Trying to construct InterpolatedFxSmileSection with interpolation method: " << Integer(method) << ".");
-        BOOST_CHECK_NO_THROW(section =
-                                ext::make_shared<InterpolatedFxSmileSection>(spot, rd, rf, t, strikes, vols, method));
-        BOOST_CHECK_EQUAL(section->volatility(strikes.at(1)), vols.at(1));
-    }
-}
-
 BOOST_AUTO_TEST_SUITE_END()
 
 BOOST_AUTO_TEST_SUITE_END()

From 93c57cb52c3336f9323fa48d0c9c2f79b2bf0410 Mon Sep 17 00:00:00 2001
From: paolodelia99 <paolo.delia99@gmail.com>
Date: Tue, 4 Nov 2025 22:41:40 +0100
Subject: [PATCH 04/11] Fix compilation errors

---
 .../volatility/equityfx/blackvariancetimeextrapolation.hpp     | 1 +
 ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp | 3 ++-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/ql/termstructures/volatility/equityfx/blackvariancetimeextrapolation.hpp b/ql/termstructures/volatility/equityfx/blackvariancetimeextrapolation.hpp
index dff4066db04..2c678bcc0d7 100644
--- a/ql/termstructures/volatility/equityfx/blackvariancetimeextrapolation.hpp
+++ b/ql/termstructures/volatility/equityfx/blackvariancetimeextrapolation.hpp
@@ -22,6 +22,7 @@
 */
 #pragma once
 
+#include <array>
 #include <functional>
 #include <ql/math/comparison.hpp>
 #include <ql/math/interpolation.hpp>
diff --git a/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp b/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp
index 35253a370d1..2a672517421 100644
--- a/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp
+++ b/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp
@@ -37,7 +37,8 @@
 
 namespace QuantLib {
 
-    class InterpolatedFxSmileSection : public FxSmileSection, LazyObject {
+    class InterpolatedFxSmileSection : public FxSmileSection, 
+                                       public LazyObject {
     public:
         //! Supported interpolation methods
         enum class InterpolationMethod { Linear, NaturalCubic, FinancialCubic, CubicSpline };

From dddeafdec3342c4d8a4f925a34eebb7981890cd4 Mon Sep 17 00:00:00 2001
From: paolodelia99 <paolo.delia99@gmail.com>
Date: Wed, 5 Nov 2025 11:02:38 +0100
Subject: [PATCH 05/11] Replace InterpolatedFxSmileSection with already present
 InterpolatedSmileSection

---
 QuantLib.vcxproj                              |   1 -
 QuantLib.vcxproj.filters                      |   3 -
 ql/CMakeLists.txt                             |   1 -
 .../volatility/equityfx/Makefile.am           |   1 -
 .../equityfx/blackvolsurfacedelta.cpp         | 129 ++++++------------
 .../equityfx/blackvolsurfacedelta.hpp         |  69 ++--------
 .../volatility/equityfx/fxsmilesection.hpp    |  55 --------
 test-suite/blackvolsurfacedelta.cpp           |  65 ---------
 8 files changed, 52 insertions(+), 272 deletions(-)
 delete mode 100644 ql/termstructures/volatility/equityfx/fxsmilesection.hpp

diff --git a/QuantLib.vcxproj b/QuantLib.vcxproj
index 3e9f2eb8c5a..28771422ec2 100644
--- a/QuantLib.vcxproj
+++ b/QuantLib.vcxproj
@@ -1731,7 +1731,6 @@
     <ClInclude Include="ql\termstructures\volatility\equityfx\blackvolsurfacedelta.hpp" />
     <ClInclude Include="ql\termstructures\volatility\equityfx\blackvoltermstructure.hpp" />
     <ClInclude Include="ql\termstructures\volatility\equityfx\fixedlocalvolsurface.hpp" />
-    <ClInclude Include="ql\termstructures\volatility\equityfx\fxsmilesection.hpp" />
     <ClInclude Include="ql\termstructures\volatility\equityfx\gridmodellocalvolsurface.hpp" />
     <ClInclude Include="ql\termstructures\volatility\equityfx\hestonblackvolsurface.hpp" />
     <ClInclude Include="ql\termstructures\volatility\equityfx\impliedvoltermstructure.hpp" />
diff --git a/QuantLib.vcxproj.filters b/QuantLib.vcxproj.filters
index 74839fb564f..3c1cc862826 100644
--- a/QuantLib.vcxproj.filters
+++ b/QuantLib.vcxproj.filters
@@ -4251,9 +4251,6 @@
     <ClInclude Include="ql\termstructures\volatility\equityfx\fixedlocalvolsurface.hpp">
       <Filter>termstructures\volatility\equityfx</Filter>
     </ClInclude>
-    <ClInclude Include="ql\termstructures\volatility\equityfx\fxsmilesection.hpp">
-      <Filter>termstructures\volatility\equityfx</Filter>
-    </ClInclude>
     <ClInclude Include="ql\methods\finitedifferences\operators\fdmlocalvolfwdop.hpp">
       <Filter>methods\finitedifferences\operators</Filter>
     </ClInclude>
diff --git a/ql/CMakeLists.txt b/ql/CMakeLists.txt
index 469a6d351bb..d399d99f69b 100644
--- a/ql/CMakeLists.txt
+++ b/ql/CMakeLists.txt
@@ -2108,7 +2108,6 @@ set(QL_HEADERS
     termstructures/volatility/equityfx/blackvolsurfacedelta.hpp
     termstructures/volatility/equityfx/blackvoltermstructure.hpp
     termstructures/volatility/equityfx/fixedlocalvolsurface.hpp
-    termstructures/volatility/equityfx/fxsmilesection.hpp
     termstructures/volatility/equityfx/gridmodellocalvolsurface.hpp
     termstructures/volatility/equityfx/hestonblackvolsurface.hpp
     termstructures/volatility/equityfx/impliedvoltermstructure.hpp
diff --git a/ql/termstructures/volatility/equityfx/Makefile.am b/ql/termstructures/volatility/equityfx/Makefile.am
index 997f501732f..94ae793d063 100644
--- a/ql/termstructures/volatility/equityfx/Makefile.am
+++ b/ql/termstructures/volatility/equityfx/Makefile.am
@@ -14,7 +14,6 @@ this_include_HEADERS = \
     blackvolsurfacedelta.hpp \
     blackvoltermstructure.hpp \
     fixedlocalvolsurface.hpp \
-    fxsmilesection.hpp \
     gridmodellocalvolsurface.hpp \
     hestonblackvolsurface.hpp \
     impliedvoltermstructure.hpp \
diff --git a/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.cpp b/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.cpp
index 4931f97fd42..3dc693f73a7 100644
--- a/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.cpp
+++ b/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.cpp
@@ -23,73 +23,13 @@
 #include <ql/math/interpolations/cubicinterpolation.hpp>
 #include <ql/math/interpolations/linearinterpolation.hpp>
 #include <ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp>
+#include <ql/termstructures/volatility/interpolatedsmilesection.hpp>
+#include <ql/termstructures/volatility/flatsmilesection.hpp>
 
 using namespace std;
 
 namespace QuantLib {
 
-    InterpolatedFxSmileSection::InterpolatedFxSmileSection(Real spot, Real rd, Real rf, Time t,
-                                                    const std::vector<Real>& strikes,
-                                                    const std::vector<Volatility>& vols, InterpolationMethod method,
-                                                    bool flatExtrapolation)
-        : FxSmileSection(spot, rd, rf, t), strikes_(strikes), vols_(vols), volHandles_(vols.size()), flatExtrapolation_(flatExtrapolation) {
-        for (Size i = 0; i < vols.size(); ++i)
-            volHandles_[i] = Handle<Quote>(ext::shared_ptr<Quote>(new SimpleQuote(vols[i])));
-
-        initializeInterpolator(method);
-    }
-
-    InterpolatedFxSmileSection::InterpolatedFxSmileSection(Real spot, Real rd, Real rf, Time t,
-                                                    const std::vector<Real>& strikes,
-                                                    const std::vector<Handle<Quote>>& volHandles, InterpolationMethod method,
-                                                    bool flatExtrapolation)
-        : FxSmileSection(spot, rd, rf, t), strikes_(strikes), vols_(volHandles.size()),
-        volHandles_(volHandles), flatExtrapolation_(flatExtrapolation) {
-        for (auto& volHandle : volHandles)
-            LazyObject::registerWith(volHandle);
-        
-        initializeInterpolator(method);
-    }
-
-    Volatility InterpolatedFxSmileSection::volatility(Real strike) const {
-        calculate();
-        if (flatExtrapolation_) {
-            if (strike < strikes_.front())
-                return vols_.front();
-            else if (strike > strikes_.back())
-                return vols_.back();
-        }
-        // and then call the interpolator with extrapolation on
-        return interpolator_(strike, true);
-    }
-
-    void InterpolatedFxSmileSection::performCalculations() const {
-        for (Size i = 0; i < volHandles_.size(); ++i)
-            vols_[i] = volHandles_[i]->value();
-        interpolator_.update();
-    }
-
-    void InterpolatedFxSmileSection::update() {
-        LazyObject::update();
-    }
-
-    void InterpolatedFxSmileSection::initializeInterpolator(InterpolationMethod method) const {
-        if (method == InterpolationMethod::Linear)
-            interpolator_ = Linear().interpolate(strikes_.begin(), strikes_.end(), vols_.begin());
-        else if (method == InterpolationMethod::NaturalCubic)
-            interpolator_ =
-                Cubic(CubicInterpolation::Kruger, true).interpolate(strikes_.begin(), strikes_.end(), vols_.begin());
-        else if (method == InterpolationMethod::FinancialCubic)
-            interpolator_ = Cubic(CubicInterpolation::Kruger, true, CubicInterpolation::SecondDerivative, 0.0,
-                                CubicInterpolation::FirstDerivative)
-                                .interpolate(strikes_.begin(), strikes_.end(), vols_.begin());
-        else if (method == InterpolationMethod::CubicSpline)
-            interpolator_ = CubicNaturalSpline(strikes_.begin(), strikes_.end(), vols_.begin());
-        else {
-            QL_FAIL("Invalid method " << (int)method);
-        }
-    }
-
     BlackVolatilitySurfaceDelta::BlackVolatilitySurfaceDelta(
         Date referenceDate, const std::vector<Date>& dates, const std::vector<Real>& putDeltas,
         const std::vector<Real>& callDeltas, bool hasAtm, const Matrix& blackVolMatrix, const DayCounter& dayCounter,
@@ -97,8 +37,7 @@ namespace QuantLib {
         const Handle<YieldTermStructure>& foreignTS, DeltaVolQuote::DeltaType dt, DeltaVolQuote::AtmType at,
         ext::optional<DeltaVolQuote::DeltaType> atmDeltaType, const Period& switchTenor, DeltaVolQuote::DeltaType ltdt,
         DeltaVolQuote::AtmType ltat, ext::optional<DeltaVolQuote::DeltaType> longTermAtmDeltaType,
-        InterpolatedFxSmileSection::InterpolationMethod im, bool flatStrikeExtrapolation,
-        BlackVolTimeExtrapolation timeExtrapolation)
+        SmileInterpolationMethod im, bool flatStrikeExtrapolation, BlackVolTimeExtrapolation timeExtrapolation)
         : BlackVolatilityTermStructure(referenceDate, cal, Following, dayCounter), dates_(dates), times_(dates.size(), 0),
         putDeltas_(putDeltas), callDeltas_(callDeltas), hasAtm_(hasAtm), spot_(spot), domesticTS_(domesticTS),
         foreignTS_(foreignTS), dt_(dt), at_(at), atmDeltaType_(atmDeltaType), switchTenor_(switchTenor), ltdt_(ltdt),
@@ -154,11 +93,12 @@ namespace QuantLib {
         registerWith(foreignTS_);
     }
 
-    ext::shared_ptr<FxSmileSection> BlackVolatilitySurfaceDelta::blackVolSmile(Time t) const {
+    ext::shared_ptr<SmileSection> BlackVolatilitySurfaceDelta::blackVolSmile(Time t) const {
 
         Real spot = spot_->value();
         DiscountFactor dDiscount = domesticTS_->discount(t);
         DiscountFactor fDiscount = foreignTS_->discount(t);
+        Real sqrtT = sqrt(t);
 
         DeltaVolQuote::AtmType at;
         DeltaVolQuote::DeltaType dt;
@@ -176,15 +116,17 @@ namespace QuantLib {
         // Store smile section in map. Use strikes as key and vols as values for automatic sorting by strike.
         // If we have already have a strike from a previous delta, we do not overwrite it.
         auto comp = [](Real a, Real b) { return !close(a, b) && a < b; };
-        map<Real, Real, decltype(comp)> smileSection(comp);
+        map<Real, Real, decltype(comp)> smileSections(comp);
         Size i = 0;
+        Real atmLevel = 1.0; // set atmLevel to 1.0 in case hasAtm_ is false
+
         for (Real delta : putDeltas_) {
             Real vol = interpolators_.at(i)->blackVol(t, 1, true);
             try {
-                BlackDeltaCalculator bdc(Option::Put, dt, spot, dDiscount, fDiscount, vol * sqrt(t));
+                BlackDeltaCalculator bdc(Option::Put, dt, spot, dDiscount, fDiscount, vol * sqrtT);
                 Real strike = bdc.strikeFromDelta(delta);
-                if (smileSection.count(strike) == 0)
-                    smileSection[strike] = vol;
+                if (smileSections.count(strike) == 0)
+                    smileSections[strike] = vol;
             } catch (const std::exception& e) {
                 QL_FAIL("BlackVolatilitySurfaceDelta: Error during calculating put strike at delta " << delta << ": "
                                                                                                     << e.what());
@@ -193,11 +135,12 @@ namespace QuantLib {
         }
         if (hasAtm_) {
             Real vol = interpolators_.at(i)->blackVol(t, 1, true);
+            atmLevel = vol;
             try {
-                BlackDeltaCalculator bdc(Option::Put, atmDt, spot, dDiscount, fDiscount, vol * sqrt(t));
+                BlackDeltaCalculator bdc(Option::Put, atmDt, spot, dDiscount, fDiscount, vol * sqrtT);
                 Real strike = bdc.atmStrike(at);
-                if (smileSection.count(strike) == 0)
-                    smileSection[strike] = vol;
+                if (smileSections.count(strike) == 0)
+                    smileSections[strike] = vol;
             } catch (const std::exception& e) {
                 QL_FAIL("BlackVolatilitySurfaceDelta: Error during calculating atm strike: " << e.what());
             }
@@ -206,10 +149,10 @@ namespace QuantLib {
         for (Real delta : callDeltas_) {
             Real vol = interpolators_.at(i)->blackVol(t, 1, true);
             try {
-                BlackDeltaCalculator bdc(Option::Call, dt, spot, dDiscount, fDiscount, vol * sqrt(t));
+                BlackDeltaCalculator bdc(Option::Call, dt, spot, dDiscount, fDiscount, vol * sqrtT);
                 Real strike = bdc.strikeFromDelta(delta);
-                if (smileSection.count(strike) == 0)
-                    smileSection[strike] = vol;
+                if (smileSections.count(strike) == 0)
+                    smileSections[strike] = vol;
             } catch (const std::exception& e) {
                 QL_FAIL("BlackVolatilitySurfaceDelta: Error during calculating call strike at delta " << delta << ": "
                                                                                                     << e.what());
@@ -219,28 +162,42 @@ namespace QuantLib {
 
         // sort and extract to vectors
         vector<Real> strikes;
-        strikes.reserve(smileSection.size());
-        vector<Real> vols;
-        vols.reserve(smileSection.size());
-        for (const auto& kv : smileSection) {
+        strikes.reserve(smileSections.size());
+        vector<Real> stdDevs;
+        stdDevs.reserve(smileSections.size());
+        for (const auto& kv : smileSections) {
             strikes.push_back(kv.first);
-            vols.push_back(kv.second);
+            stdDevs.push_back(kv.second * sqrtT);
         }
 
         // now build smile from strikes and vols
-        QL_REQUIRE(!vols.empty(),
+        QL_REQUIRE(!stdDevs.empty(),
                 "BlackVolatilitySurfaceDelta::blackVolSmile(" << t << "): no strikes given, this is unexpected.");
-        if (vols.size() == 1) {
+        if (stdDevs.size() == 1) {
             // handle the situation that we only have one strike (might occur for e.g. t=0)
-            return ext::make_shared<ConstantFxSmileSection>(vols.front());
+            return ext::make_shared<FlatSmileSection>(t, stdDevs.front() / sqrtT, dayCounter());
         } else {
             // we have at least two strikes
-            return ext::make_shared<InterpolatedFxSmileSection>(spot, dDiscount, fDiscount, t, strikes, vols,
-                                                                        interpolationMethod_, flatStrikeExtrapolation_);
+            if (interpolationMethod_ == SmileInterpolationMethod::Linear)
+                return ext::make_shared<InterpolatedSmileSection<Linear>>(t, strikes, stdDevs, atmLevel);
+            else if (interpolationMethod_ == SmileInterpolationMethod::NaturalCubic)
+                return ext::make_shared<InterpolatedSmileSection<Cubic>>(t, strikes, stdDevs, atmLevel, Cubic(CubicInterpolation::Kruger));
+            else if (interpolationMethod_ == SmileInterpolationMethod::FinancialCubic)
+                return ext::make_shared<InterpolatedSmileSection<Cubic>>(t, 
+                        strikes, 
+                        stdDevs, 
+                        atmLevel, 
+                        Cubic(CubicInterpolation::Kruger, true, CubicInterpolation::SecondDerivative, 0.0,
+                                    CubicInterpolation::FirstDerivative));
+            else if (interpolationMethod_ == SmileInterpolationMethod::CubicSpline)
+                return ext::make_shared<InterpolatedSmileSection<Cubic>>(t, strikes, stdDevs, atmLevel, Cubic(CubicInterpolation::Spline));
+            else {
+                QL_FAIL("Invalid method " << (int)interpolationMethod_);
+            }
         }
     }
 
-    ext::shared_ptr<FxSmileSection> BlackVolatilitySurfaceDelta::blackVolSmile(const Date& d) const {
+    ext::shared_ptr<SmileSection> BlackVolatilitySurfaceDelta::blackVolSmile(const Date& d) const {
         return blackVolSmile(timeFromReference(d));
     }
 
diff --git a/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp b/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp
index 2a672517421..547d1de420c 100644
--- a/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp
+++ b/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp
@@ -33,68 +33,17 @@
 #include <ql/termstructures/yieldtermstructure.hpp>
 #include <ql/time/calendar.hpp>
 #include <ql/time/daycounter.hpp>
-#include <ql/termstructures/volatility/equityfx/fxsmilesection.hpp>
+#include <ql/termstructures/volatility/smilesection.hpp>
 
 namespace QuantLib {
 
-    class InterpolatedFxSmileSection : public FxSmileSection, 
-                                       public LazyObject {
-    public:
-        //! Supported interpolation methods
-        enum class InterpolationMethod { Linear, NaturalCubic, FinancialCubic, CubicSpline };
-
-        //! ctor
-        InterpolatedFxSmileSection(Real spot, Real rd, Real rf, Time t, const std::vector<Real>& strikes,
-                                const std::vector<Volatility>& vols, InterpolationMethod method,
-                                bool flatExtrapolation = false);
-        
-        InterpolatedFxSmileSection(Real spot, Real rd, Real rf, Time t, const std::vector<Real>& strikes,
-                                const std::vector<Handle<Quote>>& volsHandles, InterpolationMethod method,
-                                bool flatExtrapolation = false);
-
-        Volatility volatility(Real strike) const override;
-
-
-        void performCalculations() const override;
-        void update() override;
-        //! \name Inspectors
-        //@{
-        const std::vector<Real>& strikes() const { return strikes_; }
-        const std::vector<Volatility>& volatilities() const {
-            return vols_;
-         }
-        //@}
-
-    private:
-        void initializeInterpolator(InterpolationMethod method) const;
-
-        mutable Interpolation interpolator_;
-        std::vector<Real> strikes_;
-        mutable std::vector<Volatility> vols_;
-        std::vector<Handle<Quote>> volHandles_;
-        bool flatExtrapolation_;
-    };
-
-    class ConstantFxSmileSection : public FxSmileSection {
-    public:
-        //! ctor
-        ConstantFxSmileSection(const Volatility vol) : vol_(vol) {}
-
-        Volatility volatility(Real strike) const override { return vol_; }
-
-        //! \name Inspectors
-        //@{
-        const Volatility volatility() const { return vol_; }
-        //@}
-
-    private:
-        Volatility vol_;
-    };
-
     //! Abstract Black volatility surface based on delta
     //!  \ingroup termstructures
     class BlackVolatilitySurfaceDelta : public BlackVolatilityTermStructure {
     public:
+        //! Supported interpolation methods for the smile sections
+        enum class SmileInterpolationMethod { Linear, NaturalCubic, FinancialCubic, CubicSpline };
+
         BlackVolatilitySurfaceDelta(Date referenceDate, const std::vector<Date>& dates, const std::vector<Real>& putDeltas,
                                     const std::vector<Real>& callDeltas, bool hasAtm, const Matrix& blackVolMatrix,
                                     const DayCounter& dayCounter, const Calendar& cal, const Handle<Quote>& spot,
@@ -107,8 +56,8 @@ namespace QuantLib {
                                     DeltaVolQuote::DeltaType ltdt = DeltaVolQuote::DeltaType::Fwd,
                                     DeltaVolQuote::AtmType ltat = DeltaVolQuote::AtmType::AtmDeltaNeutral,
                                     ext::optional<DeltaVolQuote::DeltaType> longTermAtmDeltaType = ext::nullopt,
-                                    InterpolatedFxSmileSection::InterpolationMethod interpolationMethod =
-                                        InterpolatedFxSmileSection::InterpolationMethod::Linear,
+                                    SmileInterpolationMethod interpolationMethod =
+                                        SmileInterpolationMethod::Linear,
                                     bool flatStrikeExtrapolation = true,
                                     BlackVolTimeExtrapolation timeExtrapolation =
                                         BlackVolTimeExtrapolation::FlatVolatility);
@@ -138,9 +87,9 @@ namespace QuantLib {
         *
         *  This is not really FX specific
         */
-        ext::shared_ptr<FxSmileSection> blackVolSmile(Time t) const;
+        ext::shared_ptr<SmileSection> blackVolSmile(Time t) const;
 
-        ext::shared_ptr<FxSmileSection> blackVolSmile(const Date& d) const;
+        ext::shared_ptr<SmileSection> blackVolSmile(const Date& d) const;
 
     protected:
         virtual Volatility blackVolImpl(Time t, Real strike) const override;
@@ -166,7 +115,7 @@ namespace QuantLib {
         DeltaVolQuote::AtmType ltat_;
         ext::optional<DeltaVolQuote::DeltaType> longTermAtmDeltaType_;
 
-        InterpolatedFxSmileSection::InterpolationMethod interpolationMethod_;
+        SmileInterpolationMethod interpolationMethod_;
         bool flatStrikeExtrapolation_;
         BlackVolTimeExtrapolation timeExtrapolation_;
         Real switchTime_;
diff --git a/ql/termstructures/volatility/equityfx/fxsmilesection.hpp b/ql/termstructures/volatility/equityfx/fxsmilesection.hpp
deleted file mode 100644
index a6bf508cc15..00000000000
--- a/ql/termstructures/volatility/equityfx/fxsmilesection.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- Copyright (C) 2017 Quaternion Risk Management Ltd
- All rights reserved.
-
- This file is part of ORE, a free-software/open-source library
- for transparent pricing and risk analysis - http://opensourcerisk.org
-
- ORE is free software: you can redistribute it and/or modify it
- under the terms of the Modified BSD License.  You should have received a
- copy of the license along with this program.
- The license is also available online at <http://opensourcerisk.org>
-
- This program is distributed on the basis that it will form a useful
- contribution to risk analytics and model standardisation, but WITHOUT
- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- FITNESS FOR A PARTICULAR PURPOSE. See the license for more details.
-*/
-
-/*! \file fxsmilesection.hpp
-    \brief FX smile section assuming a strike/volatility space
-    \ingroup termstructures
-*/
-
-#ifndef quantlib_fx_smile_section_hpp
-#define quantlib_fx_smile_section_hpp
-
-#include <ql/types.hpp>
-
-namespace QuantLib {
-
-    //! FX SmileSection
-    //! \ingroup termstructures
-    class FxSmileSection {
-    public:
-        FxSmileSection() : spot_(0.0), rd_(0.0), rf_(0.0), expiryTime_(0.0) {}
-        FxSmileSection(Real spot, Real rd, Real rf, Time t) : spot_(spot), rd_(rd), rf_(rf), expiryTime_(t) {}
-        virtual ~FxSmileSection(){};
-
-        virtual Volatility volatility(Real strike) const = 0;
-
-        Time expiryTime() const { return expiryTime_; }
-
-        DiscountFactor domesticDiscount() const { return std::exp(-rd_ * expiryTime()); }
-        DiscountFactor foreignDiscount() const { return std::exp(-rf_ * expiryTime()); }
-
-    protected:
-        Real spot_;
-        Real rd_;
-        Real rf_;
-        Time expiryTime_;
-    };
-
-}
-
-#endif
diff --git a/test-suite/blackvolsurfacedelta.cpp b/test-suite/blackvolsurfacedelta.cpp
index aea99d6d067..b93079fe341 100644
--- a/test-suite/blackvolsurfacedelta.cpp
+++ b/test-suite/blackvolsurfacedelta.cpp
@@ -34,71 +34,6 @@ BOOST_FIXTURE_TEST_SUITE(QuantLibTests, TopLevelFixture)
 
 BOOST_AUTO_TEST_SUITE(BlackVolSurfaceDeltaTest)
 
-BOOST_AUTO_TEST_CASE(testInterpolatedFxSmileSectionConstruction) {
-
-    BOOST_TEST_MESSAGE("Testing InterpolatedFxSmileSection...");
-    // Set up the parameters with some arbitrary data
-    Real spot = 100;
-    Real rd = 0.05;
-    Real rf = 0.03;
-    Time t = 1.0;
-    vector<Real> strikes = { 90, 100, 110 };
-    vector<Volatility> vols = { 0.15, 0.1, 0.15 };
-    vector<InterpolatedFxSmileSection::InterpolationMethod> methods = {
-        InterpolatedFxSmileSection::InterpolationMethod::Linear,
-        InterpolatedFxSmileSection::InterpolationMethod::FinancialCubic,
-        InterpolatedFxSmileSection::InterpolationMethod::NaturalCubic,
-        InterpolatedFxSmileSection::InterpolationMethod::CubicSpline
-    };
-
-    // Construct the smile section
-    ext::shared_ptr<InterpolatedFxSmileSection> section;
-    for (auto method : methods) {
-        BOOST_TEST_MESSAGE("Trying to construct InterpolatedFxSmileSection with interpolation method: " << Integer(method) << ".");
-        BOOST_CHECK_NO_THROW(section =
-                                ext::make_shared<InterpolatedFxSmileSection>(spot, rd, rf, t, strikes, vols, method));
-        BOOST_CHECK_EQUAL(section->volatility(strikes.at(1)), vols.at(1));
-    }
-}
-
-BOOST_AUTO_TEST_CASE(testInterpolatedFxSmileSectionConstructionWithHandles) {
-
-    BOOST_TEST_MESSAGE("Testing InterpolatedFxSmileSection using Handles...");
-    // Set up the parameters with some arbitrary data
-    Real spot = 100;
-    Real rd = 0.05;
-    Real rf = 0.03;
-    Time t = 1.0;
-
-    auto vol90 = ext::shared_ptr<SimpleQuote>(new SimpleQuote(0.15));
-    auto vol100 = ext::shared_ptr<SimpleQuote>(new SimpleQuote(0.1));
-    auto vol110 = ext::shared_ptr<SimpleQuote>(new SimpleQuote(0.13));
-    auto vol90Handle = Handle<Quote>(vol90);
-    auto vol100Handle = Handle<Quote>(vol100);
-    auto vol110Handle = Handle<Quote>(vol110);
-
-    vector<Real> strikes = { 90, 100, 110 };
-    vector<Handle<Quote>> vols = {
-        vol90Handle, 
-        vol100Handle, 
-        vol110Handle 
-    };
-
-    auto method = InterpolatedFxSmileSection::InterpolationMethod::CubicSpline;
-    auto section = ext::make_shared<InterpolatedFxSmileSection>(spot, rd, rf, t, strikes, vols, method);
-    
-    Real strikeToTest = 95.0;
-    Real expectedVol95 = 0.11749999999;
-
-    BOOST_CHECK_CLOSE(section->volatility(strikeToTest), expectedVol95, 1e-8);
-
-    // Test the updated interpolation after the update of a quote
-    vol90->setValue(0.13);
-    Real expectedVol95AfterMove = 0.109375;
-
-    BOOST_CHECK_CLOSE(section->volatility(strikeToTest), expectedVol95AfterMove, 1e-8);
-}
-
 BOOST_AUTO_TEST_CASE(testBlackVolSurfaceDeltaConstantVol) {
 
     BOOST_TEST_MESSAGE("Testing BlackVolatilitySurfaceDelta...");

From 94f4762f161fc5c3142c647235d5e3599041070d Mon Sep 17 00:00:00 2001
From: paolodelia99 <paolo.delia99@gmail.com>
Date: Wed, 5 Nov 2025 15:33:25 +0100
Subject: [PATCH 06/11] renaming vars, added docs string for the
 blackvolsurfacedelta

---
 .../equityfx/blackvolsurfacedelta.cpp         |  41 +++----
 .../equityfx/blackvolsurfacedelta.hpp         | 104 +++++++++++++++---
 test-suite/blackvolsurfacedelta.cpp           |  25 ++++-
 3 files changed, 129 insertions(+), 41 deletions(-)

diff --git a/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.cpp b/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.cpp
index 3dc693f73a7..019633886e7 100644
--- a/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.cpp
+++ b/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.cpp
@@ -1,20 +1,21 @@
 /*
  Copyright (C) 2019 Quaternion Risk Management Ltd
  Copyright (C) 2022 Skandinaviska Enskilda Banken AB (publ)
+ Copyright (C) 2025 Paolo D'Elia
  All rights reserved.
 
- This file is part of ORE, a free-software/open-source library
- for transparent pricing and risk analysis - http://opensourcerisk.org
+ This file is part of QuantLib, a free-software/open-source library
+ for financial quantitative analysts and developers - http://quantlib.org/
 
- ORE is free software: you can redistribute it and/or modify it
- under the terms of the Modified BSD License.  You should have received a
- copy of the license along with this program.
- The license is also available online at <http://opensourcerisk.org>
+ QuantLib is free software: you can redistribute it and/or modify it
+ under the terms of the QuantLib license.  You should have received a
+ copy of the license along with this program; if not, please email
+ <quantlib-dev@lists.sf.net>. The license is also available online at
+ <https://www.quantlib.org/license.shtml>.
 
- This program is distributed on the basis that it will form a useful
- contribution to risk analytics and model standardisation, but WITHOUT
- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- FITNESS FOR A PARTICULAR PURPOSE. See the license for more details.
+ This program is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ FOR A PARTICULAR PURPOSE.  See the license for more details.
 */
 
 #include <ql/errors.hpp>
@@ -116,7 +117,7 @@ namespace QuantLib {
         // Store smile section in map. Use strikes as key and vols as values for automatic sorting by strike.
         // If we have already have a strike from a previous delta, we do not overwrite it.
         auto comp = [](Real a, Real b) { return !close(a, b) && a < b; };
-        map<Real, Real, decltype(comp)> smileSections(comp);
+        map<Real, Real, decltype(comp)> smileSection(comp);
         Size i = 0;
         Real atmLevel = 1.0; // set atmLevel to 1.0 in case hasAtm_ is false
 
@@ -125,8 +126,8 @@ namespace QuantLib {
             try {
                 BlackDeltaCalculator bdc(Option::Put, dt, spot, dDiscount, fDiscount, vol * sqrtT);
                 Real strike = bdc.strikeFromDelta(delta);
-                if (smileSections.count(strike) == 0)
-                    smileSections[strike] = vol;
+                if (smileSection.count(strike) == 0)
+                    smileSection[strike] = vol;
             } catch (const std::exception& e) {
                 QL_FAIL("BlackVolatilitySurfaceDelta: Error during calculating put strike at delta " << delta << ": "
                                                                                                     << e.what());
@@ -139,8 +140,8 @@ namespace QuantLib {
             try {
                 BlackDeltaCalculator bdc(Option::Put, atmDt, spot, dDiscount, fDiscount, vol * sqrtT);
                 Real strike = bdc.atmStrike(at);
-                if (smileSections.count(strike) == 0)
-                    smileSections[strike] = vol;
+                if (smileSection.count(strike) == 0)
+                    smileSection[strike] = vol;
             } catch (const std::exception& e) {
                 QL_FAIL("BlackVolatilitySurfaceDelta: Error during calculating atm strike: " << e.what());
             }
@@ -151,8 +152,8 @@ namespace QuantLib {
             try {
                 BlackDeltaCalculator bdc(Option::Call, dt, spot, dDiscount, fDiscount, vol * sqrtT);
                 Real strike = bdc.strikeFromDelta(delta);
-                if (smileSections.count(strike) == 0)
-                    smileSections[strike] = vol;
+                if (smileSection.count(strike) == 0)
+                    smileSection[strike] = vol;
             } catch (const std::exception& e) {
                 QL_FAIL("BlackVolatilitySurfaceDelta: Error during calculating call strike at delta " << delta << ": "
                                                                                                     << e.what());
@@ -162,10 +163,10 @@ namespace QuantLib {
 
         // sort and extract to vectors
         vector<Real> strikes;
-        strikes.reserve(smileSections.size());
+        strikes.reserve(smileSection.size());
         vector<Real> stdDevs;
-        stdDevs.reserve(smileSections.size());
-        for (const auto& kv : smileSections) {
+        stdDevs.reserve(smileSection.size());
+        for (const auto& kv : smileSection) {
             strikes.push_back(kv.first);
             stdDevs.push_back(kv.second * sqrtT);
         }
diff --git a/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp b/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp
index 547d1de420c..50db2fa4bf1 100644
--- a/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp
+++ b/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp
@@ -1,20 +1,21 @@
 /*
  Copyright (C) 2019 Quaternion Risk Management Ltd
  Copyright (C) 2022 Skandinaviska Enskilda Banken AB (publ)
+ Copyright (C) 2025 Paolo D'Elia
  All rights reserved.
 
- This file is part of ORE, a free-software/open-source library
- for transparent pricing and risk analysis - http://opensourcerisk.org
+ This file is part of QuantLib, a free-software/open-source library
+ for financial quantitative analysts and developers - http://quantlib.org/
 
- ORE is free software: you can redistribute it and/or modify it
- under the terms of the Modified BSD License.  You should have received a
- copy of the license along with this program.
- The license is also available online at <http://opensourcerisk.org>
+ QuantLib is free software: you can redistribute it and/or modify it
+ under the terms of the QuantLib license.  You should have received a
+ copy of the license along with this program; if not, please email
+ <quantlib-dev@lists.sf.net>. The license is also available online at
+ <https://www.quantlib.org/license.shtml>.
 
- This program is distributed on the basis that it will form a useful
- contribution to risk analytics and model standardisation, but WITHOUT
- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- FITNESS FOR A PARTICULAR PURPOSE. See the license for more details.
+ This program is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ FOR A PARTICULAR PURPOSE.  See the license for more details.
 */
 
 /*! \file blackvolsurfacedelta.hpp
@@ -37,13 +38,54 @@
 
 namespace QuantLib {
 
-    //! Abstract Black volatility surface based on delta
-    //!  \ingroup termstructures
+    /*! \brief Black volatility surface parameterized by market deltas
+        \ingroup termstructures
+
+        BlackVolatilitySurfaceDelta represents a Black volatility term
+        structure where market quotes are expressed as delta-based points
+        (put deltas, call deltas and optionally an ATM quote) for a set of
+        option expiries.  The surface converts the provided deltas to strikes
+        (using spot and domestic/foreign yield curves and the configured
+        delta/ATM conventions) and builds per-expiry smile sections by
+        interpolating/extrapolating the input volatility matrix.
+
+        Use-cases:
+        - Building FX/equity volatility surfaces from market delta quotes.
+        - Creating per-expiry SmileSections for pricing and risk calculations.
+    */
     class BlackVolatilitySurfaceDelta : public BlackVolatilityTermStructure {
     public:
         //! Supported interpolation methods for the smile sections
         enum class SmileInterpolationMethod { Linear, NaturalCubic, FinancialCubic, CubicSpline };
-
+        
+        //! \name Constructors
+        //@{
+        /*! \brief Construct a delta-parametrized Black vol surface
+            \param referenceDate    reference date for the term structure (valuation date)
+            \param dates            vector of option expiry dates (must be increasing)
+            \param putDeltas        vector of put-side deltas corresponding to matrix columns
+            \param callDeltas       vector of call-side deltas corresponding to matrix columns
+            \param hasAtm           true if an ATM column is present in the vol matrix
+            \param blackVolMatrix   matrix of Black volatilities (rows = expiries,
+                                    columns = deltas/ATM). Rows must match `dates`.
+            \param dayCounter       day-count convention used to convert dates to times
+            \param cal              calendar used for date adjustments where needed
+            \param spot             handle to spot quote (used for delta->strike conversion)
+            \param domesticTS       handle to domestic yield curve (discounting / forward)
+            \param foreignTS        handle to foreign yield curve (for FX forward)
+            \param dt               delta convention (Spot or Fwd, premium-adjusted, ...)
+            \param at               ATM convention used when extracting/constructing ATM quote
+            \param atmDeltaType     optional override delta-type for ATM computation
+            \param switchTenor      tenor after which long-term delta/ATM conventions apply
+            \param ltdt             long-term delta type (used for expiries beyond switchTenor)
+            \param ltat             long-term ATM convention (used beyond switchTenor)
+            \param longTermAtmDeltaType optional override for long-term ATM delta-type
+            \param interpolationMethod interpolation used to build SmileSection for each expiry
+                                       can be choosen across the following interpolation methods:
+                                       Linear, NaturalCubic, FinancialCubic, CubicSpline
+            \param flatStrikeExtrapolation enable flat-vol extrapolation in strike dimension
+            \param timeExtrapolation policy for extrapolating/interpolating in time
+        */
         BlackVolatilitySurfaceDelta(Date referenceDate, const std::vector<Date>& dates, const std::vector<Real>& putDeltas,
                                     const std::vector<Real>& callDeltas, bool hasAtm, const Matrix& blackVolMatrix,
                                     const DayCounter& dayCounter, const Calendar& cal, const Handle<Quote>& spot,
@@ -61,6 +103,7 @@ namespace QuantLib {
                                     bool flatStrikeExtrapolation = true,
                                     BlackVolTimeExtrapolation timeExtrapolation =
                                         BlackVolTimeExtrapolation::FlatVolatility);
+        //@}
 
         //! \name TermStructure interface
         //@{
@@ -82,13 +125,40 @@ namespace QuantLib {
         //@}
 
         //! Return an FxSmile for the time t
-        /*! Note the smile does not observe the spot or YTS handles, it will
-        *  not update when they change.
-        *
-        *  This is not really FX specific
+        /*!
+          \brief Build and return a SmileSection representing the Black vol smile
+                 at time t (year fraction from the reference date).
+
+          The returned SmileSection provides volatilities as a function of strike
+          for the requested expiry time. The SmileSection is constructed from
+          the underlying delta-based surface data and the interpolation method
+          configured for this surface.
+
+          \note The produced SmileSection does not hold live references to the
+                spot or yield-term-structure handles used to construct the
+                BlackVolatilitySurfaceDelta. As a consequence, the SmileSection
+                will not update if those handles change; callers that require
+                automatic updates should recreate the SmileSection.
+
+          \param t  time to expiry expressed as a year fraction from the reference date
+          \return    a shared_ptr to a SmileSection describing the Black vol smile at time t
+
+          \throws Error if t is out of the supported time range and extrapolation
+                 is disabled.
         */
         ext::shared_ptr<SmileSection> blackVolSmile(Time t) const;
 
+        //! Return an FxSmile for Date d
+        /*!
+          \brief Convenience overload that resolves a calendar Date to time and
+                 returns the corresponding SmileSection.
+
+          \param d  expiry date
+          \return   a shared_ptr to a SmileSection describing the Black vol smile at date d
+
+          \throws Error if the date cannot be converted to a valid time-to-expiry
+                 or if the resulting time is out of range and extrapolation is disabled.
+        */
         ext::shared_ptr<SmileSection> blackVolSmile(const Date& d) const;
 
     protected:
diff --git a/test-suite/blackvolsurfacedelta.cpp b/test-suite/blackvolsurfacedelta.cpp
index b93079fe341..8351bd87b01 100644
--- a/test-suite/blackvolsurfacedelta.cpp
+++ b/test-suite/blackvolsurfacedelta.cpp
@@ -84,7 +84,7 @@ BOOST_AUTO_TEST_CASE(testBlackVolSurfaceDeltaNonConstantVol) {
     Date refDate(1, Jan, 2010);
     Settings::instance().evaluationDate() = refDate;
 
-    // Setup a 2x2
+    // Setup a 4x3
     vector<Date> dates = { 
         refDate + Period(1, Months), 
         refDate + Period(6, Months),
@@ -112,11 +112,28 @@ BOOST_AUTO_TEST_CASE(testBlackVolSurfaceDeltaNonConstantVol) {
     BlackVolatilitySurfaceDelta surface(refDate, dates, putDeltas, callDeltas, hasAtm, blackVolMatrix, ActualActual(ActualActual::ISDA),
                                         TARGET(), spot, dts, fts);
 
-    // ask for volatility at lots of points, should be constVol at every point
-    // make sure we ask for vols outside 25D and 2Y
+    // Testing ATM strike
+    Real atmStrike = 1.18;
+
+    // ask for volatility at 1M (present in the matrix)
     auto smile1M = surface.blackVolSmile(refDate + Period(1, Months));
-    BOOST_CHECK_CLOSE(smile1M->volatility(1.18), 0.13010360399, 1e-8);
+    BOOST_CHECK_CLOSE(smile1M->volatility(atmStrike), 0.13010360399, 1e-8);
     
+    // ask for volatility at 15D (using time extrapolation) should be the same as the 1M
+    auto smile15D = surface.blackVolSmile(refDate + Period(15, Days));
+    BOOST_CHECK_CLOSE(smile15D->volatility(atmStrike), 0.13007226607, 1e-8);
+
+    // ask for volatility at 3M (using time extrapolation)
+    auto smile3M = surface.blackVolSmile(refDate + Period(3, Months));
+    BOOST_CHECK_CLOSE(smile3M->volatility(atmStrike), 0.115077252583, 1e-8);
+
+    // ask for volatility at 6M for "extreme" strikes (using strike extrapolation)
+    Real lowStrike = 1.10;
+    Real highStrike = 1.30;
+
+    auto smile6M = surface.blackVolSmile(refDate + Period(6, Months));
+    BOOST_CHECK_CLOSE(smile6M->volatility(lowStrike), 0.1411379628132, 1e-8);
+    BOOST_CHECK_CLOSE(smile6M->volatility(highStrike), 0.136291154962, 1e-8);
 }
 
 BOOST_AUTO_TEST_SUITE_END()

From 3e61f8d8edfc9820be2d979ac331161328a00a91 Mon Sep 17 00:00:00 2001
From: paolodelia99 <paolo.delia99@gmail.com>
Date: Wed, 5 Nov 2025 17:33:00 +0100
Subject: [PATCH 07/11] set flatStrikeExtrapolation to false, add checkStrike
 sanity check in iterpolateSmileSection

---
 .../equityfx/blackvolsurfacedelta.cpp         | 17 +++-
 .../equityfx/blackvolsurfacedelta.hpp         |  3 +-
 .../volatility/interpolatedsmilesection.hpp   | 97 +++++++++++++++----
 3 files changed, 94 insertions(+), 23 deletions(-)

diff --git a/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.cpp b/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.cpp
index 019633886e7..57d52b3782b 100644
--- a/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.cpp
+++ b/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.cpp
@@ -180,18 +180,27 @@ namespace QuantLib {
         } else {
             // we have at least two strikes
             if (interpolationMethod_ == SmileInterpolationMethod::Linear)
-                return ext::make_shared<InterpolatedSmileSection<Linear>>(t, strikes, stdDevs, atmLevel);
+                return ext::make_shared<InterpolatedSmileSection<Linear>>(t, strikes, stdDevs, atmLevel, Linear(), dayCounter(), 
+                                                                          VolatilityType::ShiftedLognormal, 0.0, flatStrikeExtrapolation_);
             else if (interpolationMethod_ == SmileInterpolationMethod::NaturalCubic)
-                return ext::make_shared<InterpolatedSmileSection<Cubic>>(t, strikes, stdDevs, atmLevel, Cubic(CubicInterpolation::Kruger));
+                return ext::make_shared<InterpolatedSmileSection<Cubic>>(t, strikes, stdDevs, atmLevel, Cubic(CubicInterpolation::Kruger), 
+                                                                         dayCounter(), VolatilityType::ShiftedLognormal, 0.0, 
+                                                                         flatStrikeExtrapolation_);
             else if (interpolationMethod_ == SmileInterpolationMethod::FinancialCubic)
                 return ext::make_shared<InterpolatedSmileSection<Cubic>>(t, 
                         strikes, 
                         stdDevs, 
                         atmLevel, 
                         Cubic(CubicInterpolation::Kruger, true, CubicInterpolation::SecondDerivative, 0.0,
-                                    CubicInterpolation::FirstDerivative));
+                                    CubicInterpolation::FirstDerivative),
+                        dayCounter(),
+                        VolatilityType::ShiftedLognormal, 
+                        0.0, 
+                        flatStrikeExtrapolation_);
             else if (interpolationMethod_ == SmileInterpolationMethod::CubicSpline)
-                return ext::make_shared<InterpolatedSmileSection<Cubic>>(t, strikes, stdDevs, atmLevel, Cubic(CubicInterpolation::Spline));
+                return ext::make_shared<InterpolatedSmileSection<Cubic>>(t, strikes, stdDevs, atmLevel, Cubic(CubicInterpolation::Spline),
+                                                                         dayCounter(), VolatilityType::ShiftedLognormal, 0.0, 
+                                                                         flatStrikeExtrapolation_);
             else {
                 QL_FAIL("Invalid method " << (int)interpolationMethod_);
             }
diff --git a/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp b/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp
index 50db2fa4bf1..bf101095681 100644
--- a/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp
+++ b/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp
@@ -39,7 +39,6 @@
 namespace QuantLib {
 
     /*! \brief Black volatility surface parameterized by market deltas
-        \ingroup termstructures
 
         BlackVolatilitySurfaceDelta represents a Black volatility term
         structure where market quotes are expressed as delta-based points
@@ -100,7 +99,7 @@ namespace QuantLib {
                                     ext::optional<DeltaVolQuote::DeltaType> longTermAtmDeltaType = ext::nullopt,
                                     SmileInterpolationMethod interpolationMethod =
                                         SmileInterpolationMethod::Linear,
-                                    bool flatStrikeExtrapolation = true,
+                                    bool flatStrikeExtrapolation = false,
                                     BlackVolTimeExtrapolation timeExtrapolation =
                                         BlackVolTimeExtrapolation::FlatVolatility);
         //@}
diff --git a/ql/termstructures/volatility/interpolatedsmilesection.hpp b/ql/termstructures/volatility/interpolatedsmilesection.hpp
index 01e39caefa2..9f47d27704a 100644
--- a/ql/termstructures/volatility/interpolatedsmilesection.hpp
+++ b/ql/termstructures/volatility/interpolatedsmilesection.hpp
@@ -47,7 +47,8 @@ namespace QuantLib {
                                  const Interpolator& interpolator = Interpolator(),
                                  const DayCounter& dc = Actual365Fixed(),
                                  VolatilityType type = ShiftedLognormal,
-                                 Real shift = 0.0);
+                                 Real shift = 0.0,
+                                 bool flatStrikeExtrapolation = false);
         InterpolatedSmileSection(Time expiryTime,
                                  std::vector<Rate> strikes,
                                  const std::vector<Real>& stdDevs,
@@ -55,7 +56,8 @@ namespace QuantLib {
                                  const Interpolator& interpolator = Interpolator(),
                                  const DayCounter& dc = Actual365Fixed(),
                                  VolatilityType type = ShiftedLognormal,
-                                 Real shift = 0.0);
+                                 Real shift = 0.0,
+                                 bool flatStrikeExtrapolation = false);
         InterpolatedSmileSection(const Date& d,
                                  std::vector<Rate> strikes,
                                  const std::vector<Handle<Quote> >& stdDevHandles,
@@ -64,7 +66,8 @@ namespace QuantLib {
                                  const Interpolator& interpolator = Interpolator(),
                                  const Date& referenceDate = Date(),
                                  VolatilityType type = ShiftedLognormal,
-                                 Real shift = 0.0);
+                                 Real shift = 0.0,
+                                 bool flatStrikeExtrapolation = false);
         InterpolatedSmileSection(const Date& d,
                                  std::vector<Rate> strikes,
                                  const std::vector<Real>& stdDevs,
@@ -73,7 +76,8 @@ namespace QuantLib {
                                  const Interpolator& interpolator = Interpolator(),
                                  const Date& referenceDate = Date(),
                                  VolatilityType type = ShiftedLognormal,
-                                 Real shift = 0.0);
+                                 Real shift = 0.0,
+                                 bool flatStrikeExtrapolation = false);
 
         void performCalculations() const override;
         Real varianceImpl(Rate strike) const override;
@@ -84,12 +88,15 @@ namespace QuantLib {
         void update() override;
 
       private:
+        void checkStrikes();
+
         Real exerciseTimeSquareRoot_;
         std::vector<Rate> strikes_;
         std::vector<Handle<Quote> > stdDevHandles_;
         Handle<Quote> atmLevel_;
         mutable std::vector<Volatility> vols_;
         mutable Interpolation interpolation_;
+        bool flatStrikeExtrapolation_;
     };
 
 
@@ -102,14 +109,18 @@ namespace QuantLib {
         const Interpolator& interpolator,
         const DayCounter& dc,
         const VolatilityType type,
-        const Real shift)
+        const Real shift,
+        bool flatStrikeExtrapolation
+    )
     : SmileSection(timeToExpiry, dc, type, shift),
       exerciseTimeSquareRoot_(std::sqrt(exerciseTime())), strikes_(std::move(strikes)),
-      stdDevHandles_(stdDevHandles), atmLevel_(std::move(atmLevel)), vols_(stdDevHandles.size()) {
+      stdDevHandles_(stdDevHandles), atmLevel_(std::move(atmLevel)), vols_(stdDevHandles.size()),
+      flatStrikeExtrapolation_(flatStrikeExtrapolation) {
         for (auto& stdDevHandle : stdDevHandles_)
             LazyObject::registerWith(stdDevHandle);
         LazyObject::registerWith(atmLevel_);
-        // check strikes!!!!!!!!!!!!!!!!!!!!
+
+        checkStrikes();
         interpolation_ = interpolator.interpolate(strikes_.begin(),
                                                   strikes_.end(),
                                                   vols_.begin());
@@ -124,10 +135,13 @@ namespace QuantLib {
         const Interpolator& interpolator,
         const DayCounter& dc,
         const VolatilityType type,
-        const Real shift)
+        const Real shift,
+        bool flatStrikeExtrapolation
+    )
     : SmileSection(timeToExpiry, dc, type, shift),
       exerciseTimeSquareRoot_(std::sqrt(exerciseTime())), strikes_(std::move(strikes)),
-      stdDevHandles_(stdDevs.size()), vols_(stdDevs.size()) {
+      stdDevHandles_(stdDevs.size()), vols_(stdDevs.size()),
+      flatStrikeExtrapolation_(flatStrikeExtrapolation) {
         // fill dummy handles to allow generic handle-based
         // computations later on
         for (Size i=0; i<stdDevs.size(); ++i)
@@ -135,7 +149,8 @@ namespace QuantLib {
                 SimpleQuote(stdDevs[i])));
         atmLevel_ = Handle<Quote>
            (ext::shared_ptr<Quote>(new SimpleQuote(atmLevel)));
-        // check strikes!!!!!!!!!!!!!!!!!!!!
+        
+        checkStrikes();
         interpolation_ = interpolator.interpolate(strikes_.begin(),
                                                   strikes_.end(),
                                                   vols_.begin());
@@ -151,14 +166,18 @@ namespace QuantLib {
         const Interpolator& interpolator,
         const Date& referenceDate,
         const VolatilityType type,
-        const Real shift)
+        const Real shift,
+        bool flatStrikeExtrapolation
+    )
     : SmileSection(d, dc, referenceDate, type, shift),
       exerciseTimeSquareRoot_(std::sqrt(exerciseTime())), strikes_(std::move(strikes)),
-      stdDevHandles_(stdDevHandles), atmLevel_(std::move(atmLevel)), vols_(stdDevHandles.size()) {
+      stdDevHandles_(stdDevHandles), atmLevel_(std::move(atmLevel)), vols_(stdDevHandles.size()),
+      flatStrikeExtrapolation_(flatStrikeExtrapolation) {
         for (auto& stdDevHandle : stdDevHandles_)
             LazyObject::registerWith(stdDevHandle);
         LazyObject::registerWith(atmLevel_);
-        // check strikes!!!!!!!!!!!!!!!!!!!!
+        
+        checkStrikes();
         interpolation_ = interpolator.interpolate(strikes_.begin(),
                                                   strikes_.end(),
                                                   vols_.begin());
@@ -174,10 +193,13 @@ namespace QuantLib {
         const Interpolator& interpolator,
         const Date& referenceDate,
         const VolatilityType type,
-        const Real shift)
+        const Real shift,
+        bool flatStrikeExtrapolation
+    )
     : SmileSection(d, dc, referenceDate, type, shift),
       exerciseTimeSquareRoot_(std::sqrt(exerciseTime())), strikes_(std::move(strikes)),
-      stdDevHandles_(stdDevs.size()), vols_(stdDevs.size()) {
+      stdDevHandles_(stdDevs.size()), vols_(stdDevs.size()),
+      flatStrikeExtrapolation_(flatStrikeExtrapolation) {
         //fill dummy handles to allow generic handle-based
         // computations later on
         for (Size i=0; i<stdDevs.size(); ++i)
@@ -185,7 +207,8 @@ namespace QuantLib {
                 SimpleQuote(stdDevs[i])));
         atmLevel_ = Handle<Quote>
            (ext::shared_ptr<Quote>(new SimpleQuote(atmLevel)));
-        // check strikes!!!!!!!!!!!!!!!!!!!!
+        
+        checkStrikes();
         interpolation_ = interpolator.interpolate(strikes_.begin(),
                                                   strikes_.end(),
                                                   vols_.begin());
@@ -205,12 +228,30 @@ namespace QuantLib {
     Real InterpolatedSmileSection<Interpolator>::varianceImpl(Real strike) const {
         calculate();
         Real v = interpolation_(strike, true);
-        return v*v*exerciseTime();
+
+        if (flatStrikeExtrapolation_) {
+            if (strike < minStrike()) {
+                v = minStrike();                
+            } else if (strike > maxStrike()) {
+                v = maxStrike();
+            }
+        }
+
+        return v * v * exerciseTime();
     }
 
     template <class Interpolator>
     Real InterpolatedSmileSection<Interpolator>::volatilityImpl(Real strike) const {
         calculate();
+        
+        if (flatStrikeExtrapolation_) {
+            if (strike < minStrike()) {
+                return minStrike();                
+            } else if (strike > maxStrike()) {
+                return maxStrike();
+            }
+        }
+
         return interpolation_(strike, true);
     }
 
@@ -221,6 +262,28 @@ namespace QuantLib {
     }
     #endif
 
+    template <class Interpolator>
+    void InterpolatedSmileSection<Interpolator>::checkStrikes() {
+        if (!std::is_sorted(strikes_.begin(), strikes_.end())) {
+            std::vector<Size> indices(strikes_.size(), 0); 
+        
+            // initialize the indeces vector
+            for (Size i = 0; i < indices.size(); ++i)
+                indices[i] = i;
+            
+            std::sort(indices.begin(), indices.end(), [&](const int& a, const int& b){
+                return strikes_[a] < strikes_[b];
+            });
+            std::sort(strikes_.begin(), strikes_.end());
+        
+            auto oldVols = vols_;
+
+            for (Size i = 0; i < indices.size(); ++i) {
+                vols_[i] = oldVols[indices[i]];
+            }
+        }
+    }
+
 }
 
 #endif

From 9a58b8af8e2bdf8553f2b4634f62999ea8d0fb55 Mon Sep 17 00:00:00 2001
From: paolodelia99 <paolo.delia99@gmail.com>
Date: Wed, 5 Nov 2025 23:23:30 +0100
Subject: [PATCH 08/11] fix win compilation error, in generate doc error

---
 ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp | 3 +--
 ql/termstructures/volatility/interpolatedsmilesection.hpp      | 2 +-
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp b/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp
index bf101095681..802fff0e1d7 100644
--- a/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp
+++ b/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp
@@ -20,8 +20,7 @@
 
 /*! \file blackvolsurfacedelta.hpp
  \brief Black volatility surface based on delta
- \ingroup termstructures
- */
+*/
 
 #ifndef quantlib_black_variance_surface_delta_hpp
 #define quantlib_black_variance_surface_delta_hpp
diff --git a/ql/termstructures/volatility/interpolatedsmilesection.hpp b/ql/termstructures/volatility/interpolatedsmilesection.hpp
index 9f47d27704a..d481e4e352f 100644
--- a/ql/termstructures/volatility/interpolatedsmilesection.hpp
+++ b/ql/termstructures/volatility/interpolatedsmilesection.hpp
@@ -271,7 +271,7 @@ namespace QuantLib {
             for (Size i = 0; i < indices.size(); ++i)
                 indices[i] = i;
             
-            std::sort(indices.begin(), indices.end(), [&](const int& a, const int& b){
+            std::sort(indices.begin(), indices.end(), [&](const auto& a, const auto& b){
                 return strikes_[a] < strikes_[b];
             });
             std::sort(strikes_.begin(), strikes_.end());

From 813c1bf7ada6db44a18051270c742ce006018f84 Mon Sep 17 00:00:00 2001
From: paolodelia99 <paolo.delia99@gmail.com>
Date: Thu, 6 Nov 2025 17:30:46 +0100
Subject: [PATCH 09/11] Updated initial comment in the tests

---
 test-suite/blackvolsurfacedelta.cpp | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/test-suite/blackvolsurfacedelta.cpp b/test-suite/blackvolsurfacedelta.cpp
index 8351bd87b01..f715c57e783 100644
--- a/test-suite/blackvolsurfacedelta.cpp
+++ b/test-suite/blackvolsurfacedelta.cpp
@@ -1,20 +1,21 @@
 /*
  Copyright (C) 2019 Quaternion Risk Management Ltd
  Copyright (C) 2020 Skandinaviska Enskilda Banken AB (publ)
+ Copyright (C) 2025 Paolo D'Elia
  All rights reserved.
 
- This file is part of ORE, a free-software/open-source library
- for transparent pricing and risk analysis - http://opensourcerisk.org
+ This file is part of QuantLib, a free-software/open-source library
+ for financial quantitative analysts and developers - http://quantlib.org/
 
- ORE is free software: you can redistribute it and/or modify it
- under the terms of the Modified BSD License.  You should have received a
- copy of the license along with this program.
- The license is also available online at <http://opensourcerisk.org>
+ QuantLib is free software: you can redistribute it and/or modify it
+ under the terms of the QuantLib license.  You should have received a
+ copy of the license along with this program; if not, please email
+ <quantlib-dev@lists.sf.net>. The license is also available online at
+ <https://www.quantlib.org/license.shtml>.
 
- This program is distributed on the basis that it will form a useful
- contribution to risk analytics and model standardisation, but WITHOUT
- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- FITNESS FOR A PARTICULAR PURPOSE. See the license for more details.
+ This program is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ FOR A PARTICULAR PURPOSE.  See the license for more details.
 */
 
 #include "toplevelfixture.hpp"

From ff66504dcaea6468f91c2b185e048f63c93cc291 Mon Sep 17 00:00:00 2001
From: paolodelia99 <paolo.delia99@gmail.com>
Date: Thu, 27 Nov 2025 13:13:17 +0100
Subject: [PATCH 10/11] Fix various oversights and add interpolatedsmilesection
 first tests

---
 .../volatility/interpolatedsmilesection.hpp   |  28 +--
 test-suite/CMakeLists.txt                     |   1 +
 test-suite/Makefile.am                        |   1 +
 test-suite/interpolatedsmilesection.cpp       | 206 ++++++++++++++++++
 test-suite/testsuite.vcxproj                  |   1 +
 test-suite/testsuite.vcxproj.filters          |   3 +
 6 files changed, 218 insertions(+), 22 deletions(-)
 create mode 100644 test-suite/interpolatedsmilesection.cpp

diff --git a/ql/termstructures/volatility/interpolatedsmilesection.hpp b/ql/termstructures/volatility/interpolatedsmilesection.hpp
index d481e4e352f..f50a56c0222 100644
--- a/ql/termstructures/volatility/interpolatedsmilesection.hpp
+++ b/ql/termstructures/volatility/interpolatedsmilesection.hpp
@@ -231,9 +231,9 @@ namespace QuantLib {
 
         if (flatStrikeExtrapolation_) {
             if (strike < minStrike()) {
-                v = minStrike();                
+                v = interpolation_(minStrike(), true);                
             } else if (strike > maxStrike()) {
-                v = maxStrike();
+                v = interpolation_(maxStrike(), true);
             }
         }
 
@@ -246,9 +246,9 @@ namespace QuantLib {
         
         if (flatStrikeExtrapolation_) {
             if (strike < minStrike()) {
-                return minStrike();                
+                return interpolation_(minStrike(), true);                
             } else if (strike > maxStrike()) {
-                return maxStrike();
+                return interpolation_(maxStrike(), true);
             }
         }
 
@@ -264,24 +264,8 @@ namespace QuantLib {
 
     template <class Interpolator>
     void InterpolatedSmileSection<Interpolator>::checkStrikes() {
-        if (!std::is_sorted(strikes_.begin(), strikes_.end())) {
-            std::vector<Size> indices(strikes_.size(), 0); 
-        
-            // initialize the indeces vector
-            for (Size i = 0; i < indices.size(); ++i)
-                indices[i] = i;
-            
-            std::sort(indices.begin(), indices.end(), [&](const auto& a, const auto& b){
-                return strikes_[a] < strikes_[b];
-            });
-            std::sort(strikes_.begin(), strikes_.end());
-        
-            auto oldVols = vols_;
-
-            for (Size i = 0; i < indices.size(); ++i) {
-                vols_[i] = oldVols[indices[i]];
-            }
-        }
+        QL_REQUIRE(std::is_sorted(strikes_.begin(), strikes_.end()), 
+                    "Strikes have to be sorted in ascending order");
     }
 
 }
diff --git a/test-suite/CMakeLists.txt b/test-suite/CMakeLists.txt
index 6fec73ac93b..930289d32e5 100644
--- a/test-suite/CMakeLists.txt
+++ b/test-suite/CMakeLists.txt
@@ -91,6 +91,7 @@ set(QL_TEST_SOURCES
     instruments.cpp
     integrals.cpp
     interestrates.cpp
+    interpolatedsmilesection.cpp
     interpolations.cpp
     jumpdiffusion.cpp
     lazyobject.cpp
diff --git a/test-suite/Makefile.am b/test-suite/Makefile.am
index 92809b5ec8c..fbcb3c0a4a0 100644
--- a/test-suite/Makefile.am
+++ b/test-suite/Makefile.am
@@ -92,6 +92,7 @@ QL_TEST_SRCS = \
 	instruments.cpp \
 	integrals.cpp \
 	interestrates.cpp \
+	interpolatedsmilesection.cpp \
 	interpolations.cpp \
 	jumpdiffusion.cpp \
 	lazyobject.cpp \
diff --git a/test-suite/interpolatedsmilesection.cpp b/test-suite/interpolatedsmilesection.cpp
new file mode 100644
index 00000000000..a6adcfdb875
--- /dev/null
+++ b/test-suite/interpolatedsmilesection.cpp
@@ -0,0 +1,206 @@
+/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*
+ Copyright (C) 2025 Paolo D'Elia
+
+ This file is part of QuantLib, a free-software/open-source library
+ for financial quantitative analysts and developers - http://quantlib.org/
+
+ QuantLib is free software: you can redistribute it and/or modify it
+ under the terms of the QuantLib license.  You should have received a
+ copy of the license along with this program; if not, please email
+ <quantlib-dev@lists.sf.net>. The license is also available online at
+ <https://www.quantlib.org/license.shtml>.
+
+ This program is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ FOR A PARTICULAR PURPOSE.  See the license for more details.
+*/
+#include "toplevelfixture.hpp"
+#include "utilities.hpp"
+#include <ql/termstructures/volatility/interpolatedsmilesection.hpp>
+#include <ql/math/interpolations/linearinterpolation.hpp>
+#include <ql/quotes/simplequote.hpp>
+#include <ql/time/daycounters/actual365fixed.hpp>
+
+#include <vector>
+#include <cmath>
+
+using namespace QuantLib;
+using namespace boost::unit_test_framework;
+
+BOOST_FIXTURE_TEST_SUITE(QuantLibTests, TopLevelFixture)
+
+BOOST_AUTO_TEST_SUITE(InterpolatedSmileSectionTests)
+
+// Helper for linear interpolation/extrapolation between two points
+static Real linearInterp(Real x, Real x1, Real y1, Real x2, Real y2) {
+    if (x2 == x1)
+        return y1;
+    return y1 + (y2 - y1) * ( (x - x1) / (x2 - x1) );
+}
+
+BOOST_AUTO_TEST_CASE(testInterpolationAndVariance) {
+    BOOST_TEST_MESSAGE("Testing basic behaviour of Linear Interpolated Smile Section");
+    // basic scenario: sorted strikes, constructor taking stdDevs (total std devs)
+    Time expiry = 0.25; // 3 months
+    std::vector<Rate> strikes{90.0, 100.0, 110};
+    // total std deviations (i.e., sigma * sqrt(T))
+    std::vector<Real> stdDevs{0.20, 0.15, 0.18};
+    Real atmLevel = 95.0;
+
+    auto section = ext::make_shared<InterpolatedSmileSection<Linear>>(
+        expiry, strikes, stdDevs, atmLevel
+    );
+
+    // pick an interior strike 95 between 90 and 100
+    Real strike = 95.0;
+
+    // vols stored internally are stdDev / sqrt(T)
+    Real sqrtT = std::sqrt(expiry);
+    Real v90 = stdDevs[0] / sqrtT;
+    Real v100 = stdDevs[1] / sqrtT;
+    Real expectedVol = linearInterp(strike, 90.0, v90, 100.0, v100);
+
+    Real tol = 1e-12;
+    BOOST_CHECK_CLOSE(section->volatilityImpl(strike), expectedVol, tol);
+
+    // variance should be vol^2 * T
+    Real expectedVar = expectedVol * expectedVol * expiry;
+    BOOST_CHECK_CLOSE(section->varianceImpl(strike), expectedVar, tol);
+}
+
+BOOST_AUTO_TEST_CASE(testExtrapolationWhenAllowed) {
+    BOOST_TEST_MESSAGE("Testing extrapolation behavior of Linear Interpolated Smile Section");
+    // test extrapolation behavior when flatStrikeExtrapolation=false
+    Time expiry = 0.25;
+    std::vector<Rate> strikes{90.0, 100.0, 110};
+    std::vector<Real> stdDevs{0.20, 0.15, 0.18};
+    Real atmLevel = 95.0;
+
+    auto section = ext::make_shared<InterpolatedSmileSection<Linear>>(
+        expiry, strikes, stdDevs, atmLevel
+    );
+
+    Real sqrtT = std::sqrt(expiry);
+    // compute expected extrapolated vol at strike 80 (below min strike 90)
+    Real v90 = stdDevs[0] / sqrtT;
+    Real v100 = stdDevs[1] / sqrtT;
+    Real strikeLow = 80.0;
+    Real expectedLow = linearInterp(strikeLow, 90.0, v90, 100.0, v100);
+
+    Real tol = 1e-12;
+    BOOST_CHECK_CLOSE(section->volatilityImpl(strikeLow), expectedLow, tol);
+
+    // extrapolate above max strike, e.g., 120 using last segment 110-100
+    Real v110 = stdDevs[2] / sqrtT;
+    Real strikeHigh = 120.0;
+    // use last two points (110, v110) and (100, v100) for extrapolation;
+    // linearInterp works for extrapolation as well
+    Real expectedHigh = linearInterp(strikeHigh, 110.0, v110, 100.0, v100);
+    BOOST_CHECK_CLOSE(section->volatilityImpl(strikeHigh), expectedHigh, tol);
+}
+
+BOOST_AUTO_TEST_CASE(testHandlesUpdatePropagates) {
+    BOOST_TEST_MESSAGE("Testing construction of Linear Interpolated Smile Section using Quote Handles for vols and updating them");
+    // construct via Quote handles and verify changing the underlying quote updates the section
+    Time expiry = 0.25;
+    std::vector<Rate> strikes{80.0, 90.0, 100.0};
+
+    // create SimpleQuote instances
+    ext::shared_ptr<SimpleQuote> q0(new SimpleQuote(0.20));
+    ext::shared_ptr<SimpleQuote> q1(new SimpleQuote(0.15));
+    ext::shared_ptr<SimpleQuote> q2(new SimpleQuote(0.18));
+    std::vector<Handle<Quote>> stdDevHandles;
+    stdDevHandles.emplace_back(Handle<Quote>(q0));
+    stdDevHandles.emplace_back(Handle<Quote>(q1));
+    stdDevHandles.emplace_back(Handle<Quote>(q2));
+
+    ext::shared_ptr<SimpleQuote> atm(new SimpleQuote(95.0));
+    Handle<Quote> atmHandle(atm);
+
+    auto section = ext::make_shared<InterpolatedSmileSection<Linear>>(
+        expiry, strikes, stdDevHandles, atmHandle
+    );
+
+    Real sqrtT = std::sqrt(expiry);
+    // current vol at 95
+    Real v90 = q1->value() / sqrtT;
+    Real v100 = q2->value() / sqrtT;
+    Real expectedBefore = linearInterp(95.0, 90.0, v90, 100.0, v100);
+
+    Real tol = 1e-12;
+    BOOST_CHECK_CLOSE(section->volatilityImpl(95.0), expectedBefore, tol);
+
+    // now change the middle quote q1 from 0.15 to 0.20
+    q1->setValue(0.20);
+
+    // after changing the quote, the section should reflect the new vol
+    Real v90_after = q1->value() / sqrtT;
+    Real expectedAfter = linearInterp(95.0, 90.0, v90_after, 100.0, v100);
+    BOOST_CHECK_CLOSE(section->volatilityImpl(95.0), expectedAfter, tol);
+}
+
+BOOST_AUTO_TEST_CASE(testFlatStrikeExtrapolation) {
+    BOOST_TEST_MESSAGE("Testing flat strike extrapolation in Interpolated Smile Section");
+    // construct via Quote handles and verify changing the underlying quote updates the section
+    Time expiry = 0.25;
+    std::vector<Rate> strikes{90.0, 100.0, 110.0};
+
+    // create SimpleQuote instances
+    ext::shared_ptr<SimpleQuote> q0(new SimpleQuote(0.20));
+    ext::shared_ptr<SimpleQuote> q1(new SimpleQuote(0.15));
+    ext::shared_ptr<SimpleQuote> q2(new SimpleQuote(0.18));
+    std::vector<Handle<Quote>> stdDevHandles;
+    stdDevHandles.emplace_back(Handle<Quote>(q0));
+    stdDevHandles.emplace_back(Handle<Quote>(q1));
+    stdDevHandles.emplace_back(Handle<Quote>(q2));
+
+    ext::shared_ptr<SimpleQuote> atm(new SimpleQuote(95.0));
+    Handle<Quote> atmHandle(atm);
+
+    auto section = ext::make_shared<InterpolatedSmileSection<Linear>>(
+        expiry, strikes, stdDevHandles, atmHandle,
+        Linear(), Actual365Fixed(), ShiftedLognormal, 0.0, true
+    );
+
+    Real sqrtT = std::sqrt(expiry);
+    // Check with strike lower than minStrike()
+    Real v90 = q0->value() / sqrtT;
+    Real strikeLow = 85.0;
+
+    Real tol = 1e-12;
+    BOOST_CHECK_CLOSE(section->volatilityImpl(strikeLow), v90, tol);
+
+    // Check with strike higher than maxStrike()
+    Real v110 = q2->value() / sqrtT;
+    Real strikeHigh = 120.0;
+
+    BOOST_CHECK_CLOSE(section->volatilityImpl(strikeHigh), v110, tol);
+
+    //Change minStrike vol quote and check if out-of-bounds vol is the same
+    q0->setValue(0.21);
+    Real v90_after = q0->value() / sqrtT;
+    BOOST_CHECK_CLOSE(section->volatilityImpl(strikeLow), v90_after, tol);
+}
+
+BOOST_AUTO_TEST_CASE(testErrorThrowingWhenNonSortedStrikes) {
+    BOOST_TEST_MESSAGE("Testing throwin QuantLib::Error when creating Interpolated Smile section with non-sorted strikes");
+    // basic scenario: sorted strikes, constructor taking stdDevs (total std devs)
+    Time expiry = 0.25; // 3 months
+    std::vector<Rate> strikes{90.0, 110.0, 100};
+    // total std deviations (i.e., sigma * sqrt(T))
+    std::vector<Real> stdDevs{0.20, 0.15, 0.18};
+    Real atmLevel = 95.0;
+
+    BOOST_CHECK_THROW(
+        auto section = ext::make_shared<InterpolatedSmileSection<Linear>>(
+            expiry, strikes, stdDevs, atmLevel
+        ),
+        QuantLib::Error
+    );
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test-suite/testsuite.vcxproj b/test-suite/testsuite.vcxproj
index 9af2e569023..47e9391f62e 100644
--- a/test-suite/testsuite.vcxproj
+++ b/test-suite/testsuite.vcxproj
@@ -736,6 +736,7 @@
     <ClCompile Include="instruments.cpp" />
     <ClCompile Include="integrals.cpp" />
     <ClCompile Include="interestrates.cpp" />
+    <ClCompile Include="interpolatedsmilesection.cpp" />
     <ClCompile Include="interpolations.cpp" />
     <ClCompile Include="jumpdiffusion.cpp" />
     <ClCompile Include="lazyobject.cpp" />
diff --git a/test-suite/testsuite.vcxproj.filters b/test-suite/testsuite.vcxproj.filters
index ee1e23f1947..412fc2e2cd0 100644
--- a/test-suite/testsuite.vcxproj.filters
+++ b/test-suite/testsuite.vcxproj.filters
@@ -230,6 +230,9 @@
     <ClCompile Include="interestrates.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="interpolatedsmilesection.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
     <ClCompile Include="interpolations.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>

From 8e6afe619154de161b0ab82becbc193c0f6f7b8c Mon Sep 17 00:00:00 2001
From: paolodelia99 <paolo.delia99@gmail.com>
Date: Thu, 27 Nov 2025 18:06:09 +0100
Subject: [PATCH 11/11] no anonymous namespace anymore, removed #pragma once

---
 .../volatility/equityfx/blackvariancetimeextrapolation.hpp | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/ql/termstructures/volatility/equityfx/blackvariancetimeextrapolation.hpp b/ql/termstructures/volatility/equityfx/blackvariancetimeextrapolation.hpp
index 2c678bcc0d7..8b31163ce4e 100644
--- a/ql/termstructures/volatility/equityfx/blackvariancetimeextrapolation.hpp
+++ b/ql/termstructures/volatility/equityfx/blackvariancetimeextrapolation.hpp
@@ -20,7 +20,6 @@
 /*! \file blackvariancetimeextrapolation.hpp
     \brief Utility function for time extrapolation in Black volatility in black variance term structures
 */
-#pragma once
 
 #include <array>
 #include <functional>
@@ -31,7 +30,7 @@
 
 namespace QuantLib {
 
-    namespace {
+    namespace detail {
         Real linearExtrapolation(const double t, const std::array<double, 2>& times, const std::array<double, 2>& variances);
 
         inline Real linearExtrapolation(const double t, const std::array<double, 2>& times,
@@ -79,7 +78,7 @@ namespace QuantLib {
         std::array<Real, 2> variances;
         variances[0] = varianceSurface(xs[0], strike, true);
         variances[1] = varianceSurface(xs[1], strike, true);
-        Real v = linearExtrapolation(t, xs, variances);
+        Real v = detail::linearExtrapolation(t, xs, variances);
         return v * v * t;
     }
 
@@ -96,7 +95,7 @@ namespace QuantLib {
         std::array<Real, 2> variances;
         variances[0] = varianceCurve(xs[0], true);
         variances[1] = varianceCurve(xs[1], true);
-        Real v = linearExtrapolation(t, xs, variances);
+        Real v = detail::linearExtrapolation(t, xs, variances);
         return v * v * t;
     }
 } // namespace QuantLib
\ No newline at end of file