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

#include <qle/cashflows/averageonindexedcoupon.hpp>

Collaboration diagram for AverageONLeg:

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

AverageONLeg &	withNotional (Real notional)

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

AverageONLeg &	withPaymentDayCounter (const DayCounter &dayCounter)

AverageONLeg &	withPaymentAdjustment (BusinessDayConvention convention)

AverageONLeg &	withGearing (Real gearing)

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

AverageONLeg &	withSpread (Spread spread)

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

AverageONLeg &	withTelescopicValueDates (bool telescopicValueDates)

AverageONLeg &	withRateCutoff (Natural rateCutoff)

AverageONLeg &	withPaymentCalendar (const Calendar &calendar)

AverageONLeg &	withPaymentLag (Natural lag)

AverageONLeg &	withLookback (const Period &lookback)

AverageONLeg &	withFixingDays (const Size fixingDays)

AverageONLeg &	withCaps (Rate cap)

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

AverageONLeg &	withFloors (Rate floor)

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

AverageONLeg &	includeSpreadInCapFloors (bool includeSpread)

AverageONLeg &	withNakedOption (const bool nakedOption)

AverageONLeg &	withLocalCapFloor (const bool localCapFloor)

AverageONLeg &	withInArrears (const bool inArrears)

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

AverageONLeg &	withLastRecentPeriodCalendar (const Calendar &lastRecentPeriodCalendar)

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

AverageONLeg &	withAverageONIndexedCouponPricer (const QuantLib::ext::shared_ptr< AverageONIndexedCouponPricer > &couponPricer)

AverageONLeg &	withCapFlooredAverageONIndexedCouponPricer (const QuantLib::ext::shared_ptr< CapFlooredAverageONIndexedCouponPricer > &couponPricer)

	operator Leg () const

Private Attributes
Schedule	schedule_

QuantLib::ext::shared_ptr< OvernightIndex >	overnightIndex_

std::vector< Real >	notionals_

DayCounter	paymentDayCounter_

BusinessDayConvention	paymentAdjustment_

Natural	paymentLag_

std::vector< Real >	gearings_

std::vector< Spread >	spreads_

bool	telescopicValueDates_

Calendar	paymentCalendar_

Natural	rateCutoff_

Period	lookback_

Natural	fixingDays_

std::vector< Rate >	caps_

std::vector< Rate >	floors_

bool	includeSpread_

bool	nakedOption_

bool	localCapFloor_

bool	inArrears_

boost::optional< Period >	lastRecentPeriod_

Calendar	lastRecentPeriodCalendar_

std::vector< QuantLib::Date >	paymentDates_

QuantLib::ext::shared_ptr< AverageONIndexedCouponPricer >	couponPricer_

QuantLib::ext::shared_ptr< CapFlooredAverageONIndexedCouponPricer >	capFlooredCouponPricer_

Detailed Description

helper class building a sequence of overnight coupons

Definition at line 179 of file averageonindexedcoupon.hpp.

Constructor & Destructor Documentation

◆ AverageONLeg()

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

Definition at line 295 of file averageonindexedcoupon.cpp.

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

Member Function Documentation

◆ withNotional()

AverageONLeg & withNotional ( Real notional )

Definition at line 300 of file averageonindexedcoupon.cpp.

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

Here is the caller graph for this function:

◆ withNotionals()

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

Definition at line 305 of file averageonindexedcoupon.cpp.

                                                                          {
    notionals_ = notionals;
    return *this;
}

Here is the caller graph for this function:

◆ withPaymentDayCounter()

AverageONLeg & withPaymentDayCounter ( const DayCounter & dayCounter )

Definition at line 310 of file averageonindexedcoupon.cpp.

                                                                              {
    paymentDayCounter_ = dayCounter;
    return *this;
}

Here is the caller graph for this function:

◆ withPaymentAdjustment()

AverageONLeg & withPaymentAdjustment ( BusinessDayConvention convention )

Definition at line 315 of file averageonindexedcoupon.cpp.

                                                                                  {
    paymentAdjustment_ = convention;
    return *this;
}

Here is the caller graph for this function:

◆ withGearing()

AverageONLeg & withGearing ( Real gearing )

Definition at line 320 of file averageonindexedcoupon.cpp.

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

Here is the caller graph for this function:

◆ withGearings()

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

Definition at line 325 of file averageonindexedcoupon.cpp.

                                                                        {
    gearings_ = gearings;
    return *this;
}

Here is the caller graph for this function:

◆ withSpread()

AverageONLeg & withSpread ( Spread spread )

Definition at line 330 of file averageonindexedcoupon.cpp.

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

Here is the caller graph for this function:

◆ withSpreads()

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

Definition at line 335 of file averageonindexedcoupon.cpp.

                                                                        {
    spreads_ = spreads;
    return *this;
}

Here is the caller graph for this function:

◆ withTelescopicValueDates()

AverageONLeg & withTelescopicValueDates ( bool telescopicValueDates )

Definition at line 340 of file averageonindexedcoupon.cpp.

                                                                              {
    telescopicValueDates_ = telescopicValueDates;
    return *this;
}

Here is the caller graph for this function:

◆ withRateCutoff()

AverageONLeg & withRateCutoff ( Natural rateCutoff )

Definition at line 345 of file averageonindexedcoupon.cpp.

                                                             {
    rateCutoff_ = rateCutoff;
    return *this;
}

Here is the caller graph for this function:

◆ withPaymentCalendar()

AverageONLeg & withPaymentCalendar ( const Calendar & calendar )

Definition at line 350 of file averageonindexedcoupon.cpp.

                                                                        {
    paymentCalendar_ = calendar;
    return *this;
}

Here is the caller graph for this function:

◆ withPaymentLag()

AverageONLeg & withPaymentLag ( Natural lag )

Definition at line 355 of file averageonindexedcoupon.cpp.

                                                      {
    paymentLag_ = lag;
    return *this;
}

Here is the caller graph for this function:

◆ withLookback()

AverageONLeg & withLookback ( const Period & lookback )

Definition at line 360 of file averageonindexedcoupon.cpp.

                                                               {
    lookback_ = lookback;
    return *this;
}

Here is the caller graph for this function:

◆ withFixingDays()

AverageONLeg & withFixingDays ( const Size fixingDays )

Definition at line 365 of file averageonindexedcoupon.cpp.

                                                                {
    fixingDays_ = fixingDays;
    return *this;
}

Here is the caller graph for this function:

◆ withCaps() [1/2]

AverageONLeg & withCaps ( Rate cap )

Definition at line 370 of file averageonindexedcoupon.cpp.

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

◆ withCaps() [2/2]

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

Definition at line 375 of file averageonindexedcoupon.cpp.

                                                                {
    caps_ = caps;
    return *this;
}

◆ withFloors() [1/2]

AverageONLeg & withFloors ( Rate floor )

Definition at line 380 of file averageonindexedcoupon.cpp.

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

◆ withFloors() [2/2]

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

Definition at line 385 of file averageonindexedcoupon.cpp.

                                                                    {
    floors_ = floors;
    return *this;
}

◆ includeSpreadInCapFloors()

AverageONLeg & includeSpreadInCapFloors ( bool includeSpread )

Definition at line 390 of file averageonindexedcoupon.cpp.

                                                                       {
    includeSpread_ = includeSpread;
    return *this;
}

◆ withNakedOption()

AverageONLeg & withNakedOption ( const bool nakedOption )

Definition at line 395 of file averageonindexedcoupon.cpp.

                                                                  {
    nakedOption_ = nakedOption;
    return *this;
}

◆ withLocalCapFloor()

AverageONLeg & withLocalCapFloor ( const bool localCapFloor )

Definition at line 400 of file averageonindexedcoupon.cpp.

                                                                      {
    localCapFloor_ = localCapFloor;
    return *this;
}

◆ withInArrears()

AverageONLeg & withInArrears ( const bool inArrears )

Definition at line 405 of file averageonindexedcoupon.cpp.

                                                              {
    inArrears_ = inArrears;
    return *this;
}

◆ withLastRecentPeriod()

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

Definition at line 410 of file averageonindexedcoupon.cpp.

                                                                                              {
    lastRecentPeriod_ = lastRecentPeriod;
    return *this;
}

◆ withLastRecentPeriodCalendar()

AverageONLeg & withLastRecentPeriodCalendar ( const Calendar & lastRecentPeriodCalendar )

Definition at line 415 of file averageonindexedcoupon.cpp.

                                                                                                 {
    lastRecentPeriodCalendar_ = lastRecentPeriodCalendar;
    return *this;
}

◆ withPaymentDates()

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

Definition at line 420 of file averageonindexedcoupon.cpp.

                                                                                {
    paymentDates_ = paymentDates;
    return *this;
}

◆ withAverageONIndexedCouponPricer()

AverageONLeg & withAverageONIndexedCouponPricer ( const QuantLib::ext::shared_ptr< AverageONIndexedCouponPricer > & couponPricer )

Definition at line 426 of file averageonindexedcoupon.cpp.

                                                                                                                      {
    couponPricer_ = couponPricer;
    return *this;
}

Here is the caller graph for this function:

◆ withCapFlooredAverageONIndexedCouponPricer()

AverageONLeg & withCapFlooredAverageONIndexedCouponPricer ( const QuantLib::ext::shared_ptr< CapFlooredAverageONIndexedCouponPricer > & couponPricer )

Definition at line 431 of file averageonindexedcoupon.cpp.

                                                                                       {
    capFlooredCouponPricer_ = couponPricer;
    return *this;
}

◆ operator Leg()

operator Leg ( ) const

Definition at line 437 of file averageonindexedcoupon.cpp.

                                 {
 
    QL_REQUIRE(!notionals_.empty(), "No notional given for average 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::get(spreads_, i, 0.0), paymentDayCounter_,
                                                                    start, end, refStart, refEnd));
        } else {
            // floating coupon
            auto cpn = QuantLib::ext::make_shared<AverageONIndexedCoupon>(
                paymentDate, detail::get(notionals_, i, notionals_.back()), start, end, overnightIndex_,
                detail::get(gearings_, i, 1.0), detail::get(spreads_, i, 0.0), rateCutoff_, paymentDayCounter_,
                lookback_, fixingDays_, rateComputationStartDate, rateComputationEndDate, telescopicValueDates_);
            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<CappedFlooredAverageONIndexedCoupon>(cpn, cap, floor, nakedOption_,
                                                                                   localCapFloor_, includeSpread_);
                if (capFlooredCouponPricer_) {
                    cfCpn->setPricer(capFlooredCouponPricer_);
                }
                cashflows.push_back(cfCpn);
            }
        }
    }
    return cashflows;
}