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

#include <qle/cashflows/commodityindexedaveragecashflow.hpp>

Collaboration diagram for CommodityIndexedAverageLeg:

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

CommodityIndexedAverageLeg &	withQuantities (QuantLib::Real quantity)

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

CommodityIndexedAverageLeg &	withPaymentLag (QuantLib::Natural paymentLag)

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

CommodityIndexedAverageLeg &	withPaymentConvention (QuantLib::BusinessDayConvention paymentConvention)

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

CommodityIndexedAverageLeg &	withSpreads (QuantLib::Real spread)

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

CommodityIndexedAverageLeg &	withGearings (QuantLib::Real gearing)

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

CommodityIndexedAverageLeg &	paymentTiming (CommodityIndexedAverageCashFlow::PaymentTiming paymentTiming)

CommodityIndexedAverageLeg &	useFuturePrice (bool flag=false)

CommodityIndexedAverageLeg &	withDeliveryDateRoll (QuantLib::Natural deliveryDateRoll)

CommodityIndexedAverageLeg &	withFutureMonthOffset (QuantLib::Natural futureMonthOffset)

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

CommodityIndexedAverageLeg &	payAtMaturity (bool flag=false)

CommodityIndexedAverageLeg &	includeEndDate (bool flag=true)

CommodityIndexedAverageLeg &	excludeStartDate (bool flag=true)

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

CommodityIndexedAverageLeg &	useBusinessDays (bool flag=true)

CommodityIndexedAverageLeg &	withQuantityFrequency (CommodityQuantityFrequency quantityFrequency)

CommodityIndexedAverageLeg &	withHoursPerDay (QuantLib::Natural hoursPerDay)

CommodityIndexedAverageLeg &	withDailyExpiryOffset (QuantLib::Natural dailyExpiryOffset)

CommodityIndexedAverageLeg &	unrealisedQuantity (bool flag=false)

CommodityIndexedAverageLeg &	withOffPeakPowerData (const boost::optional< std::pair< QuantLib::Calendar, QuantLib::Real > > &offPeakPowerData)

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

	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::Calendar	pricingCalendar_

std::vector< QuantLib::Real >	spreads_

std::vector< QuantLib::Real >	gearings_

CommodityIndexedAverageCashFlow::PaymentTiming	paymentTiming_

bool	useFuturePrice_

QuantLib::Natural	deliveryDateRoll_

QuantLib::Natural	futureMonthOffset_

ext::shared_ptr< FutureExpiryCalculator >	calc_

bool	payAtMaturity_

bool	includeEndDate_

bool	excludeStartDate_

std::vector< QuantLib::Date >	paymentDates_

bool	useBusinessDays_

CommodityQuantityFrequency	quantityFrequency_

QuantLib::Natural	hoursPerDay_

QuantLib::Natural	dailyExpiryOffset_

bool	unrealisedQuantity_

boost::optional< std::pair< QuantLib::Calendar, QuantLib::Real > >	offPeakPowerData_

ext::shared_ptr< FxIndex >	fxIndex_

Detailed Description

Helper class building a sequence of commodity indexed average cashflows.

Definition at line 174 of file commodityindexedaveragecashflow.hpp.

Constructor & Destructor Documentation

◆ CommodityIndexedAverageLeg()

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

Definition at line 279 of file commodityindexedaveragecashflow.cpp.

    : schedule_(schedule), index_(index), paymentLag_(0), paymentCalendar_(NullCalendar()),
      paymentConvention_(Unadjusted), pricingCalendar_(Calendar()),
      paymentTiming_(CommodityIndexedAverageCashFlow::PaymentTiming::InArrears), useFuturePrice_(false),
      deliveryDateRoll_(0), futureMonthOffset_(0), payAtMaturity_(false), includeEndDate_(true),
      excludeStartDate_(true), useBusinessDays_(true),
      quantityFrequency_(CommodityQuantityFrequency::PerCalculationPeriod), hoursPerDay_(Null<Natural>()),
      dailyExpiryOffset_(Null<Natural>()), unrealisedQuantity_(false) {}

Member Function Documentation

◆ withQuantities() [1/2]

CommodityIndexedAverageLeg & withQuantities ( QuantLib::Real quantity )

Here is the caller graph for this function:

◆ withQuantities() [2/2]

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

◆ withPaymentLag()

CommodityIndexedAverageLeg & withPaymentLag ( QuantLib::Natural paymentLag )

Definition at line 299 of file commodityindexedaveragecashflow.cpp.

                                                                                         {
    paymentLag_ = paymentLag;
    return *this;
}

◆ withPaymentCalendar()

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

Definition at line 304 of file commodityindexedaveragecashflow.cpp.

                                                                                                           {
    paymentCalendar_ = paymentCalendar;
    return *this;
}

◆ withPaymentConvention()

CommodityIndexedAverageLeg & withPaymentConvention ( QuantLib::BusinessDayConvention paymentConvention )

Definition at line 309 of file commodityindexedaveragecashflow.cpp.

                                                                                                                     {
    paymentConvention_ = paymentConvention;
    return *this;
}

◆ withPricingCalendar()

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

Definition at line 314 of file commodityindexedaveragecashflow.cpp.

                                                                                                           {
    pricingCalendar_ = pricingCalendar;
    return *this;
}

◆ withSpreads() [1/2]

CommodityIndexedAverageLeg & withSpreads ( QuantLib::Real spread )

◆ withSpreads() [2/2]

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

◆ withGearings() [1/2]

CommodityIndexedAverageLeg & withGearings ( QuantLib::Real gearing )

◆ withGearings() [2/2]

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

◆ paymentTiming()

CommodityIndexedAverageLeg & paymentTiming ( CommodityIndexedAverageCashFlow::PaymentTiming paymentTiming )

Definition at line 340 of file commodityindexedaveragecashflow.cpp.

                                                                                                    {
    paymentTiming_ = paymentTiming;
    return *this;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ useFuturePrice()

CommodityIndexedAverageLeg & useFuturePrice ( bool flag = false )

Definition at line 345 of file commodityindexedaveragecashflow.cpp.

                                                                                {
    useFuturePrice_ = flag;
    return *this;
}

Here is the caller graph for this function:

◆ withDeliveryDateRoll()

CommodityIndexedAverageLeg & withDeliveryDateRoll ( QuantLib::Natural deliveryDateRoll )

Definition at line 350 of file commodityindexedaveragecashflow.cpp.

                                                                                                     {
    deliveryDateRoll_ = deliveryDateRoll;
    return *this;
}

◆ withFutureMonthOffset()

CommodityIndexedAverageLeg & withFutureMonthOffset ( QuantLib::Natural futureMonthOffset )

Definition at line 355 of file commodityindexedaveragecashflow.cpp.

                                                                                                       {
    futureMonthOffset_ = futureMonthOffset;
    return *this;
}

◆ withFutureExpiryCalculator()

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

Definition at line 361 of file commodityindexedaveragecashflow.cpp.

                                                                                                        {
    calc_ = calc;
    return *this;
}

Here is the caller graph for this function:

◆ payAtMaturity()

CommodityIndexedAverageLeg & payAtMaturity ( bool flag = false )

Definition at line 366 of file commodityindexedaveragecashflow.cpp.

                                                                               {
    payAtMaturity_ = flag;
    return *this;
}

◆ includeEndDate()

CommodityIndexedAverageLeg & includeEndDate ( bool flag = true )

Definition at line 371 of file commodityindexedaveragecashflow.cpp.

                                                                                {
    includeEndDate_ = flag;
    return *this;
}

◆ excludeStartDate()

CommodityIndexedAverageLeg & excludeStartDate ( bool flag = true )

Definition at line 376 of file commodityindexedaveragecashflow.cpp.

                                                                                  {
    excludeStartDate_ = flag;
    return *this;
}

◆ withPaymentDates()

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

Definition at line 381 of file commodityindexedaveragecashflow.cpp.

                                                                                                         {
    paymentDates_ = paymentDates;
    return *this;
}

◆ useBusinessDays()

CommodityIndexedAverageLeg & useBusinessDays ( bool flag = true )

Definition at line 386 of file commodityindexedaveragecashflow.cpp.

                                                                                 {
    useBusinessDays_ = flag;
    return *this;
}

◆ withQuantityFrequency()

CommodityIndexedAverageLeg & withQuantityFrequency ( CommodityQuantityFrequency quantityFrequency )

Definition at line 391 of file commodityindexedaveragecashflow.cpp.

                                                  {
    quantityFrequency_ = quantityFrequency;
    return *this;
}

◆ withHoursPerDay()

CommodityIndexedAverageLeg & withHoursPerDay ( QuantLib::Natural hoursPerDay )

Definition at line 397 of file commodityindexedaveragecashflow.cpp.

                                                                                           {
    hoursPerDay_ = hoursPerDay;
    return *this;
}

◆ withDailyExpiryOffset()

CommodityIndexedAverageLeg & withDailyExpiryOffset ( QuantLib::Natural dailyExpiryOffset )

Definition at line 402 of file commodityindexedaveragecashflow.cpp.

                                                                                                       {
    dailyExpiryOffset_ = dailyExpiryOffset;
    return *this;
}

◆ unrealisedQuantity()

CommodityIndexedAverageLeg & unrealisedQuantity ( bool flag = false )

Definition at line 407 of file commodityindexedaveragecashflow.cpp.

                                                                                    {
    unrealisedQuantity_ = flag;
    return *this;
}

◆ withOffPeakPowerData()

CommodityIndexedAverageLeg & withOffPeakPowerData ( const boost::optional< std::pair< QuantLib::Calendar, QuantLib::Real > > & offPeakPowerData )

Definition at line 417 of file commodityindexedaveragecashflow.cpp.

                                                                                                                                         {
    offPeakPowerData_ = offPeakPowerData;
    return *this;
}

◆ withFxIndex()

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

Definition at line 412 of file commodityindexedaveragecashflow.cpp.

                                                                                                         {
    fxIndex_ = fxIndex;
    return *this;
}

◆ operator Leg()

operator Leg ( ) const

Definition at line 422 of file commodityindexedaveragecashflow.cpp.

                                               {
 
    // Number of commodity indexed average 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 (!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
    // We always include the schedule start and schedule termination date in the averaging so the first and last
    // coupon have special treatment here that overrides the includeEndDate_ and excludeStartDate_ flags
    Leg leg;
    leg.reserve(numberCashflows);
    for (Size i = 0; i < numberCashflows; ++i) {
 
        Date start = schedule_.date(i);
        Date end = schedule_.date(i + 1);
        bool excludeStart = i == 0 ? false : excludeStartDate_;
        bool includeEnd = i == numberCashflows - 1 ? true : includeEndDate_;
        Real quantity = detail::get(quantities_, i, 1.0);
        Real spread = detail::get(spreads_, i, 0.0);
        Real gearing = detail::get(gearings_, i, 1.0);
 
        // If explicit payment dates provided, use them.
        if (!paymentDates_.empty()) {
            paymentDate = paymentDates_[i];
        }
 
        leg.push_back(ext::make_shared<CommodityIndexedAverageCashFlow>(
            quantity, start, end, paymentLag_, paymentCalendar_, paymentConvention_, index_, pricingCalendar_, spread,
            gearing, paymentTiming_, useFuturePrice_, deliveryDateRoll_, futureMonthOffset_, calc_, includeEnd,
            excludeStart, paymentDate, useBusinessDays_, quantityFrequency_, hoursPerDay_, dailyExpiryOffset_,
            unrealisedQuantity_, offPeakPowerData_, fxIndex_));
    }
 
    return leg;
}