From 1f7ba67bb7225d43b16c3d851b0acb9fdec63f46 Mon Sep 17 00:00:00 2001
From: ralfkonrad <github@eckel-consulting.de>
Date: Tue, 16 Jul 2024 15:50:00 +0200
Subject: [PATCH 01/10] Expose the OvernightIndexedCouponPricer

---
 ql/cashflows/overnightindexedcoupon.cpp | 291 +++++++++++-------------
 ql/cashflows/overnightindexedcoupon.hpp |  27 ++-
 2 files changed, 161 insertions(+), 157 deletions(-)

diff --git a/ql/cashflows/overnightindexedcoupon.cpp b/ql/cashflows/overnightindexedcoupon.cpp
index db1e8019d4c..f23eafc57e2 100644
--- a/ql/cashflows/overnightindexedcoupon.cpp
+++ b/ql/cashflows/overnightindexedcoupon.cpp
@@ -48,155 +48,6 @@ namespace QuantLib {
             return n == interestDates.size() && applyObservationShift ? n - 1 : n;
         }
 
-        class OvernightIndexedCouponPricer : public FloatingRateCouponPricer {
-          public:
-            void initialize(const FloatingRateCoupon& coupon) override {
-                coupon_ = dynamic_cast<const OvernightIndexedCoupon*>(&coupon);
-                QL_ENSURE(coupon_, "wrong coupon type");
-            }
-
-            Rate averageRate(const Date& date) const {
-
-                const Date today = Settings::instance().evaluationDate();
-
-                const ext::shared_ptr<OvernightIndex> index =
-                    ext::dynamic_pointer_cast<OvernightIndex>(coupon_->index());
-                const auto& pastFixings = IndexManager::instance().getHistory(index->name());
-
-                const vector<Date>& fixingDates = coupon_->fixingDates();
-                const vector<Date>& valueDates = coupon_->valueDates();
-                const vector<Date>& interestDates = coupon_->interestDates();
-                const vector<Time>& dt = coupon_->dt();
-                const bool applyObservationShift = coupon_->applyObservationShift();
-
-                Size i = 0;
-                const Size n = determineNumberOfFixings(interestDates, date, applyObservationShift);
-
-                Real compoundFactor = 1.0;
-
-                // already fixed part
-                while (i < n && fixingDates[i] < today) {
-                    // rate must have been fixed
-                    const Rate fixing = pastFixings[fixingDates[i]];
-                    QL_REQUIRE(fixing != Null<Real>(),
-                               "Missing " << index->name() <<
-                               " fixing for " << fixingDates[i]);
-                    Time span = (date >= interestDates[i + 1] ?
-                                 dt[i] :
-                                 index->dayCounter().yearFraction(interestDates[i], date));
-                    compoundFactor *= (1.0 + fixing * span);
-                    ++i;
-                }
-
-                // today is a border case
-                if (i < n && fixingDates[i] == today) {
-                    // might have been fixed
-                    try {
-                        Rate fixing = pastFixings[fixingDates[i]];
-                        if (fixing != Null<Real>()) {
-                            Time span = (date >= interestDates[i + 1] ?
-                                         dt[i] :
-                                         index->dayCounter().yearFraction(interestDates[i], date));
-                            compoundFactor *= (1.0 + fixing * span);
-                            ++i;
-                        } else {
-                            ;   // fall through and forecast
-                        }
-                    } catch (Error&) {
-                        ;       // fall through and forecast
-                    }
-                }
-
-                // forward part using telescopic property in order
-                // to avoid the evaluation of multiple forward fixings
-                // where possible.
-                if (i < n) {
-                    const Handle<YieldTermStructure> curve = index->forwardingTermStructure();
-                    QL_REQUIRE(!curve.empty(),
-                               "null term structure set to this instance of " << index->name());
-
-                    const auto effectiveRate = [&index, &fixingDates, &date, &interestDates,
-                                                &dt](Size position) {
-                        Rate fixing = index->fixing(fixingDates[position]);
-                        Time span =
-                            (date >= interestDates[position + 1] ?
-                                 dt[position] :
-                                 index->dayCounter().yearFraction(interestDates[position], date));
-                        return span * fixing;
-                    };
-
-                    if (!coupon_->canApplyTelescopicFormula()) {
-                        // With lookback applied, the telescopic formula cannot be used,
-                        // we need to project each fixing in the coupon.
-                        // Only in one particular case when observation shift is used and
-                        // no intrinsic index fixing delay is applied, the telescopic formula
-                        // holds, because regardless of the fixing delay in the coupon,
-                        // in such configuration value dates will be equal to interest dates.
-                        // A potential lockout, which may occur in tandem with a lookback
-                        // setting, will be handled automatically based on fixing dates.
-                        // Same applies to a case when accrual calculation date does or
-                        // does not occur on an interest date.
-                        while (i < n) {
-                            compoundFactor *= (1.0 + effectiveRate(i));
-                            ++i;
-                        }
-                    } else {
-                        // No lookback, we can partially apply the telescopic formula.
-                        // But we need to make a correction for a potential lockout.
-                        const Size nLockout = n - coupon_->lockoutDays();
-                        const bool isLockoutApplied = coupon_->lockoutDays() > 0;
-
-                        // Lockout could already start at or before i.
-                        // In such case the ratio of discount factors will be equal to 1.
-                        const DiscountFactor startDiscount =
-                            curve->discount(valueDates[std::min<Size>(nLockout, i)]);
-                        if (interestDates[n] == date || isLockoutApplied) {
-                            // telescopic formula up to potential lockout dates.
-                            const DiscountFactor endDiscount =
-                                curve->discount(valueDates[std::min<Size>(nLockout, n)]);
-                            compoundFactor *= startDiscount / endDiscount;
-                            // For the lockout periods the telescopic formula does not apply.
-                            // The value dates (at which the projection is calculated) correspond
-                            // to the locked-out fixing, while the interest dates (at which the
-                            // interest over that fixing is accrued) are not fixed at lockout,
-                            // hence they do not cancel out.
-                            i = std::max(nLockout, i);
-                            
-                            // With no lockout, the loop is skipped because i = n.
-                            while (i < n) {
-                                compoundFactor *= (1.0 + effectiveRate(i));
-                                ++i;
-                            }
-                        } else {
-                            // No lockout and date is different than last interest date.
-                            // The last fixing is not used for its full period (the date is between
-                            // its start and end date).  We can use the telescopic formula until the
-                            // previous date, then we'll add the missing bit.
-                            const DiscountFactor endDiscount = curve->discount(valueDates[n - 1]);
-                            compoundFactor *= startDiscount / endDiscount;
-                            compoundFactor *= (1.0 + effectiveRate(n - 1));
-                        }
-                    }
-                }
-
-                const Rate rate = (compoundFactor - 1.0) / coupon_->accruedPeriod(date);
-                return coupon_->gearing() * rate + coupon_->spread();
-            }
-
-            Rate swapletRate() const override {
-                return averageRate(coupon_->accrualEndDate());
-            }
-
-            Real swapletPrice() const override { QL_FAIL("swapletPrice not available"); }
-            Real capletPrice(Rate) const override { QL_FAIL("capletPrice not available"); }
-            Rate capletRate(Rate) const override { QL_FAIL("capletRate not available"); }
-            Real floorletPrice(Rate) const override { QL_FAIL("floorletPrice not available"); }
-            Rate floorletRate(Rate) const override { QL_FAIL("floorletRate not available"); }
-
-          protected:
-            const OvernightIndexedCoupon* coupon_;
-        };
-
         Date applyLookbackPeriod(const ext::shared_ptr<InterestRateIndex>& index,
                                  const Date& valueDate,
                                  Natural lookbackDays) {
@@ -310,14 +161,14 @@ namespace QuantLib {
                     // If fixing dates of the coupon deviate from fixing days in the index
                     // we need to correct the value dates such that they reflect dates
                     // corresponding to a deposit instrument linked to the index.
-                    // This is to ensure that future projections (which are computed 
+                    // This is to ensure that future projections (which are computed
                     // based on the value dates) of the index do not
-                    // yield any convexity corrections. 
+                    // yield any convexity corrections.
                     valueDates_[i] = overnightIndex->valueDate(tmp);
             }
         }
-        // When lockout is used the fixing rate applied for the last k days of the 
-        // interest period is frozen at the rate observed k days before the period ends. 
+        // When lockout is used the fixing rate applied for the last k days of the
+        // interest period is frozen at the rate observed k days before the period ends.
         if (lockoutDays_ != 0) {
             QL_REQUIRE(lockoutDays_ > 0 && lockoutDays_ < n_,
                        "Lockout period cannot be negative or exceed the number of fixing days.");
@@ -389,6 +240,140 @@ namespace QuantLib {
         }
     }
 
+    void OvernightIndexedCouponPricer::initialize(const FloatingRateCoupon& coupon) {
+        coupon_ = dynamic_cast<const OvernightIndexedCoupon*>(&coupon);
+        QL_ENSURE(coupon_, "wrong coupon type");
+    }
+
+    Rate OvernightIndexedCouponPricer::swapletRate() const {
+        return averageRate(coupon_->accrualEndDate());
+    }
+
+    Rate OvernightIndexedCouponPricer::averageRate(const Date& date) const {
+        const Date today = Settings::instance().evaluationDate();
+
+        const ext::shared_ptr<OvernightIndex> index =
+            ext::dynamic_pointer_cast<OvernightIndex>(coupon_->index());
+        const auto& pastFixings = IndexManager::instance().getHistory(index->name());
+
+        const vector<Date>& fixingDates = coupon_->fixingDates();
+        const vector<Date>& valueDates = coupon_->valueDates();
+        const vector<Date>& interestDates = coupon_->interestDates();
+        const vector<Time>& dt = coupon_->dt();
+        const bool applyObservationShift = coupon_->applyObservationShift();
+
+        Size i = 0;
+        const Size n = determineNumberOfFixings(interestDates, date, applyObservationShift);
+
+        Real compoundFactor = 1.0;
+
+        // already fixed part
+        while (i < n && fixingDates[i] < today) {
+            // rate must have been fixed
+            const Rate fixing = pastFixings[fixingDates[i]];
+            QL_REQUIRE(fixing != Null<Real>(),
+                       "Missing " << index->name() << " fixing for " << fixingDates[i]);
+            Time span = (date >= interestDates[i + 1] ?
+                             dt[i] :
+                             index->dayCounter().yearFraction(interestDates[i], date));
+            compoundFactor *= (1.0 + fixing * span);
+            ++i;
+        }
+
+        // today is a border case
+        if (i < n && fixingDates[i] == today) {
+            // might have been fixed
+            try {
+                Rate fixing = pastFixings[fixingDates[i]];
+                if (fixing != Null<Real>()) {
+                    Time span = (date >= interestDates[i + 1] ?
+                                     dt[i] :
+                                     index->dayCounter().yearFraction(interestDates[i], date));
+                    compoundFactor *= (1.0 + fixing * span);
+                    ++i;
+                } else {
+                    ; // fall through and forecast
+                }
+            } catch (Error&) {
+                ; // fall through and forecast
+            }
+        }
+
+        // forward part using telescopic property in order
+        // to avoid the evaluation of multiple forward fixings
+        // where possible.
+        if (i < n) {
+            const Handle<YieldTermStructure> curve = index->forwardingTermStructure();
+            QL_REQUIRE(!curve.empty(),
+                       "null term structure set to this instance of " << index->name());
+
+            const auto effectiveRate = [&index, &fixingDates, &date, &interestDates,
+                                        &dt](Size position) {
+                Rate fixing = index->fixing(fixingDates[position]);
+                Time span = (date >= interestDates[position + 1] ?
+                                 dt[position] :
+                                 index->dayCounter().yearFraction(interestDates[position], date));
+                return span * fixing;
+            };
+
+            if (!coupon_->canApplyTelescopicFormula()) {
+                // With lookback applied, the telescopic formula cannot be used,
+                // we need to project each fixing in the coupon.
+                // Only in one particular case when observation shift is used and
+                // no intrinsic index fixing delay is applied, the telescopic formula
+                // holds, because regardless of the fixing delay in the coupon,
+                // in such configuration value dates will be equal to interest dates.
+                // A potential lockout, which may occur in tandem with a lookback
+                // setting, will be handled automatically based on fixing dates.
+                // Same applies to a case when accrual calculation date does or
+                // does not occur on an interest date.
+                while (i < n) {
+                    compoundFactor *= (1.0 + effectiveRate(i));
+                    ++i;
+                }
+            } else {
+                // No lookback, we can partially apply the telescopic formula.
+                // But we need to make a correction for a potential lockout.
+                const Size nLockout = n - coupon_->lockoutDays();
+                const bool isLockoutApplied = coupon_->lockoutDays() > 0;
+
+                // Lockout could already start at or before i.
+                // In such case the ratio of discount factors will be equal to 1.
+                const DiscountFactor startDiscount =
+                    curve->discount(valueDates[std::min<Size>(nLockout, i)]);
+                if (interestDates[n] == date || isLockoutApplied) {
+                    // telescopic formula up to potential lockout dates.
+                    const DiscountFactor endDiscount =
+                        curve->discount(valueDates[std::min<Size>(nLockout, n)]);
+                    compoundFactor *= startDiscount / endDiscount;
+                    // For the lockout periods the telescopic formula does not apply.
+                    // The value dates (at which the projection is calculated) correspond
+                    // to the locked-out fixing, while the interest dates (at which the
+                    // interest over that fixing is accrued) are not fixed at lockout,
+                    // hence they do not cancel out.
+                    i = std::max(nLockout, i);
+
+                    // With no lockout, the loop is skipped because i = n.
+                    while (i < n) {
+                        compoundFactor *= (1.0 + effectiveRate(i));
+                        ++i;
+                    }
+                } else {
+                    // No lockout and date is different than last interest date.
+                    // The last fixing is not used for its full period (the date is between
+                    // its start and end date).  We can use the telescopic formula until the
+                    // previous date, then we'll add the missing bit.
+                    const DiscountFactor endDiscount = curve->discount(valueDates[n - 1]);
+                    compoundFactor *= startDiscount / endDiscount;
+                    compoundFactor *= (1.0 + effectiveRate(n - 1));
+                }
+            }
+        }
+
+        const Rate rate = (compoundFactor - 1.0) / coupon_->accruedPeriod(date);
+        return coupon_->gearing() * rate + coupon_->spread();
+    }
+
     OvernightLeg::OvernightLeg(Schedule schedule, ext::shared_ptr<OvernightIndex> i)
     : schedule_(std::move(schedule)), overnightIndex_(std::move(i)), paymentCalendar_(schedule_.calendar()) {
         QL_REQUIRE(overnightIndex_, "no index provided");
diff --git a/ql/cashflows/overnightindexedcoupon.hpp b/ql/cashflows/overnightindexedcoupon.hpp
index 69a4ad5d5cc..8d275a8dcb8 100644
--- a/ql/cashflows/overnightindexedcoupon.hpp
+++ b/ql/cashflows/overnightindexedcoupon.hpp
@@ -28,6 +28,7 @@
 #ifndef quantlib_overnight_indexed_coupon_hpp
 #define quantlib_overnight_indexed_coupon_hpp
 
+#include <ql/cashflows/couponpricer.hpp>
 #include <ql/cashflows/floatingratecoupon.hpp>
 #include <ql/cashflows/rateaveraging.hpp>
 #include <ql/indexes/iborindex.hpp>
@@ -113,11 +114,24 @@ namespace QuantLib {
         Rate averageRate(const Date& date) const;
     };
 
-    inline const bool OvernightIndexedCoupon::canApplyTelescopicFormula() const {
-        return fixingDays_ == index_->fixingDays() ||
-               (applyObservationShift_ && index_->fixingDays() == 0);
-    }
+    //! OvernightIndexedCoupon pricer
+    class OvernightIndexedCouponPricer : public FloatingRateCouponPricer {
+      public:
+        //! \name FloatingRateCoupon interface
+        //@{
+        void initialize(const FloatingRateCoupon& coupon) override;
+        Rate swapletRate() const override;
+        Real swapletPrice() const override { QL_FAIL("swapletPrice not available"); }
+        Real capletPrice(Rate) const override { QL_FAIL("capletPrice not available"); }
+        Rate capletRate(Rate) const override { QL_FAIL("capletRate not available"); }
+        Real floorletPrice(Rate) const override { QL_FAIL("floorletPrice not available"); }
+        Rate floorletRate(Rate) const override { QL_FAIL("floorletRate not available"); }
+        //@}
+        Rate averageRate(const Date& date) const;
 
+      protected:
+        const OvernightIndexedCoupon* coupon_ = nullptr;
+    };
 
     //! helper class building a sequence of overnight coupons
     class OvernightLeg {
@@ -156,6 +170,11 @@ namespace QuantLib {
         bool applyObservationShift_ = false;
     };
 
+    inline const bool OvernightIndexedCoupon::canApplyTelescopicFormula() const {
+        return fixingDays_ == index_->fixingDays() ||
+               (applyObservationShift_ && index_->fixingDays() == 0);
+    }
+
 }
 
 #endif

From 0991b3ee6ef9d3e1a5bbb33536b60781b5c2ca2d Mon Sep 17 00:00:00 2001
From: ralfkonrad <github@eckel-consulting.de>
Date: Tue, 16 Jul 2024 16:07:17 +0200
Subject: [PATCH 02/10] Add set pricer functionality to OvernightLeg

---
 ql/cashflows/overnightindexedcoupon.cpp | 28 ++++++++++++-------------
 ql/cashflows/overnightindexedcoupon.hpp |  4 ++++
 2 files changed, 17 insertions(+), 15 deletions(-)

diff --git a/ql/cashflows/overnightindexedcoupon.cpp b/ql/cashflows/overnightindexedcoupon.cpp
index f23eafc57e2..c258c02847e 100644
--- a/ql/cashflows/overnightindexedcoupon.cpp
+++ b/ql/cashflows/overnightindexedcoupon.cpp
@@ -452,6 +452,11 @@ namespace QuantLib {
         applyObservationShift_ = applyObservationShift;
         return *this;
     }
+    OvernightLeg& OvernightLeg::withOvernightIndexedCouponPricer(
+        const ext::shared_ptr<OvernightIndexedCouponPricer>& couponPricer) {
+        couponPricer_ = couponPricer;
+        return *this;
+    }
 
     OvernightLeg::operator Leg() const {
 
@@ -478,21 +483,14 @@ namespace QuantLib {
                 refEnd = calendar.adjust(start + schedule_.tenor(),
                                          paymentAdjustment_);
 
-            cashflows.push_back(ext::shared_ptr<CashFlow>(new
-                OvernightIndexedCoupon(paymentDate,
-                                       detail::get(notionals_, i,
-                                                   notionals_.back()),
-                                       start, end,
-                                       overnightIndex_,
-                                       detail::get(gearings_, i, 1.0),
-                                       detail::get(spreads_, i, 0.0),
-                                       refStart, refEnd,
-                                       paymentDayCounter_,
-                                       telescopicValueDates_,
-                                       averagingMethod_,
-                                       lookbackDays_,
-                                       lockoutDays_,
-                                       applyObservationShift_)));
+            const auto overnightIndexedCoupon = ext::make_shared<OvernightIndexedCoupon>(
+                paymentDate, detail::get(notionals_, i, notionals_.back()), start, end,
+                overnightIndex_, detail::get(gearings_, i, 1.0), detail::get(spreads_, i, 0.0),
+                refStart, refEnd, paymentDayCounter_, telescopicValueDates_, averagingMethod_,
+                lookbackDays_, lockoutDays_, applyObservationShift_);
+            overnightIndexedCoupon->setPricer(couponPricer_);
+
+            cashflows.push_back(overnightIndexedCoupon);
         }
         return cashflows;
     }
diff --git a/ql/cashflows/overnightindexedcoupon.hpp b/ql/cashflows/overnightindexedcoupon.hpp
index 8d275a8dcb8..b5ba70bf3c6 100644
--- a/ql/cashflows/overnightindexedcoupon.hpp
+++ b/ql/cashflows/overnightindexedcoupon.hpp
@@ -152,6 +152,8 @@ namespace QuantLib {
         OvernightLeg& withLookbackDays(Natural lookbackDays);
         OvernightLeg& withLockoutDays(Natural lockoutDays);
         OvernightLeg& withObservationShift(bool applyObservationShift = true);
+        OvernightLeg& withOvernightIndexedCouponPricer(
+            const ext::shared_ptr<OvernightIndexedCouponPricer>& couponPricer);
         operator Leg() const;
       private:
         Schedule schedule_;
@@ -168,6 +170,8 @@ namespace QuantLib {
         Natural lookbackDays_ = Null<Natural>();
         Natural lockoutDays_ = 0;
         bool applyObservationShift_ = false;
+        ext::shared_ptr<OvernightIndexedCouponPricer> couponPricer_ =
+            ext::make_shared<OvernightIndexedCouponPricer>();
     };
 
     inline const bool OvernightIndexedCoupon::canApplyTelescopicFormula() const {

From e79fec8d4e6e71f02d5d0c9c6012aa2fd03324a0 Mon Sep 17 00:00:00 2001
From: ralfkonrad <github@eckel-consulting.de>
Date: Mon, 29 Jul 2024 14:30:40 +0200
Subject: [PATCH 03/10] Remove withOvernightIndexedCouponPricer(...) as a
 similar method is not provided e.g. for IborLeg

---
 ql/cashflows/overnightindexedcoupon.cpp | 6 ------
 ql/cashflows/overnightindexedcoupon.hpp | 4 ----
 2 files changed, 10 deletions(-)

diff --git a/ql/cashflows/overnightindexedcoupon.cpp b/ql/cashflows/overnightindexedcoupon.cpp
index c258c02847e..43381b70533 100644
--- a/ql/cashflows/overnightindexedcoupon.cpp
+++ b/ql/cashflows/overnightindexedcoupon.cpp
@@ -452,11 +452,6 @@ namespace QuantLib {
         applyObservationShift_ = applyObservationShift;
         return *this;
     }
-    OvernightLeg& OvernightLeg::withOvernightIndexedCouponPricer(
-        const ext::shared_ptr<OvernightIndexedCouponPricer>& couponPricer) {
-        couponPricer_ = couponPricer;
-        return *this;
-    }
 
     OvernightLeg::operator Leg() const {
 
@@ -488,7 +483,6 @@ namespace QuantLib {
                 overnightIndex_, detail::get(gearings_, i, 1.0), detail::get(spreads_, i, 0.0),
                 refStart, refEnd, paymentDayCounter_, telescopicValueDates_, averagingMethod_,
                 lookbackDays_, lockoutDays_, applyObservationShift_);
-            overnightIndexedCoupon->setPricer(couponPricer_);
 
             cashflows.push_back(overnightIndexedCoupon);
         }
diff --git a/ql/cashflows/overnightindexedcoupon.hpp b/ql/cashflows/overnightindexedcoupon.hpp
index b5ba70bf3c6..8d275a8dcb8 100644
--- a/ql/cashflows/overnightindexedcoupon.hpp
+++ b/ql/cashflows/overnightindexedcoupon.hpp
@@ -152,8 +152,6 @@ namespace QuantLib {
         OvernightLeg& withLookbackDays(Natural lookbackDays);
         OvernightLeg& withLockoutDays(Natural lockoutDays);
         OvernightLeg& withObservationShift(bool applyObservationShift = true);
-        OvernightLeg& withOvernightIndexedCouponPricer(
-            const ext::shared_ptr<OvernightIndexedCouponPricer>& couponPricer);
         operator Leg() const;
       private:
         Schedule schedule_;
@@ -170,8 +168,6 @@ namespace QuantLib {
         Natural lookbackDays_ = Null<Natural>();
         Natural lockoutDays_ = 0;
         bool applyObservationShift_ = false;
-        ext::shared_ptr<OvernightIndexedCouponPricer> couponPricer_ =
-            ext::make_shared<OvernightIndexedCouponPricer>();
     };
 
     inline const bool OvernightIndexedCoupon::canApplyTelescopicFormula() const {

From 09dc04214b10fc66bd58fe734d82426a77901d58 Mon Sep 17 00:00:00 2001
From: ralfkonrad <github@eckel-consulting.de>
Date: Mon, 29 Jul 2024 14:43:30 +0200
Subject: [PATCH 04/10] Renamed pricer to
 CompoudingOvernightIndexedCouponPricer

---
 ql/cashflows/overnightindexedcoupon.cpp | 18 +++++++++---------
 ql/cashflows/overnightindexedcoupon.hpp |  4 ++--
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/ql/cashflows/overnightindexedcoupon.cpp b/ql/cashflows/overnightindexedcoupon.cpp
index 43381b70533..29ecb1a5374 100644
--- a/ql/cashflows/overnightindexedcoupon.cpp
+++ b/ql/cashflows/overnightindexedcoupon.cpp
@@ -194,8 +194,8 @@ namespace QuantLib {
                     new ArithmeticAveragedOvernightIndexedCouponPricer(telescopicValueDates)));
                 break;
             case RateAveraging::Compound:
-                setPricer(
-                    ext::shared_ptr<FloatingRateCouponPricer>(new OvernightIndexedCouponPricer));
+                setPricer(ext::shared_ptr<FloatingRateCouponPricer>(
+                    new CompoudingOvernightIndexedCouponPricer));
                 break;
             default:
                 QL_FAIL("unknown compounding convention (" << Integer(averagingMethod) << ")");
@@ -217,10 +217,10 @@ namespace QuantLib {
     Rate OvernightIndexedCoupon::averageRate(const Date& d) const {
         QL_REQUIRE(pricer_, "pricer not set");
         pricer_->initialize(*this);
-        const auto overnightIndexPricer = ext::dynamic_pointer_cast<OvernightIndexedCouponPricer>(pricer_);
-        if (overnightIndexPricer)
-            return overnightIndexPricer->averageRate(d);
-
+        if (const auto compoudingPricer =
+                ext::dynamic_pointer_cast<CompoudingOvernightIndexedCouponPricer>(pricer_)) {
+            return compoudingPricer->averageRate(d);
+        }
         return pricer_->swapletRate();
     }
 
@@ -240,16 +240,16 @@ namespace QuantLib {
         }
     }
 
-    void OvernightIndexedCouponPricer::initialize(const FloatingRateCoupon& coupon) {
+    void CompoudingOvernightIndexedCouponPricer::initialize(const FloatingRateCoupon& coupon) {
         coupon_ = dynamic_cast<const OvernightIndexedCoupon*>(&coupon);
         QL_ENSURE(coupon_, "wrong coupon type");
     }
 
-    Rate OvernightIndexedCouponPricer::swapletRate() const {
+    Rate CompoudingOvernightIndexedCouponPricer::swapletRate() const {
         return averageRate(coupon_->accrualEndDate());
     }
 
-    Rate OvernightIndexedCouponPricer::averageRate(const Date& date) const {
+    Rate CompoudingOvernightIndexedCouponPricer::averageRate(const Date& date) const {
         const Date today = Settings::instance().evaluationDate();
 
         const ext::shared_ptr<OvernightIndex> index =
diff --git a/ql/cashflows/overnightindexedcoupon.hpp b/ql/cashflows/overnightindexedcoupon.hpp
index 8d275a8dcb8..0edcbabede2 100644
--- a/ql/cashflows/overnightindexedcoupon.hpp
+++ b/ql/cashflows/overnightindexedcoupon.hpp
@@ -114,8 +114,8 @@ namespace QuantLib {
         Rate averageRate(const Date& date) const;
     };
 
-    //! OvernightIndexedCoupon pricer
-    class OvernightIndexedCouponPricer : public FloatingRateCouponPricer {
+    //! CompoudAveragedOvernightIndexedCouponPricer pricer
+    class CompoudingOvernightIndexedCouponPricer : public FloatingRateCouponPricer {
       public:
         //! \name FloatingRateCoupon interface
         //@{

From dce7eebc32abeef1783faeadf0be648ac8960ee3 Mon Sep 17 00:00:00 2001
From: ralfkonrad <github@eckel-consulting.de>
Date: Tue, 30 Jul 2024 09:13:29 +0200
Subject: [PATCH 05/10] Fix typo

---
 ql/cashflows/overnightindexedcoupon.cpp | 10 +++++-----
 ql/cashflows/overnightindexedcoupon.hpp |  2 +-
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/ql/cashflows/overnightindexedcoupon.cpp b/ql/cashflows/overnightindexedcoupon.cpp
index 29ecb1a5374..48685e124aa 100644
--- a/ql/cashflows/overnightindexedcoupon.cpp
+++ b/ql/cashflows/overnightindexedcoupon.cpp
@@ -195,7 +195,7 @@ namespace QuantLib {
                 break;
             case RateAveraging::Compound:
                 setPricer(ext::shared_ptr<FloatingRateCouponPricer>(
-                    new CompoudingOvernightIndexedCouponPricer));
+                    new CompoundingOvernightIndexedCouponPricer));
                 break;
             default:
                 QL_FAIL("unknown compounding convention (" << Integer(averagingMethod) << ")");
@@ -218,7 +218,7 @@ namespace QuantLib {
         QL_REQUIRE(pricer_, "pricer not set");
         pricer_->initialize(*this);
         if (const auto compoudingPricer =
-                ext::dynamic_pointer_cast<CompoudingOvernightIndexedCouponPricer>(pricer_)) {
+                ext::dynamic_pointer_cast<CompoundingOvernightIndexedCouponPricer>(pricer_)) {
             return compoudingPricer->averageRate(d);
         }
         return pricer_->swapletRate();
@@ -240,16 +240,16 @@ namespace QuantLib {
         }
     }
 
-    void CompoudingOvernightIndexedCouponPricer::initialize(const FloatingRateCoupon& coupon) {
+    void CompoundingOvernightIndexedCouponPricer::initialize(const FloatingRateCoupon& coupon) {
         coupon_ = dynamic_cast<const OvernightIndexedCoupon*>(&coupon);
         QL_ENSURE(coupon_, "wrong coupon type");
     }
 
-    Rate CompoudingOvernightIndexedCouponPricer::swapletRate() const {
+    Rate CompoundingOvernightIndexedCouponPricer::swapletRate() const {
         return averageRate(coupon_->accrualEndDate());
     }
 
-    Rate CompoudingOvernightIndexedCouponPricer::averageRate(const Date& date) const {
+    Rate CompoundingOvernightIndexedCouponPricer::averageRate(const Date& date) const {
         const Date today = Settings::instance().evaluationDate();
 
         const ext::shared_ptr<OvernightIndex> index =
diff --git a/ql/cashflows/overnightindexedcoupon.hpp b/ql/cashflows/overnightindexedcoupon.hpp
index 0edcbabede2..4613e7cde4b 100644
--- a/ql/cashflows/overnightindexedcoupon.hpp
+++ b/ql/cashflows/overnightindexedcoupon.hpp
@@ -115,7 +115,7 @@ namespace QuantLib {
     };
 
     //! CompoudAveragedOvernightIndexedCouponPricer pricer
-    class CompoudingOvernightIndexedCouponPricer : public FloatingRateCouponPricer {
+    class CompoundingOvernightIndexedCouponPricer : public FloatingRateCouponPricer {
       public:
         //! \name FloatingRateCoupon interface
         //@{

From 8425c5040e6575e6272479f93fffb5d885a06304 Mon Sep 17 00:00:00 2001
From: ralfkonrad <github@eckel-consulting.de>
Date: Tue, 30 Jul 2024 18:12:40 +0200
Subject: [PATCH 06/10] Move CompoundingOvernightIndexedCouponPricer into
 overnightindexedcouponpricer files

---
 QuantLib.vcxproj                              |   2 +
 QuantLib.vcxproj.filters                      |   6 +
 ql/CMakeLists.txt                             |   2 +
 ql/cashflows/Makefile.am                      |   2 +
 ql/cashflows/all.hpp                          |   1 +
 ql/cashflows/overnightindexedcoupon.cpp       | 149 +--------------
 ql/cashflows/overnightindexedcoupon.hpp       |  19 --
 ql/cashflows/overnightindexedcouponpricer.cpp | 179 ++++++++++++++++++
 ql/cashflows/overnightindexedcouponpricer.hpp |  57 ++++++
 9 files changed, 250 insertions(+), 167 deletions(-)
 create mode 100644 ql/cashflows/overnightindexedcouponpricer.cpp
 create mode 100644 ql/cashflows/overnightindexedcouponpricer.hpp

diff --git a/QuantLib.vcxproj b/QuantLib.vcxproj
index a0bbb274750..2b328cd6e41 100644
--- a/QuantLib.vcxproj
+++ b/QuantLib.vcxproj
@@ -534,6 +534,7 @@
     <ClInclude Include="ql\cashflows\inflationcouponpricer.hpp" />
     <ClInclude Include="ql\cashflows\lineartsrpricer.hpp" />
     <ClInclude Include="ql\cashflows\overnightindexedcoupon.hpp" />
+    <ClInclude Include="ql\cashflows\overnightindexedcouponpricer.hpp" />
     <ClInclude Include="ql\cashflows\rangeaccrual.hpp" />
     <ClInclude Include="ql\cashflows\rateaveraging.hpp" />
     <ClInclude Include="ql\cashflows\replication.hpp" />
@@ -1933,6 +1934,7 @@
     <ClCompile Include="ql\cashflows\inflationcouponpricer.cpp" />
     <ClCompile Include="ql\cashflows\lineartsrpricer.cpp" />
     <ClCompile Include="ql\cashflows\overnightindexedcoupon.cpp" />
+    <ClCompile Include="ql\cashflows\overnightindexedcouponpricer.cpp" />
     <ClCompile Include="ql\cashflows\rangeaccrual.cpp" />
     <ClCompile Include="ql\cashflows\replication.cpp" />
     <ClCompile Include="ql\cashflows\simplecashflow.cpp" />
diff --git a/QuantLib.vcxproj.filters b/QuantLib.vcxproj.filters
index 8b09bc52e18..106f34be392 100644
--- a/QuantLib.vcxproj.filters
+++ b/QuantLib.vcxproj.filters
@@ -561,6 +561,9 @@
     <ClInclude Include="ql\cashflows\overnightindexedcoupon.hpp">
       <Filter>cashflows</Filter>
     </ClInclude>
+    <ClInclude Include="ql\cashflows\overnightindexedcouponpricer.hpp">
+      <Filter>cashflows</Filter>
+    </ClInclude>
     <ClInclude Include="ql\cashflows\rangeaccrual.hpp">
       <Filter>cashflows</Filter>
     </ClInclude>
@@ -4544,6 +4547,9 @@
     <ClCompile Include="ql\cashflows\overnightindexedcoupon.cpp">
       <Filter>cashflows</Filter>
     </ClCompile>
+    <ClCompile Include="ql\cashflows\overnightindexedcouponpricer.cpp">
+      <Filter>cashflows</Filter>
+    </ClCompile>
     <ClCompile Include="ql\cashflows\rangeaccrual.cpp">
       <Filter>cashflows</Filter>
     </ClCompile>
diff --git a/ql/CMakeLists.txt b/ql/CMakeLists.txt
index e000e1c276c..1887b1c70e8 100644
--- a/ql/CMakeLists.txt
+++ b/ql/CMakeLists.txt
@@ -25,6 +25,7 @@ set(QL_SOURCES
     cashflows/inflationcouponpricer.cpp
     cashflows/lineartsrpricer.cpp
     cashflows/overnightindexedcoupon.cpp
+    cashflows/overnightindexedcouponpricer.cpp
     cashflows/rangeaccrual.cpp
     cashflows/replication.cpp
     cashflows/simplecashflow.cpp
@@ -961,6 +962,7 @@ set(QL_HEADERS
     cashflows/inflationcouponpricer.hpp
     cashflows/lineartsrpricer.hpp
     cashflows/overnightindexedcoupon.hpp
+    cashflows/overnightindexedcouponpricer.hpp
     cashflows/rangeaccrual.hpp
     cashflows/rateaveraging.hpp
     cashflows/replication.hpp
diff --git a/ql/cashflows/Makefile.am b/ql/cashflows/Makefile.am
index 5320f812c93..f45d7c0274b 100644
--- a/ql/cashflows/Makefile.am
+++ b/ql/cashflows/Makefile.am
@@ -29,6 +29,7 @@ this_include_HEADERS = \
     inflationcouponpricer.hpp \
     lineartsrpricer.hpp \
     overnightindexedcoupon.hpp \
+    overnightindexedcouponpricer.hpp \
     rangeaccrual.hpp \
     rateaveraging.hpp \
     replication.hpp \
@@ -64,6 +65,7 @@ cpp_files = \
     inflationcouponpricer.cpp \
     lineartsrpricer.cpp \
     overnightindexedcoupon.cpp \
+    overnightindexedcouponpricer.cpp \
     rangeaccrual.cpp \
     replication.cpp \
     simplecashflow.cpp \
diff --git a/ql/cashflows/all.hpp b/ql/cashflows/all.hpp
index 59ee0ab2e11..ef579427e71 100644
--- a/ql/cashflows/all.hpp
+++ b/ql/cashflows/all.hpp
@@ -26,6 +26,7 @@
 #include <ql/cashflows/inflationcouponpricer.hpp>
 #include <ql/cashflows/lineartsrpricer.hpp>
 #include <ql/cashflows/overnightindexedcoupon.hpp>
+#include <ql/cashflows/overnightindexedcouponpricer.hpp>
 #include <ql/cashflows/rangeaccrual.hpp>
 #include <ql/cashflows/rateaveraging.hpp>
 #include <ql/cashflows/replication.hpp>
diff --git a/ql/cashflows/overnightindexedcoupon.cpp b/ql/cashflows/overnightindexedcoupon.cpp
index 48685e124aa..1d2a2992193 100644
--- a/ql/cashflows/overnightindexedcoupon.cpp
+++ b/ql/cashflows/overnightindexedcoupon.cpp
@@ -22,6 +22,7 @@
 */
 
 #include <ql/cashflows/couponpricer.hpp>
+#include <ql/cashflows/overnightindexedcouponpricer.hpp>
 #include <ql/experimental/averageois/averageoiscouponpricer.hpp>
 #include <ql/cashflows/overnightindexedcoupon.hpp>
 #include <ql/termstructures/yieldtermstructure.hpp>
@@ -34,20 +35,6 @@ using std::vector;
 namespace QuantLib {
 
     namespace {
-
-        Size determineNumberOfFixings(const vector<Date>& interestDates,
-                                      const Date& date,
-                                      bool applyObservationShift) {
-            Size n =
-                std::lower_bound(interestDates.begin(), interestDates.end(), date) - interestDates.begin();
-            // When using the observation shift, it may happen that
-            // that the end of accrual period will fall later than the last
-            // interest date. In which case, n will be equal to the number of
-            // interest dates, while we know that the number of fixing dates is
-            // always one less than the number of interest dates.
-            return n == interestDates.size() && applyObservationShift ? n - 1 : n;
-        }
-
         Date applyLookbackPeriod(const ext::shared_ptr<InterestRateIndex>& index,
                                  const Date& valueDate,
                                  Natural lookbackDays) {
@@ -240,140 +227,6 @@ namespace QuantLib {
         }
     }
 
-    void CompoundingOvernightIndexedCouponPricer::initialize(const FloatingRateCoupon& coupon) {
-        coupon_ = dynamic_cast<const OvernightIndexedCoupon*>(&coupon);
-        QL_ENSURE(coupon_, "wrong coupon type");
-    }
-
-    Rate CompoundingOvernightIndexedCouponPricer::swapletRate() const {
-        return averageRate(coupon_->accrualEndDate());
-    }
-
-    Rate CompoundingOvernightIndexedCouponPricer::averageRate(const Date& date) const {
-        const Date today = Settings::instance().evaluationDate();
-
-        const ext::shared_ptr<OvernightIndex> index =
-            ext::dynamic_pointer_cast<OvernightIndex>(coupon_->index());
-        const auto& pastFixings = IndexManager::instance().getHistory(index->name());
-
-        const vector<Date>& fixingDates = coupon_->fixingDates();
-        const vector<Date>& valueDates = coupon_->valueDates();
-        const vector<Date>& interestDates = coupon_->interestDates();
-        const vector<Time>& dt = coupon_->dt();
-        const bool applyObservationShift = coupon_->applyObservationShift();
-
-        Size i = 0;
-        const Size n = determineNumberOfFixings(interestDates, date, applyObservationShift);
-
-        Real compoundFactor = 1.0;
-
-        // already fixed part
-        while (i < n && fixingDates[i] < today) {
-            // rate must have been fixed
-            const Rate fixing = pastFixings[fixingDates[i]];
-            QL_REQUIRE(fixing != Null<Real>(),
-                       "Missing " << index->name() << " fixing for " << fixingDates[i]);
-            Time span = (date >= interestDates[i + 1] ?
-                             dt[i] :
-                             index->dayCounter().yearFraction(interestDates[i], date));
-            compoundFactor *= (1.0 + fixing * span);
-            ++i;
-        }
-
-        // today is a border case
-        if (i < n && fixingDates[i] == today) {
-            // might have been fixed
-            try {
-                Rate fixing = pastFixings[fixingDates[i]];
-                if (fixing != Null<Real>()) {
-                    Time span = (date >= interestDates[i + 1] ?
-                                     dt[i] :
-                                     index->dayCounter().yearFraction(interestDates[i], date));
-                    compoundFactor *= (1.0 + fixing * span);
-                    ++i;
-                } else {
-                    ; // fall through and forecast
-                }
-            } catch (Error&) {
-                ; // fall through and forecast
-            }
-        }
-
-        // forward part using telescopic property in order
-        // to avoid the evaluation of multiple forward fixings
-        // where possible.
-        if (i < n) {
-            const Handle<YieldTermStructure> curve = index->forwardingTermStructure();
-            QL_REQUIRE(!curve.empty(),
-                       "null term structure set to this instance of " << index->name());
-
-            const auto effectiveRate = [&index, &fixingDates, &date, &interestDates,
-                                        &dt](Size position) {
-                Rate fixing = index->fixing(fixingDates[position]);
-                Time span = (date >= interestDates[position + 1] ?
-                                 dt[position] :
-                                 index->dayCounter().yearFraction(interestDates[position], date));
-                return span * fixing;
-            };
-
-            if (!coupon_->canApplyTelescopicFormula()) {
-                // With lookback applied, the telescopic formula cannot be used,
-                // we need to project each fixing in the coupon.
-                // Only in one particular case when observation shift is used and
-                // no intrinsic index fixing delay is applied, the telescopic formula
-                // holds, because regardless of the fixing delay in the coupon,
-                // in such configuration value dates will be equal to interest dates.
-                // A potential lockout, which may occur in tandem with a lookback
-                // setting, will be handled automatically based on fixing dates.
-                // Same applies to a case when accrual calculation date does or
-                // does not occur on an interest date.
-                while (i < n) {
-                    compoundFactor *= (1.0 + effectiveRate(i));
-                    ++i;
-                }
-            } else {
-                // No lookback, we can partially apply the telescopic formula.
-                // But we need to make a correction for a potential lockout.
-                const Size nLockout = n - coupon_->lockoutDays();
-                const bool isLockoutApplied = coupon_->lockoutDays() > 0;
-
-                // Lockout could already start at or before i.
-                // In such case the ratio of discount factors will be equal to 1.
-                const DiscountFactor startDiscount =
-                    curve->discount(valueDates[std::min<Size>(nLockout, i)]);
-                if (interestDates[n] == date || isLockoutApplied) {
-                    // telescopic formula up to potential lockout dates.
-                    const DiscountFactor endDiscount =
-                        curve->discount(valueDates[std::min<Size>(nLockout, n)]);
-                    compoundFactor *= startDiscount / endDiscount;
-                    // For the lockout periods the telescopic formula does not apply.
-                    // The value dates (at which the projection is calculated) correspond
-                    // to the locked-out fixing, while the interest dates (at which the
-                    // interest over that fixing is accrued) are not fixed at lockout,
-                    // hence they do not cancel out.
-                    i = std::max(nLockout, i);
-
-                    // With no lockout, the loop is skipped because i = n.
-                    while (i < n) {
-                        compoundFactor *= (1.0 + effectiveRate(i));
-                        ++i;
-                    }
-                } else {
-                    // No lockout and date is different than last interest date.
-                    // The last fixing is not used for its full period (the date is between
-                    // its start and end date).  We can use the telescopic formula until the
-                    // previous date, then we'll add the missing bit.
-                    const DiscountFactor endDiscount = curve->discount(valueDates[n - 1]);
-                    compoundFactor *= startDiscount / endDiscount;
-                    compoundFactor *= (1.0 + effectiveRate(n - 1));
-                }
-            }
-        }
-
-        const Rate rate = (compoundFactor - 1.0) / coupon_->accruedPeriod(date);
-        return coupon_->gearing() * rate + coupon_->spread();
-    }
-
     OvernightLeg::OvernightLeg(Schedule schedule, ext::shared_ptr<OvernightIndex> i)
     : schedule_(std::move(schedule)), overnightIndex_(std::move(i)), paymentCalendar_(schedule_.calendar()) {
         QL_REQUIRE(overnightIndex_, "no index provided");
diff --git a/ql/cashflows/overnightindexedcoupon.hpp b/ql/cashflows/overnightindexedcoupon.hpp
index 4613e7cde4b..ed9363baa67 100644
--- a/ql/cashflows/overnightindexedcoupon.hpp
+++ b/ql/cashflows/overnightindexedcoupon.hpp
@@ -114,25 +114,6 @@ namespace QuantLib {
         Rate averageRate(const Date& date) const;
     };
 
-    //! CompoudAveragedOvernightIndexedCouponPricer pricer
-    class CompoundingOvernightIndexedCouponPricer : public FloatingRateCouponPricer {
-      public:
-        //! \name FloatingRateCoupon interface
-        //@{
-        void initialize(const FloatingRateCoupon& coupon) override;
-        Rate swapletRate() const override;
-        Real swapletPrice() const override { QL_FAIL("swapletPrice not available"); }
-        Real capletPrice(Rate) const override { QL_FAIL("capletPrice not available"); }
-        Rate capletRate(Rate) const override { QL_FAIL("capletRate not available"); }
-        Real floorletPrice(Rate) const override { QL_FAIL("floorletPrice not available"); }
-        Rate floorletRate(Rate) const override { QL_FAIL("floorletRate not available"); }
-        //@}
-        Rate averageRate(const Date& date) const;
-
-      protected:
-        const OvernightIndexedCoupon* coupon_ = nullptr;
-    };
-
     //! helper class building a sequence of overnight coupons
     class OvernightLeg {
       public:
diff --git a/ql/cashflows/overnightindexedcouponpricer.cpp b/ql/cashflows/overnightindexedcouponpricer.cpp
new file mode 100644
index 00000000000..586b318ca3c
--- /dev/null
+++ b/ql/cashflows/overnightindexedcouponpricer.cpp
@@ -0,0 +1,179 @@
+/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*
+ Copyright (C) 2009 Roland Lichters
+ Copyright (C) 2009 Ferdinando Ametrano
+ Copyright (C) 2014 Peter Caspers
+ Copyright (C) 2017 Joseph Jeisman
+ Copyright (C) 2017 Fabrice Lecuyer
+
+ 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.
+*/
+
+#include <ql/cashflows/overnightindexedcouponpricer.hpp>
+
+using std::vector;
+
+namespace QuantLib {
+
+    namespace {
+
+        Size determineNumberOfFixings(const vector<Date>& interestDates,
+                                      const Date& date,
+                                      bool applyObservationShift) {
+            Size n = std::lower_bound(interestDates.begin(), interestDates.end(), date) -
+                     interestDates.begin();
+            // When using the observation shift, it may happen that
+            // that the end of accrual period will fall later than the last
+            // interest date. In which case, n will be equal to the number of
+            // interest dates, while we know that the number of fixing dates is
+            // always one less than the number of interest dates.
+            return n == interestDates.size() && applyObservationShift ? n - 1 : n;
+        }
+    }
+
+    void CompoundingOvernightIndexedCouponPricer::initialize(const FloatingRateCoupon& coupon) {
+        coupon_ = dynamic_cast<const OvernightIndexedCoupon*>(&coupon);
+        QL_ENSURE(coupon_, "wrong coupon type");
+    }
+
+    Rate CompoundingOvernightIndexedCouponPricer::swapletRate() const {
+        return averageRate(coupon_->accrualEndDate());
+    }
+
+    Rate CompoundingOvernightIndexedCouponPricer::averageRate(const Date& date) const {
+        const Date today = Settings::instance().evaluationDate();
+
+        const ext::shared_ptr<OvernightIndex> index =
+            ext::dynamic_pointer_cast<OvernightIndex>(coupon_->index());
+        const auto& pastFixings = IndexManager::instance().getHistory(index->name());
+
+        const vector<Date>& fixingDates = coupon_->fixingDates();
+        const vector<Date>& valueDates = coupon_->valueDates();
+        const vector<Date>& interestDates = coupon_->interestDates();
+        const vector<Time>& dt = coupon_->dt();
+        const bool applyObservationShift = coupon_->applyObservationShift();
+
+        Size i = 0;
+        const Size n = determineNumberOfFixings(interestDates, date, applyObservationShift);
+
+        Real compoundFactor = 1.0;
+
+        // already fixed part
+        while (i < n && fixingDates[i] < today) {
+            // rate must have been fixed
+            const Rate fixing = pastFixings[fixingDates[i]];
+            QL_REQUIRE(fixing != Null<Real>(),
+                       "Missing " << index->name() << " fixing for " << fixingDates[i]);
+            Time span = (date >= interestDates[i + 1] ?
+                             dt[i] :
+                             index->dayCounter().yearFraction(interestDates[i], date));
+            compoundFactor *= (1.0 + fixing * span);
+            ++i;
+        }
+
+        // today is a border case
+        if (i < n && fixingDates[i] == today) {
+            // might have been fixed
+            try {
+                Rate fixing = pastFixings[fixingDates[i]];
+                if (fixing != Null<Real>()) {
+                    Time span = (date >= interestDates[i + 1] ?
+                                     dt[i] :
+                                     index->dayCounter().yearFraction(interestDates[i], date));
+                    compoundFactor *= (1.0 + fixing * span);
+                    ++i;
+                } else {
+                    ; // fall through and forecast
+                }
+            } catch (Error&) {
+                ; // fall through and forecast
+            }
+        }
+
+        // forward part using telescopic property in order
+        // to avoid the evaluation of multiple forward fixings
+        // where possible.
+        if (i < n) {
+            const Handle<YieldTermStructure> curve = index->forwardingTermStructure();
+            QL_REQUIRE(!curve.empty(),
+                       "null term structure set to this instance of " << index->name());
+
+            const auto effectiveRate = [&index, &fixingDates, &date, &interestDates,
+                                        &dt](Size position) {
+                Rate fixing = index->fixing(fixingDates[position]);
+                Time span = (date >= interestDates[position + 1] ?
+                                 dt[position] :
+                                 index->dayCounter().yearFraction(interestDates[position], date));
+                return span * fixing;
+            };
+
+            if (!coupon_->canApplyTelescopicFormula()) {
+                // With lookback applied, the telescopic formula cannot be used,
+                // we need to project each fixing in the coupon.
+                // Only in one particular case when observation shift is used and
+                // no intrinsic index fixing delay is applied, the telescopic formula
+                // holds, because regardless of the fixing delay in the coupon,
+                // in such configuration value dates will be equal to interest dates.
+                // A potential lockout, which may occur in tandem with a lookback
+                // setting, will be handled automatically based on fixing dates.
+                // Same applies to a case when accrual calculation date does or
+                // does not occur on an interest date.
+                while (i < n) {
+                    compoundFactor *= (1.0 + effectiveRate(i));
+                    ++i;
+                }
+            } else {
+                // No lookback, we can partially apply the telescopic formula.
+                // But we need to make a correction for a potential lockout.
+                const Size nLockout = n - coupon_->lockoutDays();
+                const bool isLockoutApplied = coupon_->lockoutDays() > 0;
+
+                // Lockout could already start at or before i.
+                // In such case the ratio of discount factors will be equal to 1.
+                const DiscountFactor startDiscount =
+                    curve->discount(valueDates[std::min<Size>(nLockout, i)]);
+                if (interestDates[n] == date || isLockoutApplied) {
+                    // telescopic formula up to potential lockout dates.
+                    const DiscountFactor endDiscount =
+                        curve->discount(valueDates[std::min<Size>(nLockout, n)]);
+                    compoundFactor *= startDiscount / endDiscount;
+                    // For the lockout periods the telescopic formula does not apply.
+                    // The value dates (at which the projection is calculated) correspond
+                    // to the locked-out fixing, while the interest dates (at which the
+                    // interest over that fixing is accrued) are not fixed at lockout,
+                    // hence they do not cancel out.
+                    i = std::max(nLockout, i);
+
+                    // With no lockout, the loop is skipped because i = n.
+                    while (i < n) {
+                        compoundFactor *= (1.0 + effectiveRate(i));
+                        ++i;
+                    }
+                } else {
+                    // No lockout and date is different than last interest date.
+                    // The last fixing is not used for its full period (the date is between
+                    // its start and end date).  We can use the telescopic formula until the
+                    // previous date, then we'll add the missing bit.
+                    const DiscountFactor endDiscount = curve->discount(valueDates[n - 1]);
+                    compoundFactor *= startDiscount / endDiscount;
+                    compoundFactor *= (1.0 + effectiveRate(n - 1));
+                }
+            }
+        }
+
+        const Rate rate = (compoundFactor - 1.0) / coupon_->accruedPeriod(date);
+        return coupon_->gearing() * rate + coupon_->spread();
+    }
+}
diff --git a/ql/cashflows/overnightindexedcouponpricer.hpp b/ql/cashflows/overnightindexedcouponpricer.hpp
new file mode 100644
index 00000000000..b22b36c66b0
--- /dev/null
+++ b/ql/cashflows/overnightindexedcouponpricer.hpp
@@ -0,0 +1,57 @@
+/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*
+ Copyright (C) 2009 Roland Lichters
+ Copyright (C) 2009 Ferdinando Ametrano
+ Copyright (C) 2014 Peter Caspers
+ Copyright (C) 2017 Joseph Jeisman
+ Copyright (C) 2017 Fabrice Lecuyer
+
+ 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 overnightindexedcouponpricer.hpp
+    \brief contains the pricer for an OvernightIndexedCoupon
+*/
+
+#ifndef quantlib_overnight_indexed_coupon_pricer_hpp
+#define quantlib_overnight_indexed_coupon_pricer_hpp
+
+#include <ql/cashflows/couponpricer.hpp>
+#include <ql/cashflows/floatingratecoupon.hpp>
+#include <ql/cashflows/overnightindexedcoupon.hpp>
+
+namespace QuantLib {
+
+    //! CompoudAveragedOvernightIndexedCouponPricer pricer
+    class CompoundingOvernightIndexedCouponPricer : public FloatingRateCouponPricer {
+      public:
+        //! \name FloatingRateCoupon interface
+        //@{
+        void initialize(const FloatingRateCoupon& coupon) override;
+        Rate swapletRate() const override;
+        Real swapletPrice() const override { QL_FAIL("swapletPrice not available"); }
+        Real capletPrice(Rate) const override { QL_FAIL("capletPrice not available"); }
+        Rate capletRate(Rate) const override { QL_FAIL("capletRate not available"); }
+        Real floorletPrice(Rate) const override { QL_FAIL("floorletPrice not available"); }
+        Rate floorletRate(Rate) const override { QL_FAIL("floorletRate not available"); }
+        //@}
+        Rate averageRate(const Date& date) const;
+
+      protected:
+        const OvernightIndexedCoupon* coupon_ = nullptr;
+    };
+}
+
+#endif

From 3ac875295491b84e13aa044174e565ec81cc6b92 Mon Sep 17 00:00:00 2001
From: ralfkonrad <github@eckel-consulting.de>
Date: Tue, 30 Jul 2024 18:34:46 +0200
Subject: [PATCH 07/10] Move ArithmeticAveragedOvernightIndexedCouponPricer
 into overnightindexedcouponpricer files

---
 QuantLib.vcxproj                              |   1 -
 QuantLib.vcxproj.filters                      |   3 -
 ql/CMakeLists.txt                             |   1 -
 ql/cashflows/overnightindexedcoupon.cpp       |   1 -
 ql/cashflows/overnightindexedcouponpricer.cpp | 114 +++++++++++++-
 ql/cashflows/overnightindexedcouponpricer.hpp |  34 ++++
 ql/experimental/averageois/Makefile.am        |   1 -
 .../averageois/arithmeticaverageois.cpp       |   2 +-
 .../averageois/averageoiscouponpricer.cpp     | 146 ------------------
 .../averageois/averageoiscouponpricer.hpp     |  44 +-----
 10 files changed, 146 insertions(+), 201 deletions(-)
 delete mode 100644 ql/experimental/averageois/averageoiscouponpricer.cpp

diff --git a/QuantLib.vcxproj b/QuantLib.vcxproj
index 2b328cd6e41..c9e69684b9d 100644
--- a/QuantLib.vcxproj
+++ b/QuantLib.vcxproj
@@ -1953,7 +1953,6 @@
     <ClCompile Include="ql\experimental\asian\analytic_discr_geom_av_price_heston.cpp" />
     <ClCompile Include="ql\experimental\averageois\arithmeticaverageois.cpp" />
     <ClCompile Include="ql\experimental\averageois\arithmeticoisratehelper.cpp" />
-    <ClCompile Include="ql\experimental\averageois\averageoiscouponpricer.cpp" />
     <ClCompile Include="ql\experimental\averageois\makearithmeticaverageois.cpp" />
     <ClCompile Include="ql\experimental\barrieroption\discretizeddoublebarrieroption.cpp" />
     <ClCompile Include="ql\experimental\barrieroption\mcdoublebarrierengine.cpp" />
diff --git a/QuantLib.vcxproj.filters b/QuantLib.vcxproj.filters
index 106f34be392..001b00b67ee 100644
--- a/QuantLib.vcxproj.filters
+++ b/QuantLib.vcxproj.filters
@@ -6596,9 +6596,6 @@
     <ClCompile Include="ql\experimental\averageois\arithmeticaverageois.cpp">
       <Filter>experimental\averageois</Filter>
     </ClCompile>
-    <ClCompile Include="ql\experimental\averageois\averageoiscouponpricer.cpp">
-      <Filter>experimental\averageois</Filter>
-    </ClCompile>
     <ClCompile Include="ql\experimental\averageois\arithmeticoisratehelper.cpp">
       <Filter>experimental\averageois</Filter>
     </ClCompile>
diff --git a/ql/CMakeLists.txt b/ql/CMakeLists.txt
index 1887b1c70e8..ca7950156d0 100644
--- a/ql/CMakeLists.txt
+++ b/ql/CMakeLists.txt
@@ -50,7 +50,6 @@ set(QL_SOURCES
     experimental/asian/analytic_discr_geom_av_price_heston.cpp
     experimental/averageois/arithmeticaverageois.cpp
     experimental/averageois/arithmeticoisratehelper.cpp
-    experimental/averageois/averageoiscouponpricer.cpp
     experimental/averageois/makearithmeticaverageois.cpp
     experimental/barrieroption/mcdoublebarrierengine.cpp
     experimental/barrieroption/discretizeddoublebarrieroption.cpp
diff --git a/ql/cashflows/overnightindexedcoupon.cpp b/ql/cashflows/overnightindexedcoupon.cpp
index 1d2a2992193..9a975808b2a 100644
--- a/ql/cashflows/overnightindexedcoupon.cpp
+++ b/ql/cashflows/overnightindexedcoupon.cpp
@@ -23,7 +23,6 @@
 
 #include <ql/cashflows/couponpricer.hpp>
 #include <ql/cashflows/overnightindexedcouponpricer.hpp>
-#include <ql/experimental/averageois/averageoiscouponpricer.hpp>
 #include <ql/cashflows/overnightindexedcoupon.hpp>
 #include <ql/termstructures/yieldtermstructure.hpp>
 #include <ql/utilities/vectors.hpp>
diff --git a/ql/cashflows/overnightindexedcouponpricer.cpp b/ql/cashflows/overnightindexedcouponpricer.cpp
index 586b318ca3c..98d78ff9863 100644
--- a/ql/cashflows/overnightindexedcouponpricer.cpp
+++ b/ql/cashflows/overnightindexedcouponpricer.cpp
@@ -4,6 +4,7 @@
  Copyright (C) 2009 Roland Lichters
  Copyright (C) 2009 Ferdinando Ametrano
  Copyright (C) 2014 Peter Caspers
+ Copyright (C) 2016 Stefano Fondi
  Copyright (C) 2017 Joseph Jeisman
  Copyright (C) 2017 Fabrice Lecuyer
 
@@ -23,13 +24,11 @@
 
 #include <ql/cashflows/overnightindexedcouponpricer.hpp>
 
-using std::vector;
-
 namespace QuantLib {
 
     namespace {
 
-        Size determineNumberOfFixings(const vector<Date>& interestDates,
+        Size determineNumberOfFixings(const std::vector<Date>& interestDates,
                                       const Date& date,
                                       bool applyObservationShift) {
             Size n = std::lower_bound(interestDates.begin(), interestDates.end(), date) -
@@ -59,10 +58,10 @@ namespace QuantLib {
             ext::dynamic_pointer_cast<OvernightIndex>(coupon_->index());
         const auto& pastFixings = IndexManager::instance().getHistory(index->name());
 
-        const vector<Date>& fixingDates = coupon_->fixingDates();
-        const vector<Date>& valueDates = coupon_->valueDates();
-        const vector<Date>& interestDates = coupon_->interestDates();
-        const vector<Time>& dt = coupon_->dt();
+        const auto& fixingDates = coupon_->fixingDates();
+        const auto& valueDates = coupon_->valueDates();
+        const auto& interestDates = coupon_->interestDates();
+        const auto& dt = coupon_->dt();
         const bool applyObservationShift = coupon_->applyObservationShift();
 
         Size i = 0;
@@ -176,4 +175,105 @@ namespace QuantLib {
         const Rate rate = (compoundFactor - 1.0) / coupon_->accruedPeriod(date);
         return coupon_->gearing() * rate + coupon_->spread();
     }
+
+    void
+    ArithmeticAveragedOvernightIndexedCouponPricer::initialize(const FloatingRateCoupon& coupon) {
+        coupon_ = dynamic_cast<const OvernightIndexedCoupon*>(&coupon);
+        QL_ENSURE(coupon_, "wrong coupon type");
+    }
+
+    Rate ArithmeticAveragedOvernightIndexedCouponPricer::swapletRate() const {
+
+        ext::shared_ptr<OvernightIndex> index =
+            ext::dynamic_pointer_cast<OvernightIndex>(coupon_->index());
+
+        const auto& fixingDates = coupon_->fixingDates();
+        const auto& dt = coupon_->dt();
+
+        Size n = dt.size(), i = 0;
+
+        Real accumulatedRate = 0.0;
+
+        // already fixed part
+        Date today = Settings::instance().evaluationDate();
+        while (i < n && fixingDates[i] < today) {
+            // rate must have been fixed
+            Rate pastFixing = IndexManager::instance().getHistory(index->name())[fixingDates[i]];
+            QL_REQUIRE(pastFixing != Null<Real>(),
+                       "Missing " << index->name() << " fixing for " << fixingDates[i]);
+            accumulatedRate += pastFixing * dt[i];
+            ++i;
+        }
+
+        // today is a border case
+        if (i < n && fixingDates[i] == today) {
+            // might have been fixed
+            try {
+                Rate pastFixing =
+                    IndexManager::instance().getHistory(index->name())[fixingDates[i]];
+                if (pastFixing != Null<Real>()) {
+                    accumulatedRate += pastFixing * dt[i];
+                    ++i;
+                } else {
+                    ; // fall through and forecast
+                }
+            } catch (Error&) {
+                ; // fall through and forecast
+            }
+        }
+
+        /* forward part using telescopic property in order
+        to avoid the evaluation of multiple forward fixings
+        (approximation proposed by Katsumi Takada)*/
+        if (byApprox_ && i < n) {
+            Handle<YieldTermStructure> curve = index->forwardingTermStructure();
+            QL_REQUIRE(!curve.empty(),
+                       "null term structure set to this instance of " << index->name());
+
+            const auto& dates = coupon_->valueDates();
+            DiscountFactor startDiscount = curve->discount(dates[i]);
+            DiscountFactor endDiscount = curve->discount(dates[n]);
+
+            accumulatedRate +=
+                log(startDiscount / endDiscount) -
+                convAdj1(curve->timeFromReference(dates[i]), curve->timeFromReference(dates[n])) -
+                convAdj2(curve->timeFromReference(dates[i]), curve->timeFromReference(dates[n]));
+        }
+        // otherwise
+        else if (i < n) {
+            Handle<YieldTermStructure> curve = index->forwardingTermStructure();
+            QL_REQUIRE(!curve.empty(),
+                       "null term structure set to this instance of " << index->name());
+
+            const auto& dates = coupon_->valueDates();
+            Time te = curve->timeFromReference(dates[n]);
+            while (i < n) {
+                // forcast fixing
+                Rate forecastFixing = index->fixing(fixingDates[i]);
+                Time ti1 = curve->timeFromReference(dates[i]);
+                Time ti2 = curve->timeFromReference(dates[i + 1]);
+                /*convexity adjustment due to payment dalay of each
+                overnight fixing, supposing an Hull-White short rate model*/
+                Real convAdj = exp(
+                    0.5 * pow(vol_, 2.0) / pow(mrs_, 3.0) * (exp(2 * mrs_ * ti1) - 1) *
+                    (exp(-mrs_ * ti2) - exp(-mrs_ * te)) * (exp(-mrs_ * ti2) - exp(-mrs_ * ti1)));
+                accumulatedRate += convAdj * (1 + forecastFixing * dt[i]) - 1;
+                ++i;
+            }
+        }
+
+        Rate rate = accumulatedRate / coupon_->accrualPeriod();
+        return coupon_->gearing() * rate + coupon_->spread();
+    }
+
+    Real ArithmeticAveragedOvernightIndexedCouponPricer::convAdj1(Time ts, Time te) const {
+        return vol_ * vol_ / (4.0 * pow(mrs_, 3.0)) * (1.0 - exp(-2.0 * mrs_ * ts)) *
+               pow((1.0 - exp(-mrs_ * (te - ts))), 2.0);
+    }
+
+    Real ArithmeticAveragedOvernightIndexedCouponPricer::convAdj2(Time ts, Time te) const {
+        return vol_ * vol_ / (2.0 * pow(mrs_, 2.0)) *
+               ((te - ts) - pow(1.0 - exp(-mrs_ * (te - ts)), 2.0) / mrs_ -
+                (1.0 - exp(-2.0 * mrs_ * (te - ts))) / (2.0 * mrs_));
+    }
 }
diff --git a/ql/cashflows/overnightindexedcouponpricer.hpp b/ql/cashflows/overnightindexedcouponpricer.hpp
index b22b36c66b0..984af3cf2ac 100644
--- a/ql/cashflows/overnightindexedcouponpricer.hpp
+++ b/ql/cashflows/overnightindexedcouponpricer.hpp
@@ -4,6 +4,7 @@
  Copyright (C) 2009 Roland Lichters
  Copyright (C) 2009 Ferdinando Ametrano
  Copyright (C) 2014 Peter Caspers
+ Copyright (C) 2016 Stefano Fondi
  Copyright (C) 2017 Joseph Jeisman
  Copyright (C) 2017 Fabrice Lecuyer
 
@@ -52,6 +53,39 @@ namespace QuantLib {
       protected:
         const OvernightIndexedCoupon* coupon_ = nullptr;
     };
+
+    /*! pricer for arithmetically averaged overnight indexed coupons
+    Reference: Katsumi Takada 2011, Valuation of Arithmetically Average of
+    Fed Funds Rates and Construction of the US Dollar Swap Yield Curve
+    */
+    class ArithmeticAveragedOvernightIndexedCouponPricer : public FloatingRateCouponPricer {
+      public:
+        explicit ArithmeticAveragedOvernightIndexedCouponPricer(
+            Real meanReversion = 0.03,
+            Real volatility = 0.00, // NO convexity adjustment by default
+            bool byApprox = false)  // TRUE to use Katsumi Takada approximation
+        : byApprox_(byApprox), mrs_(meanReversion), vol_(volatility) {}
+
+        explicit ArithmeticAveragedOvernightIndexedCouponPricer(
+            bool byApprox) // Simplified constructor assuming no convexity correction
+        : ArithmeticAveragedOvernightIndexedCouponPricer(0.03, 0.0, byApprox) {}
+
+        void initialize(const FloatingRateCoupon& coupon) override;
+        Rate swapletRate() const override;
+        Real swapletPrice() const override { QL_FAIL("swapletPrice not available"); }
+        Real capletPrice(Rate) const override { QL_FAIL("capletPrice not available"); }
+        Rate capletRate(Rate) const override { QL_FAIL("capletRate not available"); }
+        Real floorletPrice(Rate) const override { QL_FAIL("floorletPrice not available"); }
+        Rate floorletRate(Rate) const override { QL_FAIL("floorletRate not available"); }
+
+      protected:
+        Real convAdj1(Time ts, Time te) const;
+        Real convAdj2(Time ts, Time te) const;
+        const OvernightIndexedCoupon* coupon_;
+        bool byApprox_;
+        Real mrs_;
+        Real vol_;
+    };
 }
 
 #endif
diff --git a/ql/experimental/averageois/Makefile.am b/ql/experimental/averageois/Makefile.am
index 745b1654eaf..c1909dd7d09 100644
--- a/ql/experimental/averageois/Makefile.am
+++ b/ql/experimental/averageois/Makefile.am
@@ -10,7 +10,6 @@ this_include_HEADERS = \
     makearithmeticaverageois.hpp
 
 cpp_files = \
-    averageoiscouponpricer.cpp \
     arithmeticaverageois.cpp \
     arithmeticoisratehelper.cpp \
     makearithmeticaverageois.cpp
diff --git a/ql/experimental/averageois/arithmeticaverageois.cpp b/ql/experimental/averageois/arithmeticaverageois.cpp
index e779e5a73af..ee6e0ff9117 100644
--- a/ql/experimental/averageois/arithmeticaverageois.cpp
+++ b/ql/experimental/averageois/arithmeticaverageois.cpp
@@ -19,8 +19,8 @@
 
 #include <ql/cashflows/fixedratecoupon.hpp>
 #include <ql/cashflows/overnightindexedcoupon.hpp>
+#include <ql/cashflows/overnightindexedcouponpricer.hpp>
 #include <ql/experimental/averageois/arithmeticaverageois.hpp>
-#include <ql/experimental/averageois/averageoiscouponpricer.hpp>
 #include <utility>
 
 namespace QuantLib {
diff --git a/ql/experimental/averageois/averageoiscouponpricer.cpp b/ql/experimental/averageois/averageoiscouponpricer.cpp
deleted file mode 100644
index 5bcbd873041..00000000000
--- a/ql/experimental/averageois/averageoiscouponpricer.cpp
+++ /dev/null
@@ -1,146 +0,0 @@
-/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-
-/*
- Copyright (C) 2016 Stefano Fondi
-
- 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.
-*/
-
-#include <ql/experimental/averageois/averageoiscouponpricer.hpp>
-#include <cmath>
-
-using std::vector;
-using std::exp;
-using std::pow;
-using std::log;
-
-namespace QuantLib {
-
-    void ArithmeticAveragedOvernightIndexedCouponPricer::initialize(
-                                            const FloatingRateCoupon& coupon) {
-        coupon_ = dynamic_cast<const OvernightIndexedCoupon*>(&coupon);
-        QL_ENSURE(coupon_, "wrong coupon type");
-    }
-
-    Rate ArithmeticAveragedOvernightIndexedCouponPricer::swapletRate() const {
-
-        ext::shared_ptr<OvernightIndex> index =
-            ext::dynamic_pointer_cast<OvernightIndex>(coupon_->index());
-
-        const vector<Date>& fixingDates = coupon_->fixingDates();
-        const vector<Time>& dt = coupon_->dt();
-
-        Size n = dt.size(),
-            i = 0;
-
-        Real accumulatedRate = 0.0;
-
-        // already fixed part
-        Date today = Settings::instance().evaluationDate();
-        while (i < n && fixingDates[i] < today) {
-            // rate must have been fixed
-            Rate pastFixing = IndexManager::instance().getHistory(
-                index->name())[fixingDates[i]];
-            QL_REQUIRE(pastFixing != Null<Real>(),
-                "Missing " << index->name() <<
-                " fixing for " << fixingDates[i]);
-            accumulatedRate += pastFixing*dt[i];
-            ++i;
-        }
-
-        // today is a border case
-        if (i < n && fixingDates[i] == today) {
-            // might have been fixed
-            try {
-                Rate pastFixing = IndexManager::instance().getHistory(
-                    index->name())[fixingDates[i]];
-                if (pastFixing != Null<Real>()) {
-                    accumulatedRate += pastFixing*dt[i];
-                    ++i;
-                }
-                else {
-                    ;   // fall through and forecast
-                }
-            }
-            catch (Error&) {
-                ;       // fall through and forecast
-            }
-        }
-
-        /* forward part using telescopic property in order
-        to avoid the evaluation of multiple forward fixings
-        (approximation proposed by Katsumi Takada)*/
-        if (byApprox_ && i < n) {
-            Handle<YieldTermStructure> curve =
-                index->forwardingTermStructure();
-            QL_REQUIRE(!curve.empty(),
-                "null term structure set to this instance of " <<
-                index->name());
-
-            const vector<Date>& dates = coupon_->valueDates();
-            DiscountFactor startDiscount = curve->discount(dates[i]);
-            DiscountFactor endDiscount = curve->discount(dates[n]);
-
-            accumulatedRate += log(startDiscount / endDiscount) - 
-                convAdj1(curve->timeFromReference(dates[i]),
-                         curve->timeFromReference(dates[n])) -
-                convAdj2(curve->timeFromReference(dates[i]),
-                         curve->timeFromReference(dates[n]));
-        }
-        // otherwise
-        else if (i < n){
-            Handle<YieldTermStructure> curve =
-                index->forwardingTermStructure();
-            QL_REQUIRE(!curve.empty(),
-                "null term structure set to this instance of " <<
-                index->name());
-
-            const vector<Date>& dates = coupon_->valueDates();
-            Time te = curve->timeFromReference(dates[n]);
-            while (i < n) {
-                // forcast fixing
-                Rate forecastFixing = index->fixing(fixingDates[i]);
-                Time ti1 = curve->timeFromReference(dates[i]);
-                Time ti2 = curve->timeFromReference(dates[i + 1]);
-                /*convexity adjustment due to payment dalay of each
-                overnight fixing, supposing an Hull-White short rate model*/
-                Real convAdj = exp( 0.5*pow(vol_, 2.0) / pow(mrs_, 3.0)*
-                    (exp(2 * mrs_*ti1) - 1)*
-                    (exp(-mrs_*ti2) - exp(-mrs_*te))*
-                    (exp(-mrs_*ti2) - exp(-mrs_*ti1)) );
-                accumulatedRate += convAdj*(1 + forecastFixing*dt[i]) - 1;
-                ++i;
-            }
-        }
-
-        Rate rate = accumulatedRate / coupon_->accrualPeriod();
-        return coupon_->gearing() * rate + coupon_->spread();
-    }
-
-    Real ArithmeticAveragedOvernightIndexedCouponPricer::convAdj1(
-                                                    Time ts, Time te) const {
-        return vol_ * vol_ / (4.0 * pow(mrs_, 3.0)) *
-            (1.0 - exp(-2.0*mrs_*ts)) *
-            pow((1.0 - exp(-mrs_*(te - ts))), 2.0);
-    }
-
-    Real ArithmeticAveragedOvernightIndexedCouponPricer::convAdj2(
-                                                    Time ts, Time te) const {
-        return vol_ * vol_ / (2.0 * pow(mrs_, 2.0)) * ((te - ts) -
-            pow(1.0 - exp(-mrs_*(te - ts)), 2.0) / mrs_ -
-            (1.0 - exp(-2.0*mrs_*(te - ts))) / (2.0 * mrs_));
-    }
-
-}
-
diff --git a/ql/experimental/averageois/averageoiscouponpricer.hpp b/ql/experimental/averageois/averageoiscouponpricer.hpp
index f8ef37ca43a..d9bca82f6aa 100644
--- a/ql/experimental/averageois/averageoiscouponpricer.hpp
+++ b/ql/experimental/averageois/averageoiscouponpricer.hpp
@@ -24,46 +24,10 @@
 #ifndef quantlib_average_ois_coupon_pricer_hpp
 #define quantlib_average_ois_coupon_pricer_hpp
 
-#include <ql/cashflows/overnightindexedcoupon.hpp>
-#include <ql/cashflows/couponpricer.hpp>
+/* the class ArithmeticAveragedOvernightIndexedCouponPricer is moved to
+ * ql/cashflows/overnightindexedcouponpricer.hpp */
+#include <ql/cashflows/overnightindexedcouponpricer.hpp>
 
-namespace QuantLib {
-
-    /*! pricer for arithmetically averaged overnight indexed coupons
-    Reference: Katsumi Takada 2011, Valuation of Arithmetically Average of
-    Fed Funds Rates and Construction of the US Dollar Swap Yield Curve
-    */
-    class ArithmeticAveragedOvernightIndexedCouponPricer
-                                         : public FloatingRateCouponPricer {
-    public:
-        explicit ArithmeticAveragedOvernightIndexedCouponPricer(
-            Real meanReversion = 0.03,
-            Real volatility = 0.00, // NO convexity adjustment by default
-            bool byApprox = false) // TRUE to use Katsumi Takada approximation
-        : byApprox_(byApprox), mrs_(meanReversion), vol_(volatility) {}
-
-        explicit ArithmeticAveragedOvernightIndexedCouponPricer(
-            bool byApprox)  // Simplified constructor assuming no convexity correction
-        : ArithmeticAveragedOvernightIndexedCouponPricer(0.03, 0.0, byApprox) {}
-
-        void initialize(const FloatingRateCoupon& coupon) override;
-        Rate swapletRate() const override;
-        Real swapletPrice() const override { QL_FAIL("swapletPrice not available"); }
-        Real capletPrice(Rate) const override { QL_FAIL("capletPrice not available"); }
-        Rate capletRate(Rate) const override { QL_FAIL("capletRate not available"); }
-        Real floorletPrice(Rate) const override { QL_FAIL("floorletPrice not available"); }
-        Rate floorletRate(Rate) const override { QL_FAIL("floorletRate not available"); }
-
-      protected:
-        Real convAdj1(Time ts, Time te) const;
-        Real convAdj2(Time ts, Time te) const;
-        const OvernightIndexedCoupon* coupon_;
-        bool byApprox_;
-        Real mrs_;
-        Real vol_;
-
-    };
-
-}
+#pragma message("Warning: this file will disappear in a future release; do not include it.")
 
 #endif

From e5b882a855aa4bfb75c7e4278b2e385131b3069e Mon Sep 17 00:00:00 2001
From: Luigi Ballabio <luigi.ballabio@gmail.com>
Date: Mon, 5 Aug 2024 15:33:45 +0200
Subject: [PATCH 08/10] Fix typo and a few warnings

---
 ql/cashflows/overnightindexedcoupon.cpp |  4 ++--
 ql/cashflows/overnightindexedcoupon.hpp | 16 +++++++---------
 2 files changed, 9 insertions(+), 11 deletions(-)

diff --git a/ql/cashflows/overnightindexedcoupon.cpp b/ql/cashflows/overnightindexedcoupon.cpp
index 9a975808b2a..d80096a2b58 100644
--- a/ql/cashflows/overnightindexedcoupon.cpp
+++ b/ql/cashflows/overnightindexedcoupon.cpp
@@ -203,9 +203,9 @@ namespace QuantLib {
     Rate OvernightIndexedCoupon::averageRate(const Date& d) const {
         QL_REQUIRE(pricer_, "pricer not set");
         pricer_->initialize(*this);
-        if (const auto compoudingPricer =
+        if (const auto compoundingPricer =
                 ext::dynamic_pointer_cast<CompoundingOvernightIndexedCouponPricer>(pricer_)) {
-            return compoudingPricer->averageRate(d);
+            return compoundingPricer->averageRate(d);
         }
         return pricer_->swapletRate();
     }
diff --git a/ql/cashflows/overnightindexedcoupon.hpp b/ql/cashflows/overnightindexedcoupon.hpp
index ed9363baa67..3adb50262d1 100644
--- a/ql/cashflows/overnightindexedcoupon.hpp
+++ b/ql/cashflows/overnightindexedcoupon.hpp
@@ -78,11 +78,11 @@ namespace QuantLib {
         //! interest dates for the rates to be compounded
         const std::vector<Date>& interestDates() const { return interestDates_; }
         //! averaging method
-        const RateAveraging::Type averagingMethod() const { return averagingMethod_; }
+        RateAveraging::Type averagingMethod() const { return averagingMethod_; }
         //! lockout days
-        const Natural lockoutDays() const { return lockoutDays_; }
+        Natural lockoutDays() const { return lockoutDays_; }
         //! apply observation shift
-        const bool applyObservationShift() const { return applyObservationShift_; }
+        bool applyObservationShift() const { return applyObservationShift_; }
         //@}
         //! \name FloatingRateCoupon interface
         //@{
@@ -100,7 +100,10 @@ namespace QuantLib {
         //! Only when index fixing delay is 0 and observation shift is used,
         //! we can apply telescopic formula, when applying lookback period.
         //@{
-        const bool canApplyTelescopicFormula() const;
+        bool canApplyTelescopicFormula() const {
+            return fixingDays_ == index_->fixingDays() ||
+                (applyObservationShift_ && index_->fixingDays() == 0);
+        }
         //@}
       private:
         std::vector<Date> valueDates_, interestDates_, fixingDates_;
@@ -151,11 +154,6 @@ namespace QuantLib {
         bool applyObservationShift_ = false;
     };
 
-    inline const bool OvernightIndexedCoupon::canApplyTelescopicFormula() const {
-        return fixingDays_ == index_->fixingDays() ||
-               (applyObservationShift_ && index_->fixingDays() == 0);
-    }
-
 }
 
 #endif

From 7b2e01913f49021cb9ec7c77838c6d0c43af8fac Mon Sep 17 00:00:00 2001
From: Luigi Ballabio <luigi.ballabio@gmail.com>
Date: Mon, 5 Aug 2024 15:34:25 +0200
Subject: [PATCH 09/10] Modernize a couple of initializations

---
 ql/cashflows/overnightindexedcoupon.cpp | 26 +++++++++++--------------
 1 file changed, 11 insertions(+), 15 deletions(-)

diff --git a/ql/cashflows/overnightindexedcoupon.cpp b/ql/cashflows/overnightindexedcoupon.cpp
index d80096a2b58..0382671ad1d 100644
--- a/ql/cashflows/overnightindexedcoupon.cpp
+++ b/ql/cashflows/overnightindexedcoupon.cpp
@@ -170,21 +170,17 @@ namespace QuantLib {
             dt_[i] = dc.yearFraction(interestDates_[i], interestDates_[i + 1]);
 
         switch (averagingMethod) {
-            case RateAveraging::Simple:
-                QL_REQUIRE(
-                    fixingDays_ == overnightIndex->fixingDays() && !applyObservationShift_ &&
-                        lockoutDays_ == 0,
-                    "Cannot price an overnight coupon with simple averaging with lookback or "
-                    "lockout.");
-                setPricer(ext::shared_ptr<FloatingRateCouponPricer>(
-                    new ArithmeticAveragedOvernightIndexedCouponPricer(telescopicValueDates)));
-                break;
-            case RateAveraging::Compound:
-                setPricer(ext::shared_ptr<FloatingRateCouponPricer>(
-                    new CompoundingOvernightIndexedCouponPricer));
-                break;
-            default:
-                QL_FAIL("unknown compounding convention (" << Integer(averagingMethod) << ")");
+          case RateAveraging::Simple:
+            QL_REQUIRE(
+                fixingDays_ == overnightIndex->fixingDays() && !applyObservationShift_ && lockoutDays_ == 0,
+                "Cannot price an overnight coupon with simple averaging with lookback or lockout.");
+            setPricer(ext::make_shared<ArithmeticAveragedOvernightIndexedCouponPricer>(telescopicValueDates));
+            break;
+          case RateAveraging::Compound:
+            setPricer(ext::make_shared<CompoundingOvernightIndexedCouponPricer>());
+            break;
+          default:
+            QL_FAIL("unknown compounding convention (" << Integer(averagingMethod) << ")");
         }
     }
 

From 1c9494a1b5dd92fca4bde07ba0bf8b23a94eec70 Mon Sep 17 00:00:00 2001
From: Luigi Ballabio <luigi.ballabio@gmail.com>
Date: Mon, 5 Aug 2024 15:35:03 +0200
Subject: [PATCH 10/10] Include instructions in deprecation warning

---
 ql/experimental/averageois/averageoiscouponpricer.hpp | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

diff --git a/ql/experimental/averageois/averageoiscouponpricer.hpp b/ql/experimental/averageois/averageoiscouponpricer.hpp
index d9bca82f6aa..ea3bc6734a7 100644
--- a/ql/experimental/averageois/averageoiscouponpricer.hpp
+++ b/ql/experimental/averageois/averageoiscouponpricer.hpp
@@ -17,17 +17,12 @@
  FOR A PARTICULAR PURPOSE.  See the license for more details.
 */
 
-/*! \file averageoiscouponpricer.hpp
-    \brief pricer for arithmetically-averaged overnight-indexed coupons
-*/
-
 #ifndef quantlib_average_ois_coupon_pricer_hpp
 #define quantlib_average_ois_coupon_pricer_hpp
 
-/* the class ArithmeticAveragedOvernightIndexedCouponPricer is moved to
- * ql/cashflows/overnightindexedcouponpricer.hpp */
-#include <ql/cashflows/overnightindexedcouponpricer.hpp>
+// Deprecated in version 1.36
+#pragma message("Warning: this file will disappear in a future release; include <ql/cashflows/overnightindexedcouponpricer.hpp> instead")
 
-#pragma message("Warning: this file will disappear in a future release; do not include it.")
+#include <ql/cashflows/overnightindexedcouponpricer.hpp>
 
 #endif