Pricer for average overnight indexed coupons. More...

#include <qle/cashflows/averageonindexedcouponpricer.hpp>

Inheritance diagram for AverageONIndexedCouponPricer:

Collaboration diagram for AverageONIndexedCouponPricer:

Public Types
enum	Approximation { Takada , None }

Public Member Functions
	AverageONIndexedCouponPricer (Approximation approxType=Takada)

void	initialize (const FloatingRateCoupon &coupon) override

Rate	swapletRate () const override

Real	swapletPrice () const override

Real	capletPrice (Rate) const override

Rate	capletRate (Rate) const override

Real	floorletPrice (Rate) const override

Rate	floorletRate (Rate) const override

Protected Attributes
Approximation	approximationType_

Real	gearing_

Spread	spread_

Time	accrualPeriod_

QuantLib::ext::shared_ptr< OvernightIndex >	overnightIndex_

const AverageONIndexedCoupon *	coupon_

Detailed Description

Pricer for average overnight indexed coupons.

Definition at line 38 of file averageonindexedcouponpricer.hpp.

Member Enumeration Documentation

◆ Approximation

enum Approximation

Enumerator
Takada
None

Definition at line 40 of file averageonindexedcouponpricer.hpp.

40{ Takada, None };

QuantExt::AverageONIndexedCouponPricer::Takada

@ Takada

Definition: averageonindexedcouponpricer.hpp:40

QuantExt::AverageONIndexedCouponPricer::None

@ None

Definition: averageonindexedcouponpricer.hpp:40

Constructor & Destructor Documentation

◆ AverageONIndexedCouponPricer()

AverageONIndexedCouponPricer ( Approximation approxType = Takada )

Definition at line 42 of file averageonindexedcouponpricer.hpp.

42: approximationType_(approxType) {}

QuantExt::AverageONIndexedCouponPricer::approximationType_

Approximation approximationType_

Definition: averageonindexedcouponpricer.hpp:54

Member Function Documentation

◆ initialize()

void initialize ( const FloatingRateCoupon & coupon )

override

Definition at line 23 of file averageonindexedcouponpricer.cpp.

                                                                              {
 
    coupon_ = dynamic_cast<const AverageONIndexedCoupon*>(&coupon);
    QL_REQUIRE(coupon_, "AverageONIndexedCoupon required");
 
    overnightIndex_ = QuantLib::ext::dynamic_pointer_cast<OvernightIndex>(coupon_->index());
    QL_REQUIRE(overnightIndex_, "OvernightIndex required");
 
    gearing_ = coupon_->gearing();
    spread_ = coupon_->spread();
    accrualPeriod_ = coupon_->accrualPeriod();
}

◆ swapletRate()

Rate swapletRate ( ) const

override

Definition at line 36 of file averageonindexedcouponpricer.cpp.

                                                     {
 
    std::vector<Date> fixingDates = coupon_->fixingDates();
    std::vector<Time> accrualFractions = coupon_->dt();
    Size numPeriods = accrualFractions.size();
    Real accumulatedRate = 0;
    QL_REQUIRE(coupon_->rateCutoff() < numPeriods,
               "rate cutoff (" << coupon_->rateCutoff() << ") must be less than number of fixings in period ("
                               << numPeriods << ")");
    Size nCutoff = numPeriods - coupon_->rateCutoff();
 
    if (approximationType_ == Takada) {
        Size i = 0;
        Date valuationDate = Settings::instance().evaluationDate();
        // Deal with past fixings.
        while (i < numPeriods && fixingDates[std::min(i, nCutoff)] < valuationDate) {
            Rate pastFixing = overnightIndex_->pastFixing(fixingDates[std::min(i, nCutoff)]);
            QL_REQUIRE(pastFixing != Null<Real>(),
                       "Missing " << overnightIndex_->name() << " fixing for " << fixingDates[std::min(i, nCutoff)]);
            accumulatedRate += pastFixing * accrualFractions[i];
            ++i;
        }
        // Use valuation date's fixing also if available.
        if (i < numPeriods && fixingDates[std::min(i, nCutoff)] == valuationDate) {
            Rate valuationDateFixing = overnightIndex_->pastFixing(valuationDate);
            if (valuationDateFixing != Null<Real>()) {
                accumulatedRate += valuationDateFixing * accrualFractions[i];
                ++i;
            }
        }
        // Use Takada approximation (2011) for forecasting.
        if (i < numPeriods) {
            Handle<YieldTermStructure> projectionCurve = overnightIndex_->forwardingTermStructure();
            QL_REQUIRE(!projectionCurve.empty(),
                       "Null term structure set to this instance of " << overnightIndex_->name());
 
            // handle the part until the rate cutoff (might be empty, i.e. startForecast = endForecast)
            Date startForecast = coupon_->valueDates()[i];
            Date endForecast = coupon_->valueDates()[std::max(nCutoff, i)];
            DiscountFactor startDiscount = projectionCurve->discount(startForecast);
            DiscountFactor endDiscount = projectionCurve->discount(endForecast);
 
            // handle the rate cutoff period (if there is any, i.e. if nCutoff < n)
            if (nCutoff < numPeriods) {
                // forward discount factor for one calendar day on the cutoff date
                DiscountFactor discountCutoffDate = projectionCurve->discount(coupon_->valueDates()[nCutoff] + 1) /
                                                    projectionCurve->discount(coupon_->valueDates()[nCutoff]);
                // keep the above forward discount factor constant during the cutoff period
                endDiscount *=
                    std::pow(discountCutoffDate, coupon_->valueDates()[numPeriods] - coupon_->valueDates()[nCutoff]);
            }
 
            accumulatedRate += log(startDiscount / endDiscount);
        }
    } else if (approximationType_ == None) {
        std::vector<Rate> fixings = coupon_->indexFixings();
        for (Size i = 0; i < numPeriods; ++i) {
            accumulatedRate += fixings[i] * accrualFractions[i];
        }
    } else {
        QL_FAIL("Invalid Approximation for AverageONIndexedCouponPricer");
    }
    // Return factor * rate + spread
    Rate tau = overnightIndex_->dayCounter().yearFraction(coupon_->valueDates().front(), coupon_->valueDates().back());
    Rate rate = gearing_ * accumulatedRate / tau + spread_;
    return rate;
}