helper class building a sequence of overnight coupons More...

#include <qle/cashflows/overnightindexedcoupon.hpp>

Collaboration diagram for OvernightLeg:

Public Member Functions
	OvernightLeg (const Schedule &schedule, const ext::shared_ptr< OvernightIndex > &overnightIndex)

OvernightLeg &	withNotionals (Real notional)

OvernightLeg &	withNotionals (const std::vector< Real > &notionals)

OvernightLeg &	withPaymentDayCounter (const DayCounter &)

OvernightLeg &	withPaymentAdjustment (BusinessDayConvention)

OvernightLeg &	withPaymentCalendar (const Calendar &)

OvernightLeg &	withPaymentLag (Natural lag)

OvernightLeg &	withGearings (Real gearing)

OvernightLeg &	withGearings (const std::vector< Real > &gearings)

OvernightLeg &	withSpreads (Spread spread)

OvernightLeg &	withSpreads (const std::vector< Spread > &spreads)

OvernightLeg &	withTelescopicValueDates (bool telescopicValueDates)

OvernightLeg &	includeSpread (bool includeSpread)

OvernightLeg &	withLookback (const Period &lookback)

OvernightLeg &	withRateCutoff (const Natural rateCutoff)

OvernightLeg &	withFixingDays (const Natural fixingDays)

OvernightLeg &	withCaps (Rate cap)

OvernightLeg &	withCaps (const std::vector< Rate > &caps)

OvernightLeg &	withFloors (Rate floor)

OvernightLeg &	withFloors (const std::vector< Rate > &floors)

OvernightLeg &	withNakedOption (const bool nakedOption)

OvernightLeg &	withLocalCapFloor (const bool localCapFloor)

OvernightLeg &	withInArrears (const bool inArrears)

OvernightLeg &	withLastRecentPeriod (const boost::optional< Period > &lastRecentPeriod)

OvernightLeg &	withLastRecentPeriodCalendar (const Calendar &lastRecentPeriodCalendar)

OvernightLeg &	withOvernightIndexedCouponPricer (const QuantLib::ext::shared_ptr< OvernightIndexedCouponPricer > &couponPricer)

OvernightLeg &	withPaymentDates (const std::vector< Date > &paymentDates)

OvernightLeg &	withCapFlooredOvernightIndexedCouponPricer (const QuantLib::ext::shared_ptr< CappedFlooredOvernightIndexedCouponPricer > &couponPricer)

	operator Leg () const

Private Attributes
Schedule	schedule_

ext::shared_ptr< OvernightIndex >	overnightIndex_

std::vector< Real >	notionals_

DayCounter	paymentDayCounter_

Calendar	paymentCalendar_

BusinessDayConvention	paymentAdjustment_

Natural	paymentLag_

std::vector< Real >	gearings_

std::vector< Spread >	spreads_

bool	telescopicValueDates_

bool	includeSpread_

Period	lookback_

Natural	rateCutoff_

Natural	fixingDays_

std::vector< Rate >	caps_

std::vector< Rate >	floors_

bool	nakedOption_

bool	localCapFloor_

bool	inArrears_

boost::optional< Period >	lastRecentPeriod_

Calendar	lastRecentPeriodCalendar_

std::vector< QuantLib::Date >	paymentDates_

QuantLib::ext::shared_ptr< OvernightIndexedCouponPricer >	couponPricer_

QuantLib::ext::shared_ptr< CappedFlooredOvernightIndexedCouponPricer >	capFlooredCouponPricer_

Detailed Description

helper class building a sequence of overnight coupons

Definition at line 229 of file overnightindexedcoupon.hpp.

Constructor & Destructor Documentation

◆ OvernightLeg()

OvernightLeg	(	const Schedule &	schedule,
		const ext::shared_ptr< OvernightIndex > &	overnightIndex
	)

Definition at line 469 of file overnightindexedcoupon.cpp.

    : schedule_(schedule), overnightIndex_(i), paymentCalendar_(schedule.calendar()), paymentAdjustment_(Following),
      paymentLag_(0), telescopicValueDates_(false), includeSpread_(false), lookback_(0 * Days), rateCutoff_(0),
      fixingDays_(Null<Size>()), nakedOption_(false), localCapFloor_(false), inArrears_(true) {}

Member Function Documentation

◆ withNotionals() [1/2]

OvernightLeg & withNotionals ( Real notional )

Definition at line 474 of file overnightindexedcoupon.cpp.

                                                       {
    notionals_ = vector<Real>(1, notional);
    return *this;
}

Here is the caller graph for this function:

◆ withNotionals() [2/2]

OvernightLeg & withNotionals ( const std::vector< Real > & notionals )

Definition at line 479 of file overnightindexedcoupon.cpp.

                                                                       {
    notionals_ = notionals;
    return *this;
}

◆ withPaymentDayCounter()

OvernightLeg & withPaymentDayCounter ( const DayCounter & dc )

Definition at line 484 of file overnightindexedcoupon.cpp.

                                                                      {
    paymentDayCounter_ = dc;
    return *this;
}

Here is the caller graph for this function:

◆ withPaymentAdjustment()

OvernightLeg & withPaymentAdjustment ( BusinessDayConvention convention )

Definition at line 489 of file overnightindexedcoupon.cpp.

                                                                                  {
    paymentAdjustment_ = convention;
    return *this;
}

Here is the caller graph for this function:

◆ withPaymentCalendar()

OvernightLeg & withPaymentCalendar ( const Calendar & cal )

Definition at line 494 of file overnightindexedcoupon.cpp.

                                                                   {
    paymentCalendar_ = cal;
    return *this;
}

◆ withPaymentLag()

OvernightLeg & withPaymentLag ( Natural lag )

Definition at line 499 of file overnightindexedcoupon.cpp.

                                                      {
    paymentLag_ = lag;
    return *this;
}

Here is the caller graph for this function:

◆ withGearings() [1/2]

OvernightLeg & withGearings ( Real gearing )

Definition at line 504 of file overnightindexedcoupon.cpp.

                                                     {
    gearings_ = vector<Real>(1, gearing);
    return *this;
}

Here is the caller graph for this function:

◆ withGearings() [2/2]

OvernightLeg & withGearings ( const std::vector< Real > & gearings )

Definition at line 509 of file overnightindexedcoupon.cpp.

                                                                     {
    gearings_ = gearings;
    return *this;
}

◆ withSpreads() [1/2]

OvernightLeg & withSpreads ( Spread spread )

Definition at line 514 of file overnightindexedcoupon.cpp.

                                                     {
    spreads_ = vector<Spread>(1, spread);
    return *this;
}

Here is the caller graph for this function:

◆ withSpreads() [2/2]

OvernightLeg & withSpreads ( const std::vector< Spread > & spreads )

Definition at line 519 of file overnightindexedcoupon.cpp.

                                                                     {
    spreads_ = spreads;
    return *this;
}

◆ withTelescopicValueDates()

OvernightLeg & withTelescopicValueDates ( bool telescopicValueDates )

Definition at line 524 of file overnightindexedcoupon.cpp.

                                                                              {
    telescopicValueDates_ = telescopicValueDates;
    return *this;
}

Here is the caller graph for this function:

◆ includeSpread()

OvernightLeg & includeSpread ( bool includeSpread )

Definition at line 529 of file overnightindexedcoupon.cpp.

                                                            {
    includeSpread_ = includeSpread;
    return *this;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ withLookback()

OvernightLeg & withLookback ( const Period & lookback )

Definition at line 534 of file overnightindexedcoupon.cpp.

                                                               {
    lookback_ = lookback;
    return *this;
}

Here is the caller graph for this function:

◆ withRateCutoff()

OvernightLeg & withRateCutoff ( const Natural rateCutoff )

Definition at line 539 of file overnightindexedcoupon.cpp.

                                                                   {
    rateCutoff_ = rateCutoff;
    return *this;
}

Here is the caller graph for this function:

◆ withFixingDays()

OvernightLeg & withFixingDays ( const Natural fixingDays )

Definition at line 544 of file overnightindexedcoupon.cpp.

                                                                   {
    fixingDays_ = fixingDays;
    return *this;
}

Here is the caller graph for this function:

◆ withCaps() [1/2]

OvernightLeg & withCaps ( Rate cap )

Definition at line 549 of file overnightindexedcoupon.cpp.

                                             {
    caps_ = std::vector<Rate>(1, cap);
    return *this;
}

Here is the caller graph for this function:

◆ withCaps() [2/2]

OvernightLeg & withCaps ( const std::vector< Rate > & caps )

Definition at line 554 of file overnightindexedcoupon.cpp.

                                                                {
    caps_ = caps;
    return *this;
}

◆ withFloors() [1/2]

OvernightLeg & withFloors ( Rate floor )

Definition at line 559 of file overnightindexedcoupon.cpp.

                                                 {
    floors_ = std::vector<Rate>(1, floor);
    return *this;
}

Here is the caller graph for this function:

◆ withFloors() [2/2]

OvernightLeg & withFloors ( const std::vector< Rate > & floors )

Definition at line 564 of file overnightindexedcoupon.cpp.

                                                                    {
    floors_ = floors;
    return *this;
}

◆ withNakedOption()

OvernightLeg & withNakedOption ( const bool nakedOption )

Definition at line 569 of file overnightindexedcoupon.cpp.

                                                                  {
    nakedOption_ = nakedOption;
    return *this;
}

Here is the caller graph for this function:

◆ withLocalCapFloor()

OvernightLeg & withLocalCapFloor ( const bool localCapFloor )

Definition at line 574 of file overnightindexedcoupon.cpp.

                                                                      {
    localCapFloor_ = localCapFloor;
    return *this;
}

◆ withInArrears()

OvernightLeg & withInArrears ( const bool inArrears )

Definition at line 579 of file overnightindexedcoupon.cpp.

                                                              {
    inArrears_ = inArrears;
    return *this;
}

◆ withLastRecentPeriod()

OvernightLeg & withLastRecentPeriod ( const boost::optional< Period > & lastRecentPeriod )

Definition at line 584 of file overnightindexedcoupon.cpp.

                                                                                              {
    lastRecentPeriod_ = lastRecentPeriod;
    return *this;
}

◆ withLastRecentPeriodCalendar()

OvernightLeg & withLastRecentPeriodCalendar ( const Calendar & lastRecentPeriodCalendar )

Definition at line 589 of file overnightindexedcoupon.cpp.

                                                                                                 {
    lastRecentPeriodCalendar_ = lastRecentPeriodCalendar;
    return *this;
}

◆ withOvernightIndexedCouponPricer()

OvernightLeg & withOvernightIndexedCouponPricer ( const QuantLib::ext::shared_ptr< OvernightIndexedCouponPricer > & couponPricer )

Definition at line 600 of file overnightindexedcoupon.cpp.

                                                                                                                      {
    couponPricer_ = couponPricer;
    return *this;
}

◆ withPaymentDates()

OvernightLeg & withPaymentDates ( const std::vector< Date > & paymentDates )

Definition at line 594 of file overnightindexedcoupon.cpp.

                                                                                {
    paymentDates_ = paymentDates;
    return *this;
}

◆ withCapFlooredOvernightIndexedCouponPricer()

OvernightLeg & withCapFlooredOvernightIndexedCouponPricer ( const QuantLib::ext::shared_ptr< CappedFlooredOvernightIndexedCouponPricer > & couponPricer )

Definition at line 605 of file overnightindexedcoupon.cpp.

                                                                                          {
    capFlooredCouponPricer_ = couponPricer;
    return *this;
}

◆ operator Leg()

operator Leg ( ) const

Definition at line 611 of file overnightindexedcoupon.cpp.

                                 {
 
    QL_REQUIRE(!notionals_.empty(), "no notional given for compounding overnight leg");
 
    Leg cashflows;
 
    Calendar calendar = schedule_.calendar();
    Calendar paymentCalendar = paymentCalendar_;
 
    if (calendar.empty())
        calendar = paymentCalendar;
    if (calendar.empty())
        calendar = WeekendsOnly();
    if (paymentCalendar.empty())
        paymentCalendar = calendar;
 
    Date refStart, start, refEnd, end;
    Date paymentDate;
 
    Size n = schedule_.size() - 1;
 
    // Initial consistency checks
    if (!paymentDates_.empty()) {
        QL_REQUIRE(paymentDates_.size() == n, "Expected the number of explicit payment dates ("
                                                  << paymentDates_.size()
                                                  << ") to equal the number of calculation periods ("
                                                  << n << ")");
    }
 
    for (Size i = 0; i < n; ++i) {
        refStart = start = schedule_.date(i);
        refEnd = end = schedule_.date(i + 1);
 
        // If explicit payment dates provided, use them.
        if (!paymentDates_.empty()) {
            paymentDate = paymentDates_[i];
        } else {
            paymentDate = paymentCalendar.advance(end, paymentLag_, Days, paymentAdjustment_);
        }
 
        // determine refStart and refEnd
 
        if (i == 0 && schedule_.hasIsRegular() && !schedule_.isRegular(i + 1))
            refStart = calendar.adjust(end - schedule_.tenor(), paymentAdjustment_);
        if (i == n - 1 && schedule_.hasIsRegular() && !schedule_.isRegular(i + 1))
            refEnd = calendar.adjust(start + schedule_.tenor(), paymentAdjustment_);
 
        // Determine the rate computation start and end date as
        // - the coupon start and end date, if in arrears, and
        // - the previous coupon start and end date, if in advance.
        // In addition, adjust the start date, if a last recent period is given.
 
        Date rateComputationStartDate, rateComputationEndDate;
        if (inArrears_) {
            // in arrears fixing (i.e. the "classic" case)
            rateComputationStartDate = start;
            rateComputationEndDate = end;
        } else {
            // handle in advance fixing
            if (i > 0) {
                // if there is a previous period, we take that
                rateComputationStartDate = schedule_.date(i - 1);
                rateComputationEndDate = schedule_.date(i);
            } else {
                // otherwise we construct the previous period
                rateComputationEndDate = start;
                if (schedule_.hasTenor() && schedule_.tenor() != 0 * Days)
                    rateComputationStartDate = calendar.adjust(start - schedule_.tenor(), Preceding);
                else
                    rateComputationStartDate = calendar.adjust(start - (end - start), Preceding);
            }
        }
 
        if (lastRecentPeriod_) {
            rateComputationStartDate = (lastRecentPeriodCalendar_.empty() ? calendar : lastRecentPeriodCalendar_)
                                           .advance(rateComputationEndDate, -*lastRecentPeriod_);
        }
 
        // build coupon
 
        if (close_enough(detail::get(gearings_, i, 1.0), 0.0)) {
            // fixed coupon
            cashflows.push_back(QuantLib::ext::make_shared<FixedRateCoupon>(
                paymentDate, detail::get(notionals_, i, 1.0), detail::effectiveFixedRate(spreads_, caps_, floors_, i),
                paymentDayCounter_, start, end, refStart, refEnd));
        } else {
            // floating coupon
            auto cpn = ext::make_shared<OvernightIndexedCoupon>(
                paymentDate, detail::get(notionals_, i, 1.0), start, end, overnightIndex_,
                detail::get(gearings_, i, 1.0), detail::get(spreads_, i, 0.0), refStart, refEnd, paymentDayCounter_,
                telescopicValueDates_, includeSpread_, lookback_, rateCutoff_, fixingDays_, rateComputationStartDate,
                rateComputationEndDate);
            if (couponPricer_) {
                cpn->setPricer(couponPricer_);
            }
            Real cap = detail::get(caps_, i, Null<Real>());
            Real floor = detail::get(floors_, i, Null<Real>());
            if (cap == Null<Real>() && floor == Null<Real>()) {
                cashflows.push_back(cpn);
            } else {
                auto cfCpn = ext::make_shared<CappedFlooredOvernightIndexedCoupon>(cpn, cap, floor, nakedOption_,
                                                                                   localCapFloor_);
                if (capFlooredCouponPricer_) {
                    cfCpn->setPricer(capFlooredCouponPricer_);
                }
                cashflows.push_back(cfCpn);
            }
        }
    }
    return cashflows;
}