overnight coupon More...

#include <qle/cashflows/overnightindexedcoupon.hpp>

Inheritance diagram for OvernightIndexedCoupon:

Collaboration diagram for OvernightIndexedCoupon:

Public Member Functions
	OvernightIndexedCoupon (const Date &paymentDate, Real nominal, const Date &startDate, const Date &endDate, const ext::shared_ptr< OvernightIndex > &overnightIndex, Real gearing=1.0, Spread spread=0.0, const Date &refPeriodStart=Date(), const Date &refPeriodEnd=Date(), const DayCounter &dayCounter=DayCounter(), bool telescopicValueDates=false, bool includeSpread=false, const Period &lookback=0 *Days, const Natural rateCutoff=0, const Natural fixingDays=Null< Size >(), const Date &rateComputationStartDate=Null< Date >(), const Date &rateComputationEndDate=Null< Date >())

Inspectors
const std::vector< Date > &	fixingDates () const
	fixing dates for the rates to be compounded More...

const std::vector< Time > &	dt () const
	accrual (compounding) periods More...

const std::vector< Rate > &	indexFixings () const
	fixings to be compounded More...

const std::vector< Date > &	valueDates () const
	value dates for the rates to be compounded More...

bool	includeSpread () const
	include spread in compounding? More...

Real	effectiveSpread () const

Real	effectiveIndexFixing () const

const Period &	lookback () const
	lookback period More...

Natural	rateCutoff () const
	rate cutoff More...

const Date &	rateComputationStartDate () const
	rate computation start date More...

const Date &	rateComputationEndDate () const
	rate computation end date More...

const ext::shared_ptr< OvernightIndex > &	overnightIndex () const
	the underlying index More...

FloatingRateCoupon interface
Date	fixingDate () const override
	the date when the coupon is fully determined More...

Visitability
QuantLib::ext::shared_ptr< OvernightIndex >	overnightIndex_

std::vector< Date >	valueDates_

std::vector< Date >	fixingDates_

std::vector< Rate >	fixings_

Size	n_

std::vector< Time >	dt_

bool	includeSpread_

Period	lookback_

Natural	rateCutoff_

Date	rateComputationStartDate_

Date	rateComputationEndDate_

void	accept (AcyclicVisitor &) override

Detailed Description

overnight coupon

Coupon paying the compounded interest due to daily overnight fixings.

Warning:: telescopicValueDates optimizes the schedule for calculation speed, but might fail to produce correct results if the coupon ages by more than a grace period of 7 days. It is therefore recommended not to set this flag to true unless you know exactly what you are doing. The intended use is rather by the OISRateHelper which is safe, since it reinitialises the instrument each time the evaluation date changes.

if includeSpread = true, the spread is included in the daily compounding, otherwise it is added to the effective coupon rate after the compounding

Definition at line 72 of file overnightindexedcoupon.hpp.

Constructor & Destructor Documentation

◆ OvernightIndexedCoupon()

OvernightIndexedCoupon	(	const Date &	paymentDate,
		Real	nominal,
		const Date &	startDate,
		const Date &	endDate,
		const ext::shared_ptr< OvernightIndex > &	overnightIndex,
		Real	gearing = `1.0`,
		Spread	spread = `0.0`,
		const Date &	refPeriodStart = `Date()`,
		const Date &	refPeriodEnd = `Date()`,
		const DayCounter &	dayCounter = `DayCounter()`,
		bool	telescopicValueDates = `false`,
		bool	includeSpread = `false`,
		const Period &	lookback = `0 * Days`,
		const Natural	rateCutoff = `0`,
		const Natural	fixingDays = `Null<Size>()`,
		const Date &	rateComputationStartDate = `Null<Date>()`,
		const Date &	rateComputationEndDate = `Null<Date>()`
	)

Definition at line 54 of file overnightindexedcoupon.cpp.

    : FloatingRateCoupon(paymentDate, nominal, startDate, endDate, fixingDays, overnightIndex, gearing, spread,
                         refPeriodStart, refPeriodEnd, dayCounter, false),
      overnightIndex_(overnightIndex), includeSpread_(includeSpread), lookback_(lookback), rateCutoff_(rateCutoff),
      rateComputationStartDate_(rateComputationStartDate), rateComputationEndDate_(rateComputationEndDate) {
 
    Date valueStart = rateComputationStartDate_ == Null<Date>() ? startDate : rateComputationStartDate_;
    Date valueEnd = rateComputationEndDate_ == Null<Date>() ? endDate : rateComputationEndDate_;
    if (lookback != 0 * Days) {
        BusinessDayConvention bdc = lookback.length() > 0 ? Preceding : Following;
        valueStart = overnightIndex->fixingCalendar().advance(valueStart, -lookback, bdc);
        valueEnd = overnightIndex->fixingCalendar().advance(valueEnd, -lookback, bdc);
    }
 
    // value dates
    Date tmpEndDate = valueEnd;
 
    /* For the coupon's valuation only the first and last future valuation
       dates matter, therefore we can avoid to construct the whole series
       of valuation dates, a front and back stub will do. However notice
       that if the global evaluation date moves forward it might run past
       the front stub of valuation dates we build here (which incorporates
       a grace period of 7 business after the evaluation date). This will
       lead to false coupon projections (see the warning the class header). */
 
    if (telescopicValueDates) {
        // build optimised value dates schedule: front stub goes
        // from start date to max(evalDate,valueStart) + 7bd
        Date evalDate = Settings::instance().evaluationDate();
        tmpEndDate = overnightIndex->fixingCalendar().advance(std::max(valueStart, evalDate), 7, Days, Following);
        tmpEndDate = std::min(tmpEndDate, valueEnd);
    }
    Schedule sch = MakeSchedule()
                       .from(valueStart)
                       // .to(valueEnd)
                       .to(tmpEndDate)
                       .withTenor(1 * Days)
                       .withCalendar(overnightIndex->fixingCalendar())
                       .withConvention(overnightIndex->businessDayConvention())
                       .backwards();
    valueDates_ = sch.dates();
 
    if (telescopicValueDates) {
        // build optimised value dates schedule: back stub
        // contains at least two dates and enough periods to cover rate cutoff
        Date tmp2 = overnightIndex->fixingCalendar().adjust(valueEnd, overnightIndex->businessDayConvention());
        Date tmp1 = overnightIndex->fixingCalendar().advance(tmp2, -std::max<Size>(rateCutoff_, 1), Days, Preceding);
        while (tmp1 <= tmp2) {
            if (tmp1 > valueDates_.back())
                valueDates_.push_back(tmp1);
            tmp1 = overnightIndex->fixingCalendar().advance(tmp1, 1, Days, Following);
        }
    }
 
    QL_ENSURE(valueDates_.size() >= 2 + rateCutoff_, "degenerate schedule");
 
    // the first and last value date should be the unadjusted input value dates
    if (valueDates_.front() != valueStart)
        valueDates_.front() = valueStart;
    if (valueDates_.back() != valueEnd)
        valueDates_.back() = valueEnd;
 
    n_ = valueDates_.size() - 1;
 
    QL_REQUIRE(valueDates_[0] != valueDates_[1],
               "internal error: first two value dates of on coupon are equal: " << valueDates_[0]);
    QL_REQUIRE(valueDates_[n_] != valueDates_[n_ - 1],
               "internal error: last two value dates of on coupon are equal: " << valueDates_[n_]);
 
    // fixing dates
    fixingDates_.resize(n_);
    for (Size i = 0; i < n_; ++i)
        fixingDates_[i] = overnightIndex->fixingCalendar().advance(
            valueDates_[i], -static_cast<Integer>(FloatingRateCoupon::fixingDays()), Days, Preceding);
 
    // accrual (compounding) periods
    dt_.resize(n_);
    const DayCounter& dc = overnightIndex->dayCounter();
    for (Size i = 0; i < n_; ++i)
        dt_[i] = dc.yearFraction(valueDates_[i], valueDates_[i + 1]);
 
    setPricer(ext::shared_ptr<FloatingRateCouponPricer>(new OvernightIndexedCouponPricer));
 
    // check that rate cutoff is < number of fixing dates
    QL_REQUIRE(rateCutoff_ < n_,
               "rate cutoff (" << rateCutoff_ << ") must be less than number of fixings in period (" << n_ << ")");
}

Here is the call graph for this function:

Member Function Documentation

◆ fixingDates()

const std::vector< Date > & fixingDates ( ) const

fixing dates for the rates to be compounded

Definition at line 84 of file overnightindexedcoupon.hpp.

84{ return fixingDates_; }

Here is the caller graph for this function:

◆ dt()

const std::vector< Time > & dt ( ) const

accrual (compounding) periods

Definition at line 86 of file overnightindexedcoupon.hpp.

86{ return dt_; }

Here is the caller graph for this function:

◆ indexFixings()

const vector< Rate > & indexFixings ( ) const

fixings to be compounded

Definition at line 149 of file overnightindexedcoupon.cpp.

                                                               {
    fixings_.resize(n_);
    Size i;
    for (i = 0; i < n_ - rateCutoff_; ++i) {
        fixings_[i] = index_->fixing(fixingDates_[i]);
    }
    Rate cutoffFixing = fixings_[i - 1];
    while (i < n_) {
        fixings_[i] = cutoffFixing;
        i++;
    }
    return fixings_;
}

◆ valueDates()

const std::vector< Date > & valueDates ( ) const

value dates for the rates to be compounded

Definition at line 90 of file overnightindexedcoupon.hpp.

90{ return valueDates_; }

Here is the caller graph for this function:

◆ includeSpread()

bool includeSpread ( ) const

include spread in compounding?

Definition at line 92 of file overnightindexedcoupon.hpp.

92{ return includeSpread_; }

◆ effectiveSpread()

Real effectiveSpread ( ) const

effectiveSpread and effectiveIndexFixing are set such that coupon amount = notional * accrualPeriod * ( gearing * effectiveIndexFixing + effectiveSpread ) notice that

gearing = 1 is required if includeSpread = true
effectiveSpread = spread() if includeSpread = false

Definition at line 172 of file overnightindexedcoupon.cpp.

                                                   {
    if (!includeSpread_)
        return spread();
    auto p = ext::dynamic_pointer_cast<OvernightIndexedCouponPricer>(pricer());
    QL_REQUIRE(p, "OvernightIndexedCoupon::effectiveSpread(): expected OvernightIndexedCouponPricer");
    p->initialize(*this);
    return p->effectiveSpread();
}

◆ effectiveIndexFixing()

Real effectiveIndexFixing ( ) const

Definition at line 181 of file overnightindexedcoupon.cpp.

                                                        {
    auto p = ext::dynamic_pointer_cast<OvernightIndexedCouponPricer>(pricer());
    QL_REQUIRE(p, "OvernightIndexedCoupon::effectiveSpread(): expected OvernightIndexedCouponPricer");
    p->initialize(*this);
    return p->effectiveIndexFixing();
}

◆ lookback()

const Period & lookback ( ) const

lookback period

Definition at line 101 of file overnightindexedcoupon.hpp.

101{ return lookback_; }

Here is the caller graph for this function:

◆ rateCutoff()

Natural rateCutoff ( ) const

rate cutoff

Definition at line 103 of file overnightindexedcoupon.hpp.

103{ return rateCutoff_; }

Here is the caller graph for this function:

◆ rateComputationStartDate()

const Date & rateComputationStartDate ( ) const

rate computation start date

Definition at line 105 of file overnightindexedcoupon.hpp.

105{ return rateComputationStartDate_; }

◆ rateComputationEndDate()

const Date & rateComputationEndDate ( ) const

rate computation end date

Definition at line 107 of file overnightindexedcoupon.hpp.

107{ return rateComputationEndDate_; }

◆ overnightIndex()

const ext::shared_ptr< OvernightIndex > & overnightIndex ( ) const

the underlying index

Definition at line 109 of file overnightindexedcoupon.hpp.

109{ return overnightIndex_; }

Here is the caller graph for this function:

◆ fixingDate()

Date fixingDate ( ) const

override

the date when the coupon is fully determined

Definition at line 114 of file overnightindexedcoupon.hpp.

114{ return fixingDates_[fixingDates_.size() - 1 - rateCutoff_]; }

◆ accept()

void accept ( AcyclicVisitor & v )

override

Definition at line 163 of file overnightindexedcoupon.cpp.

                                                     {
    Visitor<OvernightIndexedCoupon>* v1 = dynamic_cast<Visitor<OvernightIndexedCoupon>*>(&v);
    if (v1 != 0) {
        v1->visit(*this);
    } else {
        FloatingRateCoupon::accept(v);
    }
}