lballabio · lballabio · Mar 28, 2024 · Feb 8, 2023 · Mar 6, 2023 · Oct 10, 2023
diff --git a/Examples/BermudanSwaption/BermudanSwaption.cpp b/Examples/BermudanSwaption/BermudanSwaption.cpp
@@ -23,6 +23,7 @@
 #if !defined(BOOST_ALL_NO_LIB) && defined(BOOST_MSVC)
 #  include <ql/auto_link.hpp>
 #endif
+#include <ql/instruments/vanillaswap.hpp>
 #include <ql/instruments/swaption.hpp>
 #include <ql/pricingengines/swap/discountingswapengine.hpp>
 #include <ql/pricingengines/swaption/treeswaptionengine.hpp>

diff --git a/ql/cashflows/overnightindexedcoupon.cpp b/ql/cashflows/overnightindexedcoupon.cpp
@@ -153,7 +153,7 @@ namespace QuantLib {
                          overnightIndex,
                          gearing, spread,
                          refPeriodStart, refPeriodEnd,
-                         dayCounter, false) {
+                         dayCounter, false), averagingMethod_(averagingMethod) {
 
         // value dates
         Date tmpEndDate = endDate;

diff --git a/ql/cashflows/overnightindexedcoupon.hpp b/ql/cashflows/overnightindexedcoupon.hpp
@@ -71,6 +71,8 @@ namespace QuantLib {
         const std::vector<Rate>& indexFixings() const;
         //! value dates for the rates to be compounded
         const std::vector<Date>& valueDates() const { return valueDates_; }
+        //! averaging method
+        const RateAveraging::Type averagingMethod() const { return averagingMethod_; }
         //@}
         //! \name FloatingRateCoupon interface
         //@{
@@ -87,6 +89,7 @@ namespace QuantLib {
         mutable std::vector<Rate> fixings_;
         Size n_;
         std::vector<Time> dt_;
+        RateAveraging::Type averagingMethod_;
 
         Rate averageRate(const Date& date) const;
     };

diff --git a/ql/experimental/basismodels/swaptioncfs.cpp b/ql/experimental/basismodels/swaptioncfs.cpp
@@ -91,7 +91,7 @@ namespace QuantLib {
             floatWeights_.push_back(k->amount());
     }
 
-    SwapCashFlows::SwapCashFlows(const ext::shared_ptr<VanillaSwap>& swap,
+    SwapCashFlows::SwapCashFlows(const ext::shared_ptr<FixedVsFloatingSwap>& swap,
                                  const Handle<YieldTermStructure>& discountCurve,
                                  bool contTenorSpread)
     : IborLegCashFlows(swap->floatingLeg(), discountCurve, contTenorSpread) {

diff --git a/ql/experimental/basismodels/swaptioncfs.hpp b/ql/experimental/basismodels/swaptioncfs.hpp
@@ -59,7 +59,7 @@ namespace QuantLib {
         std::vector<Real> annuityWeights_;
 
       public:
-        SwapCashFlows(const ext::shared_ptr<VanillaSwap>& swap,
+        SwapCashFlows(const ext::shared_ptr<FixedVsFloatingSwap>& swap,
                       const Handle<YieldTermStructure>& discountCurve,
                       bool contTenorSpread = true);
         SwapCashFlows() = default;

diff --git a/ql/experimental/basismodels/tenorswaptionvts.cpp b/ql/experimental/basismodels/tenorswaptionvts.cpp
@@ -24,6 +24,7 @@ FOR A PARTICULAR PURPOSE.  See the license for more details.
 
 #include <ql/experimental/basismodels/tenorswaptionvts.hpp>
 #include <ql/experimental/basismodels/swaptioncfs.hpp>
+#include <ql/instruments/vanillaswap.hpp>
 #include <ql/exercise.hpp>
 #include <ql/indexes/iborindex.hpp>
 #include <ql/math/rounding.hpp>
@@ -60,15 +61,15 @@ namespace QuantLib {
                                    volTS.baseIndex_->fixingCalendar(), ModifiedFollowing,
                                    Unadjusted, DateGeneration::Backward, false);
         // and swaps
-        ext::shared_ptr<VanillaSwap> baseSwap(new VanillaSwap(
+        auto baseSwap = ext::make_shared<VanillaSwap>(
             Swap::Payer, 1.0, baseFixedSchedule, 1.0, volTS.baseFixedDC_, baseFloatSchedule,
-            volTS.baseIndex_, 0.0, volTS.baseIndex_->dayCounter()));
-        ext::shared_ptr<VanillaSwap> targSwap(new VanillaSwap(
+            volTS.baseIndex_, 0.0, volTS.baseIndex_->dayCounter());
+        auto targSwap = ext::make_shared<VanillaSwap>(
             Swap::Payer, 1.0, baseFixedSchedule, 1.0, volTS.baseFixedDC_, targFloatSchedule,
-            volTS.targIndex_, 0.0, volTS.targIndex_->dayCounter()));
-        ext::shared_ptr<VanillaSwap> finlSwap(new VanillaSwap(
+            volTS.targIndex_, 0.0, volTS.targIndex_->dayCounter());
+        auto finlSwap = ext::make_shared<VanillaSwap>(
             Swap::Payer, 1.0, finlFixedSchedule, 1.0, volTS.targFixedDC_, targFloatSchedule,
-            volTS.targIndex_, 0.0, volTS.targIndex_->dayCounter()));
+            volTS.targIndex_, 0.0, volTS.targIndex_->dayCounter());
         // adding engines
         baseSwap->setPricingEngine(
             ext::shared_ptr<PricingEngine>(new DiscountingSwapEngine(volTS.discountCurve_)));

diff --git a/ql/instruments/makeswaption.cpp b/ql/instruments/makeswaption.cpp
@@ -21,6 +21,7 @@
 #include <ql/cashflows/cashflows.hpp>
 #include <ql/exercise.hpp>
 #include <ql/indexes/swapindex.hpp>
+#include <ql/instruments/makeois.hpp>
 #include <ql/instruments/makeswaption.hpp>
 #include <ql/instruments/makevanillaswap.hpp>
 #include <ql/pricingengines/swap/discountingswapengine.hpp>
@@ -72,13 +73,13 @@ namespace QuantLib {
         }
 
         Rate usedStrike = strike_;
+        ext::shared_ptr<OvernightIndexedSwapIndex> OIswap_index = ext::dynamic_pointer_cast<OvernightIndexedSwapIndex>(swapIndex_);
         if (strike_ == Null<Rate>()) {
             // ATM on curve(s) attached to index
             QL_REQUIRE(!swapIndex_->forwardingTermStructure().empty(),
                        "null term structure set to this instance of " <<
                        swapIndex_->name());
-            ext::shared_ptr<VanillaSwap> temp =
-                swapIndex_->underlyingSwap(fixingDate_);
+            ext::shared_ptr<FixedVsFloatingSwap> temp = swapIndex_->underlyingSwap(fixingDate_);
             temp->setPricingEngine(
                 ext::shared_ptr<PricingEngine>(new DiscountingSwapEngine(
                     swapIndex_->exogenousDiscount()
@@ -89,21 +90,38 @@ namespace QuantLib {
         }
 
         BusinessDayConvention bdc = swapIndex_->fixedLegConvention();
-        underlyingSwap_ =
-            MakeVanillaSwap(swapIndex_->tenor(),
-                            swapIndex_->iborIndex(), usedStrike)
-            .withEffectiveDate(swapIndex_->valueDate(fixingDate_))
-            .withFixedLegCalendar(swapIndex_->fixingCalendar())
-            .withFixedLegDayCount(swapIndex_->dayCounter())
-            .withFixedLegTenor(swapIndex_->fixedLegTenor())
-            .withFixedLegConvention(bdc)
-            .withFixedLegTerminationDateConvention(bdc)
-            .withType(underlyingType_)
-            .withNominal(nominal_)
-            .withIndexedCoupons(useIndexedCoupons_);
-
-        ext::shared_ptr<Swaption> swaption(new Swaption(
-            underlyingSwap_, exercise_, delivery_, settlementMethod_));
+        if (OIswap_index) {
+            underlyingSwap_ =
+                (ext::shared_ptr<OvernightIndexedSwap>)(
+                    MakeOIS(swapIndex_->tenor(),
+                            OIswap_index->overnightIndex(), usedStrike)
+                    .withEffectiveDate(swapIndex_->valueDate(fixingDate_))
+                    .withPaymentCalendar(swapIndex_->fixingCalendar())
+                    .withFixedLegDayCount(swapIndex_->dayCounter())
+                    .withPaymentAdjustment(bdc)
+                    .withFixedLegConvention(bdc)
+                    .withFixedLegTerminationDateConvention(bdc)
+                    .withType(underlyingType_)
+                    .withNominal(nominal_)
+                    );
+        } else {
+            underlyingSwap_ =
+                (ext::shared_ptr<VanillaSwap>)(
+                    MakeVanillaSwap(swapIndex_->tenor(),
+                                    swapIndex_->iborIndex(), usedStrike)
+                    .withEffectiveDate(swapIndex_->valueDate(fixingDate_))
+                    .withFixedLegCalendar(swapIndex_->fixingCalendar())
+                    .withFixedLegDayCount(swapIndex_->dayCounter())
+                    .withFixedLegTenor(swapIndex_->fixedLegTenor())
+                    .withFixedLegConvention(bdc)
+                    .withFixedLegTerminationDateConvention(bdc)
+                    .withType(underlyingType_)
+                    .withNominal(nominal_)
+                    .withIndexedCoupons(useIndexedCoupons_)
+                    );
+        }
+        ext::shared_ptr<Swaption> swaption = ext::make_shared<Swaption>(
+            underlyingSwap_, exercise_, delivery_, settlementMethod_);
         swaption->setPricingEngine(engine_);
         return swaption;
     }

diff --git a/ql/instruments/makeswaption.hpp b/ql/instruments/makeswaption.hpp
@@ -70,7 +70,7 @@ namespace QuantLib {
         ext::shared_ptr<SwapIndex> swapIndex_;
         Settlement::Type delivery_;
         Settlement::Method settlementMethod_;
-        mutable ext::shared_ptr<VanillaSwap> underlyingSwap_;
+        mutable ext::shared_ptr<FixedVsFloatingSwap> underlyingSwap_;
 
         Period optionTenor_;
         BusinessDayConvention optionConvention_;

diff --git a/ql/instruments/nonstandardswap.cpp b/ql/instruments/nonstandardswap.cpp
@@ -33,7 +33,7 @@
 
 namespace QuantLib {
 
-    NonstandardSwap::NonstandardSwap(const VanillaSwap &fromVanilla)
+    NonstandardSwap::NonstandardSwap(const FixedVsFloatingSwap &fromVanilla)
         : Swap(2), type_(fromVanilla.type()),
           fixedNominal_(std::vector<Real>(fromVanilla.fixedLeg().size(),
                                           fromVanilla.nominal())),

diff --git a/ql/instruments/nonstandardswap.hpp b/ql/instruments/nonstandardswap.hpp
@@ -25,7 +25,7 @@
 #define quantlib_nonstandard_swap_hpp
 
 #include <ql/instruments/swap.hpp>
-#include <ql/instruments/vanillaswap.hpp>
+#include <ql/instruments/fixedvsfloatingswap.hpp>
 #include <ql/time/daycounter.hpp>
 #include <ql/time/schedule.hpp>
 #include <ql/optional.hpp>
@@ -42,7 +42,7 @@ namespace QuantLib {
         class arguments;
         class results;
         class engine;
-        NonstandardSwap(const VanillaSwap &fromVanilla);
+        explicit NonstandardSwap(const FixedVsFloatingSwap &fromVanilla);
         NonstandardSwap(Swap::Type type,
                         std::vector<Real> fixedNominal,
                         const std::vector<Real>& floatingNominal,

diff --git a/ql/instruments/swaption.cpp b/ql/instruments/swaption.cpp
@@ -130,7 +130,7 @@ namespace QuantLib {
         }
     }
 
-    Swaption::Swaption(ext::shared_ptr<VanillaSwap> swap,
+    Swaption::Swaption(ext::shared_ptr<FixedVsFloatingSwap> swap,
                        const ext::shared_ptr<Exercise>& exercise,
                        Settlement::Type delivery,
                        Settlement::Method settlementMethod)
@@ -160,7 +160,6 @@ namespace QuantLib {
     void Swaption::setupArguments(PricingEngine::arguments* args) const {
 
         swap_->setupArguments(args);
-
         auto* arguments = dynamic_cast<Swaption::arguments*>(args);
 
         QL_REQUIRE(arguments != nullptr, "wrong argument type");
@@ -172,11 +171,10 @@ namespace QuantLib {
     }
 
     void Swaption::arguments::validate() const {
-        VanillaSwap::arguments::validate();
-        QL_REQUIRE(swap, "vanilla swap not set");
+        FixedVsFloatingSwap::arguments::validate();
+        QL_REQUIRE(swap, "swap not set");
         QL_REQUIRE(exercise, "exercise not set");
-        Settlement::checkTypeAndMethodConsistency(settlementType,
-                                                  settlementMethod);
+        Settlement::checkTypeAndMethodConsistency(settlementType, settlementMethod);
     }
 
     Volatility Swaption::impliedVolatility(Real targetValue,

diff --git a/ql/instruments/swaption.hpp b/ql/instruments/swaption.hpp
@@ -30,7 +30,7 @@
 #define quantlib_instruments_swaption_hpp
 
 #include <ql/option.hpp>
-#include <ql/instruments/vanillaswap.hpp>
+#include <ql/instruments/fixedvsfloatingswap.hpp>
 #include <ql/termstructures/yieldtermstructure.hpp>
 #include <ql/termstructures/volatility/volatilitytype.hpp>
 
@@ -82,7 +82,7 @@ namespace QuantLib {
       public:
         class arguments;
         class engine;
-        Swaption(ext::shared_ptr<VanillaSwap> swap,
+        Swaption(ext::shared_ptr<FixedVsFloatingSwap> swap,
                  const ext::shared_ptr<Exercise>& exercise,
                  Settlement::Type delivery = Settlement::Physical,
                  Settlement::Method settlementMethod = Settlement::PhysicalOTC);
@@ -102,7 +102,7 @@ namespace QuantLib {
             return settlementMethod_;
         }
         Swap::Type type() const { return swap_->type(); }
-        const ext::shared_ptr<VanillaSwap>& underlyingSwap() const {
+        const ext::shared_ptr<FixedVsFloatingSwap>& underlyingSwap() const {
             return swap_;
         }
         //@}
@@ -119,18 +119,18 @@ namespace QuantLib {
                               Real displacement = 0.0) const;
       private:
         // arguments
-        ext::shared_ptr<VanillaSwap> swap_;
+        ext::shared_ptr<FixedVsFloatingSwap> swap_;
         //Handle<YieldTermStructure> termStructure_;
         Settlement::Type settlementType_;
         Settlement::Method settlementMethod_;
     };
 
     //! %Arguments for swaption calculation
-    class Swaption::arguments : public VanillaSwap::arguments,
+    class Swaption::arguments : public FixedVsFloatingSwap::arguments,
                                 public Option::arguments {
       public:
         arguments() = default;
-        ext::shared_ptr<VanillaSwap> swap;
+        ext::shared_ptr<FixedVsFloatingSwap> swap;
         Settlement::Type settlementType = Settlement::Physical;
         Settlement::Method settlementMethod;
         void validate() const override;

diff --git a/ql/legacy/libormarketmodels/lfmswaptionengine.cpp b/ql/legacy/libormarketmodels/lfmswaptionengine.cpp
@@ -39,14 +39,14 @@ namespace QuantLib {
 
         static const Spread basisPoint = 1.0e-4;
 
-        VanillaSwap swap = *arguments_.swap;
-        swap.setPricingEngine(ext::shared_ptr<PricingEngine>(
-                           new DiscountingSwapEngine(discountCurve_, false)));
+        auto swap = arguments_.swap;
+        swap->setPricingEngine(ext::shared_ptr<PricingEngine>(
+                                  new DiscountingSwapEngine(discountCurve_, false)));
 
-        Spread correction = swap.spread() *
-            std::fabs(swap.floatingLegBPS()/swap.fixedLegBPS());
-        Rate fixedRate = swap.fixedRate() - correction;
-        Rate fairRate = swap.fairRate() - correction;
+        Spread correction = swap->spread() *
+            std::fabs(swap->floatingLegBPS()/swap->fixedLegBPS());
+        Rate fixedRate = swap->fixedRate() - correction;
+        Rate fairRate = swap->fairRate() - correction;
 
         ext::shared_ptr<SwaptionVolatilityMatrix> volatility =
             model_->getSwaptionVolatilityMatrix();
@@ -65,9 +65,8 @@ namespace QuantLib {
         Option::Type w = arguments_.type==Swap::Payer ? Option::Call : Option::Put;
         Volatility vol = volatility->volatility(exercise, swapLength,
                                                 fairRate, true);
-        results_.value = (swap.fixedLegBPS()/basisPoint) *
+        results_.value = (swap->fixedLegBPS()/basisPoint) *
             blackFormula(w, fixedRate, fairRate, vol*std::sqrt(exercise));
     }
 
 }
-
diff --git a/ql/methods/finitedifferences/utilities/fdmaffinemodelswapinnervalue.hpp b/ql/methods/finitedifferences/utilities/fdmaffinemodelswapinnervalue.hpp
@@ -41,7 +41,7 @@ namespace QuantLib {
       public:
         FdmAffineModelSwapInnerValue(ext::shared_ptr<ModelType> disModel,
                                      ext::shared_ptr<ModelType> fwdModel,
-                                     const ext::shared_ptr<VanillaSwap>& swap,
+                                     const ext::shared_ptr<FixedVsFloatingSwap>& swap,
                                      std::map<Time, Date> exerciseDates,
                                      ext::shared_ptr<FdmMesher> mesher,
                                      Size direction);
@@ -58,7 +58,7 @@ namespace QuantLib {
         const ext::shared_ptr<ModelType> disModel_, fwdModel_;
 
         const ext::shared_ptr<IborIndex> index_;
-        const ext::shared_ptr<VanillaSwap> swap_;
+        const ext::shared_ptr<FixedVsFloatingSwap> swap_;
         const std::map<Time, Date> exerciseDates_;
         const ext::shared_ptr<FdmMesher> mesher_;
         const Size direction_;
@@ -68,21 +68,21 @@ namespace QuantLib {
     inline FdmAffineModelSwapInnerValue<ModelType>::FdmAffineModelSwapInnerValue(
         ext::shared_ptr<ModelType> disModel,
         ext::shared_ptr<ModelType> fwdModel,
-        const ext::shared_ptr<VanillaSwap>& swap,
+        const ext::shared_ptr<FixedVsFloatingSwap>& swap,
         std::map<Time, Date> exerciseDates,
         ext::shared_ptr<FdmMesher> mesher,
         Size direction)
     : disModel_(std::move(disModel)), fwdModel_(std::move(fwdModel)), index_(swap->iborIndex()),
-      swap_(ext::shared_ptr<VanillaSwap>(new VanillaSwap(swap->type(),
-                                                         swap->nominal(),
-                                                         swap->fixedSchedule(),
-                                                         swap->fixedRate(),
-                                                         swap->fixedDayCount(),
-                                                         swap->floatingSchedule(),
-                                                         swap->iborIndex()->clone(fwdTs_),
-                                                         swap->spread(),
-                                                         swap->floatingDayCount(),
-                                                         swap->paymentConvention()))),
+      swap_(ext::make_shared<VanillaSwap>(swap->type(),
+                                          swap->nominal(),
+                                          swap->fixedSchedule(),
+                                          swap->fixedRate(),
+                                          swap->fixedDayCount(),
+                                          swap->floatingSchedule(),
+                                          swap->iborIndex()->clone(fwdTs_),
+                                          swap->spread(),
+                                          swap->floatingDayCount(),
+                                          swap->paymentConvention())),
       exerciseDates_(std::move(exerciseDates)), mesher_(std::move(mesher)), direction_(direction) {}
 
     template <class ModelType> inline