Helper class building a sequence of commodity indexed cashflows. More...

#include <qle/cashflows/commodityindexedcashflow.hpp>

Collaboration diagram for CommodityIndexedLeg:

Public Member Functions
	CommodityIndexedLeg (const QuantLib::Schedule &schedule, const ext::shared_ptr< CommodityIndex > &index)

CommodityIndexedLeg &	withQuantities (QuantLib::Real quantity)

CommodityIndexedLeg &	withQuantities (const std::vector< QuantLib::Real > &quantities)

CommodityIndexedLeg &	withPaymentLag (QuantLib::Natural paymentLag)

CommodityIndexedLeg &	withPaymentCalendar (const QuantLib::Calendar &paymentCalendar)

CommodityIndexedLeg &	withPaymentConvention (QuantLib::BusinessDayConvention paymentConvention)

CommodityIndexedLeg &	withPricingLag (QuantLib::Natural pricingLag)

CommodityIndexedLeg &	withPricingLagCalendar (const QuantLib::Calendar &pricingLagCalendar)

CommodityIndexedLeg &	withSpreads (QuantLib::Real spread)

CommodityIndexedLeg &	withSpreads (const std::vector< QuantLib::Real > &spreads)

CommodityIndexedLeg &	withGearings (QuantLib::Real gearing)

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

CommodityIndexedLeg &	paymentTiming (CommodityIndexedCashFlow::PaymentTiming paymentTiming)

CommodityIndexedLeg &	inArrears (bool flag=true)

CommodityIndexedLeg &	useFuturePrice (bool flag=false)

CommodityIndexedLeg &	useFutureExpiryDate (bool flag=true)

CommodityIndexedLeg &	withFutureMonthOffset (QuantLib::Natural futureMonthOffset)

CommodityIndexedLeg &	withFutureExpiryCalculator (const ext::shared_ptr< FutureExpiryCalculator > &calc=nullptr)

CommodityIndexedLeg &	payAtMaturity (bool flag=false)

CommodityIndexedLeg &	withPricingDates (const std::vector< QuantLib::Date > &pricingDates)

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

CommodityIndexedLeg &	withDailyExpiryOffset (QuantLib::Natural dailyExpiryOffset)

CommodityIndexedLeg &	withFxIndex (const ext::shared_ptr< FxIndex > &fxIndex)

CommodityIndexedLeg &	withIsAveraging (const bool isAveraging)

CommodityIndexedLeg &	withPricingCalendar (const QuantLib::Calendar &pricingCalendar)

CommodityIndexedLeg &	includeEndDate (bool flag=true)

CommodityIndexedLeg &	excludeStartDate (bool flag=true)

	operator Leg () const

Private Attributes
Schedule	schedule_

ext::shared_ptr< CommodityIndex >	index_

std::vector< QuantLib::Real >	quantities_

QuantLib::Natural	paymentLag_

QuantLib::Calendar	paymentCalendar_

QuantLib::BusinessDayConvention	paymentConvention_

QuantLib::Natural	pricingLag_

QuantLib::Calendar	pricingLagCalendar_

std::vector< QuantLib::Real >	spreads_

std::vector< QuantLib::Real >	gearings_

CommodityIndexedCashFlow::PaymentTiming	paymentTiming_

bool	inArrears_

bool	useFuturePrice_

bool	useFutureExpiryDate_

QuantLib::Natural	futureMonthOffset_

ext::shared_ptr< FutureExpiryCalculator >	calc_

bool	payAtMaturity_

std::vector< QuantLib::Date >	pricingDates_

std::vector< QuantLib::Date >	paymentDates_

QuantLib::Natural	dailyExpiryOffset_

ext::shared_ptr< FxIndex >	fxIndex_

bool	isAveraging_

QuantLib::Calendar	pricingCalendar_

bool	includeEndDate_

bool	excludeStartDate_

Detailed Description

Helper class building a sequence of commodity indexed cashflows.

Definition at line 146 of file commodityindexedcashflow.hpp.

Constructor & Destructor Documentation

◆ CommodityIndexedLeg()

CommodityIndexedLeg	(	const QuantLib::Schedule &	schedule,
		const ext::shared_ptr< CommodityIndex > &	index
	)

Definition at line 191 of file commodityindexedcashflow.cpp.

    : schedule_(schedule), index_(index), paymentLag_(0), paymentCalendar_(NullCalendar()),
      paymentConvention_(Unadjusted), pricingLag_(0), pricingLagCalendar_(NullCalendar()),
      paymentTiming_(CommodityIndexedCashFlow::PaymentTiming::InArrears), inArrears_(true), useFuturePrice_(false),
      useFutureExpiryDate_(true), futureMonthOffset_(0), payAtMaturity_(false), dailyExpiryOffset_(Null<Natural>()), 
      isAveraging_(false), pricingCalendar_(NullCalendar()), includeEndDate_(true), excludeStartDate_(true) {}

Member Function Documentation

◆ withQuantities() [1/2]

CommodityIndexedLeg & withQuantities ( QuantLib::Real quantity )

◆ withQuantities() [2/2]

CommodityIndexedLeg & withQuantities ( const std::vector< QuantLib::Real > & quantities )

◆ withPaymentLag()

CommodityIndexedLeg & withPaymentLag ( QuantLib::Natural paymentLag )

Definition at line 208 of file commodityindexedcashflow.cpp.

                                                                           {
    paymentLag_ = paymentLag;
    return *this;
}

◆ withPaymentCalendar()

CommodityIndexedLeg & withPaymentCalendar ( const QuantLib::Calendar & paymentCalendar )

Definition at line 213 of file commodityindexedcashflow.cpp.

                                                                                             {
    paymentCalendar_ = paymentCalendar;
    return *this;
}

◆ withPaymentConvention()

CommodityIndexedLeg & withPaymentConvention ( QuantLib::BusinessDayConvention paymentConvention )

Definition at line 218 of file commodityindexedcashflow.cpp.

                                                                                                       {
    paymentConvention_ = paymentConvention;
    return *this;
}

◆ withPricingLag()

CommodityIndexedLeg & withPricingLag ( QuantLib::Natural pricingLag )

Definition at line 223 of file commodityindexedcashflow.cpp.

                                                                           {
    pricingLag_ = pricingLag;
    return *this;
}

◆ withPricingLagCalendar()

CommodityIndexedLeg & withPricingLagCalendar ( const QuantLib::Calendar & pricingLagCalendar )

Definition at line 228 of file commodityindexedcashflow.cpp.

                                                                                                   {
    pricingLagCalendar_ = pricingLagCalendar;
    return *this;
}

◆ withSpreads() [1/2]

CommodityIndexedLeg & withSpreads ( QuantLib::Real spread )

◆ withSpreads() [2/2]

CommodityIndexedLeg & withSpreads ( const std::vector< QuantLib::Real > & spreads )

◆ withGearings() [1/2]

CommodityIndexedLeg & withGearings ( QuantLib::Real gearing )

◆ withGearings() [2/2]

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

◆ paymentTiming()

CommodityIndexedLeg & paymentTiming ( CommodityIndexedCashFlow::PaymentTiming paymentTiming )

Definition at line 253 of file commodityindexedcashflow.cpp.

                                                                                                           {
    paymentTiming_ = paymentTiming;
    return *this;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ inArrears()

CommodityIndexedLeg & inArrears ( bool flag = true )

Definition at line 258 of file commodityindexedcashflow.cpp.

                                                             {
    inArrears_ = flag;
    return *this;
}

◆ useFuturePrice()

CommodityIndexedLeg & useFuturePrice ( bool flag = false )

Definition at line 263 of file commodityindexedcashflow.cpp.

                                                                  {
    useFuturePrice_ = flag;
    return *this;
}

◆ useFutureExpiryDate()

CommodityIndexedLeg & useFutureExpiryDate ( bool flag = true )

Definition at line 268 of file commodityindexedcashflow.cpp.

                                                                       {
    useFutureExpiryDate_ = flag;
    return *this;
}

◆ withFutureMonthOffset()

CommodityIndexedLeg & withFutureMonthOffset ( QuantLib::Natural futureMonthOffset )

Definition at line 273 of file commodityindexedcashflow.cpp.

                                                                                         {
    futureMonthOffset_ = futureMonthOffset;
    return *this;
}

◆ withFutureExpiryCalculator()

CommodityIndexedLeg & withFutureExpiryCalculator ( const ext::shared_ptr< FutureExpiryCalculator > & calc = nullptr )

Definition at line 279 of file commodityindexedcashflow.cpp.

                                                                                                 {
    calc_ = calc;
    return *this;
}

◆ payAtMaturity()

CommodityIndexedLeg & payAtMaturity ( bool flag = false )

Definition at line 284 of file commodityindexedcashflow.cpp.

                                                                 {
    payAtMaturity_ = flag;
    return *this;
}

◆ withPricingDates()

CommodityIndexedLeg & withPricingDates ( const std::vector< QuantLib::Date > & pricingDates )

Definition at line 289 of file commodityindexedcashflow.cpp.

                                                                                           {
    pricingDates_ = pricingDates;
    return *this;
}

Here is the call graph for this function:

◆ withPaymentDates()

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

Definition at line 294 of file commodityindexedcashflow.cpp.

                                                                                           {
    paymentDates_ = paymentDates;
    return *this;
}

◆ withDailyExpiryOffset()

CommodityIndexedLeg & withDailyExpiryOffset ( QuantLib::Natural dailyExpiryOffset )

Definition at line 299 of file commodityindexedcashflow.cpp.

                                                                                         {
    dailyExpiryOffset_ = dailyExpiryOffset;
    return *this;
}

◆ withFxIndex()

CommodityIndexedLeg & withFxIndex ( const ext::shared_ptr< FxIndex > & fxIndex )

Definition at line 304 of file commodityindexedcashflow.cpp.

                                                                                           {
    fxIndex_ = fxIndex;
    return *this;
}

◆ withIsAveraging()

CommodityIndexedLeg & withIsAveraging ( const bool isAveraging )

Definition at line 309 of file commodityindexedcashflow.cpp.

                                                                                {
    isAveraging_ = isAveraging;
    return *this;
}

◆ withPricingCalendar()

CommodityIndexedLeg & withPricingCalendar ( const QuantLib::Calendar & pricingCalendar )

Definition at line 314 of file commodityindexedcashflow.cpp.

                                                                                             {
    pricingCalendar_ = pricingCalendar;
    return *this;
}

◆ includeEndDate()

CommodityIndexedLeg & includeEndDate ( bool flag = true )

Definition at line 319 of file commodityindexedcashflow.cpp.

                                                                                  {
    includeEndDate_ = includeEndDate;
    return *this;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ excludeStartDate()

CommodityIndexedLeg & excludeStartDate ( bool flag = true )

Definition at line 324 of file commodityindexedcashflow.cpp.

                                                                                      {
    excludeStartDate_ = excludeStartDate;
    return *this;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator Leg()

operator Leg ( ) const

Definition at line 329 of file commodityindexedcashflow.cpp.

                                        {
 
    // Number of commodity indexed cashflows
    Size numberCashflows = schedule_.size() - 1;
 
    // Initial consistency checks
    QL_REQUIRE(!quantities_.empty(), "No quantities given");
    QL_REQUIRE(quantities_.size() <= numberCashflows,
               "Too many quantities (" << quantities_.size() << "), only " << numberCashflows << " required");
    if (useFuturePrice_) {
        QL_REQUIRE(calc_, "CommodityIndexedCashFlow needs a valid future expiry calculator when using first future");
    }
    if (!pricingDates_.empty()) {
        QL_REQUIRE(pricingDates_.size() == numberCashflows, "Expected the number of explicit pricing dates ("
                                                                << pricingDates_.size()
                                                                << ") to equal the number of calculation periods ("
                                                                << numberCashflows << ")");
    }
    if (!paymentDates_.empty()) {
        QL_REQUIRE(paymentDates_.size() == numberCashflows, "Expected the number of explicit payment dates ("
                                                                << paymentDates_.size()
                                                                << ") to equal the number of calculation periods ("
                                                                << numberCashflows << ")");
    }
 
    // If pay at maturity, populate payment date.
    Date paymentDate;
    if (payAtMaturity_) {
        paymentDate = paymentCalendar_.advance(schedule_.dates().back(), paymentLag_ * Days, paymentConvention_);
    }
 
    // Leg to hold the result
    Leg leg;
    leg.reserve(numberCashflows);
    for (Size i = 0; i < numberCashflows; ++i) {
 
        Date start = schedule_.date(i);
        Date end = schedule_.date(i + 1);
        Real quantity = detail::get(quantities_, i, 1.0);
        Real spread = detail::get(spreads_, i, 0.0);
        Real gearing = detail::get(gearings_, i, 1.0);
        Date pricingDate = detail::get(pricingDates_, i, Date());
        bool excludeStart = i == 0 ? false : excludeStartDate_;
        bool includeEnd = i == numberCashflows - 1 ? true : includeEndDate_;
 
        // If explicit payment dates provided, use them.
        if (!paymentDates_.empty()) {
            paymentDate = paymentDates_[i];
        }
 
        leg.push_back(ext::make_shared<CommodityIndexedCashFlow>(
            quantity, start, end, index_, paymentLag_, paymentCalendar_, paymentConvention_, pricingLag_,
            pricingLagCalendar_, spread, gearing, paymentTiming_, inArrears_, useFuturePrice_, useFutureExpiryDate_,
            futureMonthOffset_, calc_, paymentDate, pricingDate, dailyExpiryOffset_, fxIndex_, isAveraging_,
            pricingCalendar_, includeEnd, excludeStart));
    }
 
    return leg;
}