Fix call price accrued during ex-coupon period (#2236) (#2455)

Author: lballabio

ql/experimental/callablebonds/callablebond.cpp

@@ -445,12 +445,29 @@ namespace QuantLib {
                 arguments->callabilityPrices.push_back(i->price().amount());
 
                 if (i->price().type() == Bond::Price::Clean) {
-                    /* calling accrued() forces accrued interest to be zero
-                       if future option date is also coupon date, so that dirty
-                       price = clean price. Use here because callability is
-                       always applied before coupon in the tree engine.
-                    */
-                    arguments->callabilityPrices.back() += this->accrued(i->date());
+                    /* Convert clean call price to dirty using accrued interest
+                       at the call date. We ignore ex-coupon conventions here
+                       because the call is an issuer action governed by the
+                       indenture: the holder receives the call price plus accrued
+                       from the last payment date. Using market (ex-coupon) accrued
+                       would create an inconsistency with the tree's continuation
+                       value, which includes future coupons filtered at the
+                       settlement date (see GitHub issue #2236). */
+                    Date callDate = i->date();
+                    Real callAccrued = 0.0;
+                    for (const auto& cf : cashflows_) {
+                        if (!cf->hasOccurred(callDate, false)) {
+                            auto coupon = ext::dynamic_pointer_cast<Coupon>(cf);
+                            if (coupon != nullptr) {
+                                Real acc = coupon->accruedAmount(callDate);
+                                if (coupon->tradingExCoupon(callDate))
+                                    acc = coupon->amount() + acc;
+                                callAccrued = acc / notional(callDate) * 100.0;
+                            }
+                            break;
+                        }
+                    }
+                    arguments->callabilityPrices.back() += callAccrued;
                 }
             }
         }
@@ -459,27 +476,6 @@ namespace QuantLib {
     }
 
 
-    Real CallableBond::accrued(Date settlement) const {
-
-        if (settlement == Date()) settlement = settlementDate();
-
-        const bool IncludeToday = false;
-        for (const auto& cashflow : cashflows_) {
-            // the first coupon paying after d is the one we're after
-            if (!cashflow->hasOccurred(settlement, IncludeToday)) {
-                ext::shared_ptr<Coupon> coupon = ext::dynamic_pointer_cast<Coupon>(cashflow);
-                if (coupon != nullptr)
-                    // !!!
-                    return coupon->accruedAmount(settlement) /
-                           notional(settlement) * 100.0;
-                else
-                    return 0.0;
-            }
-        }
-        return 0.0;
-    }
-
-
     CallableFixedRateBond::CallableFixedRateBond(
                               Natural settlementDays,
                               Real faceAmount,

ql/experimental/callablebonds/callablebond.hpp

@@ -146,15 +146,6 @@ namespace QuantLib {
         // helper class for option adjusted spread calculations
         class NPVSpreadHelper;
 
-      private:
-        /*  Used internally.
-            same as Bond::accruedAmount() but with enable early
-            payments true.  Forces accrued to be calculated in a
-            consistent way for future put/ call dates, which can be
-            problematic in lattice engines when option dates are also
-            coupon dates.
-        */
-        Real accrued(Date settlement) const;
     };
 
     class CallableBond::arguments : public Bond::arguments {

test-suite/callablebonds.cpp

@@ -950,6 +950,101 @@ BOOST_AUTO_TEST_CASE(testCallableBondOasWithDifferentNotinals) {
                     << "    clean price with notional 25.0:    " << cleanPrice25 << "\n");
 }
 
+BOOST_AUTO_TEST_CASE(testOasContinuityThroughExCouponWindow) {
+
+    BOOST_TEST_MESSAGE("Testing OAS continuity when call date crosses ex-coupon period...");
+
+    /* This is a test case inspired by
+     * https://github.com/lballabio/QuantLib/issues/2236
+     *
+     * When a call date falls between the ex-coupon date and the payment date,
+     * OAS should vary smoothly (within tree discretization noise). Before the
+     * fix, OAS jumped from ~+154 bps to ~-513 bps at the ex-coupon boundary
+     * due to an inconsistency between how the tree continuation value includes
+     * coupons and how the call price uses negative accrued during ex-coupon. */
+
+    auto today = Date(31, January, 2024);
+    Settings::instance().evaluationDate() = today;
+
+    Natural settlementDays = 0;
+    auto calendar = UnitedStates(UnitedStates::NYSE);
+    auto dc = Thirty360(Thirty360::BondBasis);
+    auto bdc = Unadjusted;
+    auto frequency = Quarterly;
+    Period exCouponPeriod(14, Days);
+
+    auto issueDate = today;
+    auto maturityDate = Date(31, January, 2029);
+    Real faceAmount = 100.0;
+    std::vector<Rate> coupons = {0.06};
+    Real redemption = 100.0;
+
+    Handle<YieldTermStructure> termStructure(
+        ext::make_shared<FlatForward>(today, 0.04, dc));
+    auto model = ext::make_shared<HullWhite>(termStructure);
+
+    Schedule schedule = MakeSchedule()
+                            .from(issueDate)
+                            .to(maturityDate)
+                            .withFrequency(frequency)
+                            .withCalendar(calendar)
+                            .withConvention(bdc)
+                            .withTerminationDateConvention(bdc)
+                            .backwards()
+                            .endOfMonth(true);
+
+    // First coupon payment date after today
+    Date firstPaymentDate = schedule[1];
+    Date exCouponDate = firstPaymentDate - exCouponPeriod;
+
+    // Sweep call date from 1 week before ex-coupon to 1 week after payment
+    Date sweepStart = exCouponDate - 7 * Days;
+    Date sweepEnd = firstPaymentDate + 7 * Days;
+
+    Real cleanPrice = 100.0;
+    Compounding compounding = Compounded;
+
+    Real maxOas = -QL_MAX_REAL;
+    Real minOas = QL_MAX_REAL;
+
+    for (Date callDate = sweepStart; callDate <= sweepEnd; callDate++) {
+        CallabilitySchedule callSchedule;
+        callSchedule.push_back(ext::make_shared<Callability>(
+            Bond::Price(redemption, Bond::Price::Clean),
+            Callability::Call,
+            callDate));
+
+        CallableFixedRateBond bond(
+            settlementDays, faceAmount, schedule, coupons, dc,
+            bdc, redemption, issueDate, callSchedule,
+            exCouponPeriod, NullCalendar());
+        bond.setPricingEngine(
+            ext::make_shared<TreeCallableFixedRateBondEngine>(
+                model, 100, termStructure));
+
+        Real oas = bond.OAS(cleanPrice, termStructure, dc,
+                            compounding, frequency) * 10000.0;
+        maxOas = std::max(maxOas, oas);
+        minOas = std::min(minOas, oas);
+    }
+
+    Real oasRange = maxOas - minOas;
+
+    // OAS should be reasonably continuous through the ex-coupon window.
+    // A range of 50 bps allows for tree discretization noise; the bug
+    // produced a range of ~667 bps.
+    Real tolerance = 50.0;
+    if (oasRange > tolerance)
+        BOOST_ERROR("OAS discontinuity across ex-coupon window:\n"
+                    << std::setprecision(2) << std::fixed
+                    << "    min OAS: " << minOas << " bps\n"
+                    << "    max OAS: " << maxOas << " bps\n"
+                    << "    range:   " << oasRange << " bps\n"
+                    << "    tolerance: " << tolerance << " bps\n"
+                    << "    (sweep from " << io::iso_date(sweepStart)
+                    << " to " << io::iso_date(sweepEnd) << ")");
+}
+
 BOOST_AUTO_TEST_SUITE_END()
 
 BOOST_AUTO_TEST_SUITE_END()