RequiredFixings Class Reference

#include <ored/portfolio/fixingdates.hpp>

Collaboration diagram for RequiredFixings:

Classes
class	FixingDates
struct	FixingEntry
struct	InflationFixingEntry
struct	ZeroInflationFixingEntry

Public Member Functions
std::map< std::string, FixingDates >	fixingDatesIndices (const QuantLib::Date &settlementDate=QuantLib::Date()) const
void	addFixingDate (const QuantLib::Date &fixingDate, const std::string &indexName, const QuantLib::Date &payDate=Date::maxDate(), const bool alwaysAddIfPaysOnSettlement=false, const bool mandatoryFixing=true)
void	addFixingDate (const FixingEntry &fixingEntry)
void	addFixingDates (const std::vector< std::pair< QuantLib::Date, bool > > &fixingDates, const std::string &indexName, const QuantLib::Date &payDate=Date::maxDate(), const bool alwaysAddIfPaysOnSettlement=false)
void	addFixingDates (const std::vector< QuantLib::Date > &fixingDates, const std::string &indexName, const QuantLib::Date &payDate=Date::maxDate(), const bool alwaysAddIfPaysOnSettlement=false, const bool mandatory=true)
void	addZeroInflationFixingDate (const QuantLib::Date &fixingDate, const std::string &indexName, const bool indexInterpolated, const Frequency indexFrequency, const Period &indexAvailabilityLag, const CPI::InterpolationType coupopnInterpolation, const Frequency couponFrequency, const QuantLib::Date &payDate=Date::maxDate(), const bool alwaysAddIfPaysOnSettlement=false, const bool mandatoryFixing=true)
void	addZeroInflationFixingDate (const ZeroInflationFixingEntry &fixingEntry)
void	addYoYInflationFixingDate (const QuantLib::Date &fixingDate, const std::string &indexName, const bool indexInterpolated, const Frequency indexFrequency, const Period &indexAvailabilityLag, const QuantLib::Date &payDate=Date::maxDate(), const bool alwaysAddIfPaysOnSettlement=false, const bool mandatoryFixing=true)
void	addYoYInflationFixingDate (const InflationFixingEntry &fixingEntry)
void	clear ()
void	addData (const RequiredFixings &requiredFixings)
void	unsetPayDates ()
RequiredFixings	makeCopyWithMandatoryOverride (bool mandatory)
RequiredFixings	filteredFixingDates (const QuantLib::Date &settlementDate=QuantLib::Date())

Private Attributes
std::set< FixingEntry >	fixingDates_
std::set< ZeroInflationFixingEntry >	zeroInflationFixingDates_
std::set< InflationFixingEntry >	yoyInflationFixingDates_

Friends
std::ostream &	operator<< (std::ostream &, const RequiredFixings &)

Detailed Description

Class holding the information on the fixings required to price a trade (or a portfolio of trades).

Definition at line 81 of file fixingdates.hpp.

Member Function Documentation

fixingDatesIndices()

std::map< std::string, RequiredFixings::FixingDates > fixingDatesIndices

(

const QuantLib::Date &

settlementDate = QuantLib::Date()

)

const

Gives back the dates for which fixings will be required to price the trade assuming a given settlementDate. If the settlementDate is not provided or is set equal to QuantLib::Date(), the settlement date in the implementation is assumed to be the Settings::instance().evaluationDate().

If a cashflow payment is deemed to have already occurred relative to the settlement date, then no fixing is needed. The determination of whether a cashflow has or has not occurred will in general rely on a call to CashFlow::hasOccurred which is important in cases where the cash flow payment date falls on the settlement date.

Another important case is where a cash flow fixing date occurs on the settlement date. In this case, we should always add the fixing date to the set of fixing dates regardless of Settings::instance().enforcesTodaysHistoricFixings().

Definition at line 290 of file fixingdates.cpp.

                                                                    {
 
    // If settlement date is an empty date, update to evaluation date.
    Date d = settlementDate == Date() ? Settings::instance().evaluationDate() : settlementDate;
 
    std::map<std::string, FixingDates> result;
 
    // handle the general case
    for (auto const& f : fixingDates_) {
        // get the data
        std::string indexName = f.indexName;
        Date fixingDate = f.fixingDate;
        Date payDate = f.payDate;
        bool alwaysAddIfPaysOnSettlement = f.alwaysAddIfPaysOnSettlement;
        // add to result
        if (fixingDate > d)
            continue;
        SimpleCashFlow dummyCf(0.0, payDate);
        if (!dummyCf.hasOccurred(d) || (alwaysAddIfPaysOnSettlement && dummyCf.date() == d)) {
            result[indexName].addDate(fixingDate, f.mandatory);
        }
    }
 
    // handle zero inflation index based coupons
    for (auto const& f : zeroInflationFixingDates_) {
        // get the data
        std::string indexName = f.indexName;
        Date fixingDate = f.fixingDate;
        Date payDate = f.payDate;
        bool alwaysAddIfPaysOnSettlement = f.alwaysAddIfPaysOnSettlement;
        bool indexInterpolated = f.indexInterpolated;
        Frequency indexFrequency = f.indexFreq;
        Period indexAvailabilityLag = f.availabilityLeg;
        CPI::InterpolationType couponInterpolation = f.couponInterpolation;
        Frequency couponFrequency = f.couponFrequency;
        // add to result
        SimpleCashFlow dummyCf(0.0, payDate);
        if (!dummyCf.hasOccurred(d) || (alwaysAddIfPaysOnSettlement && dummyCf.date() == d)) {
            RequiredFixings::FixingDates tmp;
            addZeroInflationDates(tmp, fixingDate, d, indexInterpolated, indexFrequency, indexAvailabilityLag,
                                  couponInterpolation, couponFrequency, f.mandatory);
            if (!tmp.empty())
                result[indexName].addDates(tmp);
        }
    }
 
    // handle yoy inflation index based coupons
    for (auto const& f : yoyInflationFixingDates_) {
        // get the data
        std::string indexName = f.indexName;
        Date fixingDate = f.fixingDate;
        Date payDate = f.payDate;
        bool alwaysAddIfPaysOnSettlement = f.alwaysAddIfPaysOnSettlement;
        bool indexInterpolated = f.indexInterpolated;
        Frequency indexFrequency = f.indexFreq;
        Period indexAvailabilityLag = f.availabilityLeg;
        // add to result
        SimpleCashFlow dummyCf(0.0, payDate);
        if (!dummyCf.hasOccurred(d) || (alwaysAddIfPaysOnSettlement && dummyCf.date() == d)) {
            auto fixingDates =
                needsForecast(fixingDate, d, indexInterpolated, indexFrequency, indexAvailabilityLag, f.mandatory);
            if (!fixingDates.empty())
                result[indexName].addDates(fixingDates);
            // Add the previous year's date(s) also if any.
            for (const auto& [d, mandatory] : fixingDates) {
                Date previousYear = d - 1 * Years;
                result[indexName].addDate(previousYear, mandatory);
            }
        }
    }
 
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

addFixingDate() [1/2]

void addFixingDate	(	const QuantLib::Date &	fixingDate,
		const std::string &	indexName,
		const QuantLib::Date &	payDate = Date::maxDate(),
		const bool	alwaysAddIfPaysOnSettlement = false,
		const bool	mandatoryFixing = true
	)

Adds a single fixing date fixingDate for an index given by its ORE index name indexName arising from a coupon with payment date payDate. If alwaysAddIfPaysOnSettlement is true the fixing date will be added if the coupon pays on the settlement date even if the cashflow returns hasOccured(settlementDate) as true. This is conservative and necessary in some cases since some pricing engines in QL (e.g. CapFloor) do not respect hasOccured() and ask for the fixing regardless. If the payDate is not given, it defaults to Date::maxDate() meaning that the added fixing is relevant unconditional on a pay date

Definition at line 364 of file fixingdates.cpp.

                                                          {
    fixingDates_.insert(
        {indexName, fixingDate, payDate, payDate == Date::maxDate() || alwaysAddIfPaysOnSettlement, mandatory});
}

Here is the call graph for this function:

Here is the caller graph for this function:

addFixingDate() [2/2]

void addFixingDate

(

const FixingEntry &

fixingEntry

)

Definition at line 371 of file fixingdates.cpp.

{ fixingDates_.insert(fixingEntry); }

addFixingDates() [1/2]

void addFixingDates	(	const std::vector< std::pair< QuantLib::Date, bool > > &	fixingDates,
		const std::string &	indexName,
		const QuantLib::Date &	payDate = Date::maxDate(),
		const bool	alwaysAddIfPaysOnSettlement = false
	)

adds a vector of fixings dates fixingDates and mandatory flags for an index given by is ORE index name indexName arising from a coupon with payment date payDate

Definition at line 373 of file fixingdates.cpp.

                                                                             {
    for (auto const& [date, mandatory] : fixingDates) {
        fixingDates_.insert({indexName, date, payDate, alwaysAddIfPaysOnSettlement, mandatory});
    }
}

Here is the caller graph for this function:

addFixingDates() [2/2]

void addFixingDates	(	const std::vector< QuantLib::Date > &	fixingDates,
		const std::string &	indexName,
		const QuantLib::Date &	payDate = Date::maxDate(),
		const bool	alwaysAddIfPaysOnSettlement = false,
		const bool	mandatory = true
	)

adds a vector of fixings dates fixingDates for an index given by is ORE index name indexName arising from a coupon with payment date payDate

Definition at line 381 of file fixingdates.cpp.

                                                           {
    for (auto const& date : fixingDates) {
        fixingDates_.insert({indexName, date, payDate, alwaysAddIfPaysOnSettlement, mandatory});
    }
}

addZeroInflationFixingDate() [1/2]

void addZeroInflationFixingDate	(	const QuantLib::Date &	fixingDate,
		const std::string &	indexName,
		const bool	indexInterpolated,
		const Frequency	indexFrequency,
		const Period &	indexAvailabilityLag,
		const CPI::InterpolationType	coupopnInterpolation,
		const Frequency	couponFrequency,
		const QuantLib::Date &	payDate = Date::maxDate(),
		const bool	alwaysAddIfPaysOnSettlement = false,
		const bool	mandatoryFixing = true
	)

add a single fixing date fixingDate for a coupon based on a zero inflation index given by its ORE index name indexName with payment date payDate

Definition at line 389 of file fixingdates.cpp.

                                                                                                               {
    ZeroInflationFixingEntry entry;
    entry.indexName = indexName;
    entry.fixingDate = fixingDate;
    entry.payDate = payDate;
    entry.alwaysAddIfPaysOnSettlement = alwaysAddIfPaysOnSettlement;
    entry.mandatory = mandatory;
    entry.indexInterpolated = indexInterpolated;
    entry.indexFreq = indexFrequency;
    entry.availabilityLeg = indexAvailabilityLag;
    entry.couponFrequency = couponFrequency;
    entry.couponInterpolation = couponInterpolation;
    addZeroInflationFixingDate(entry);
}

Here is the call graph for this function:

Here is the caller graph for this function:

addZeroInflationFixingDate() [2/2]

void addZeroInflationFixingDate

(

const ZeroInflationFixingEntry &

fixingEntry

)

Definition at line 409 of file fixingdates.cpp.

                                                                                            {
    zeroInflationFixingDates_.insert(fixingEntry);
}

addYoYInflationFixingDate() [1/2]

void addYoYInflationFixingDate	(	const QuantLib::Date &	fixingDate,
		const std::string &	indexName,
		const bool	indexInterpolated,
		const Frequency	indexFrequency,
		const Period &	indexAvailabilityLag,
		const QuantLib::Date &	payDate = Date::maxDate(),
		const bool	alwaysAddIfPaysOnSettlement = false,
		const bool	mandatoryFixing = true
	)

add a single fixing date fixingDate for a coupon based on a yoy inflation index given by its ORE index name indexName with payment date payDate

Definition at line 413 of file fixingdates.cpp.

                                                                                                              {
    InflationFixingEntry entry;
    entry.indexName = indexName;
    entry.fixingDate = fixingDate;
    entry.payDate = payDate;
    entry.alwaysAddIfPaysOnSettlement = alwaysAddIfPaysOnSettlement;
    entry.mandatory = mandatory;
    entry.indexInterpolated = indexInterpolated;
    entry.indexFreq = indexFrequency;
    entry.availabilityLeg = indexAvailabilityLag;
    addYoYInflationFixingDate(entry);
}

Here is the call graph for this function:

Here is the caller graph for this function:

addYoYInflationFixingDate() [2/2]

void addYoYInflationFixingDate

(

const InflationFixingEntry &

fixingEntry

)

Definition at line 429 of file fixingdates.cpp.

                                                                                       {
    yoyInflationFixingDates_.insert(fixingEntry);
}

clear()

void clear

(

)

clear all data

Definition at line 172 of file fixingdates.cpp.

                            {
    fixingDates_.clear();
    zeroInflationFixingDates_.clear();
    yoyInflationFixingDates_.clear();
}

Here is the caller graph for this function:

addData()

void addData

(

const RequiredFixings &

requiredFixings

)

add data from another RequiredFixings instance

Definition at line 178 of file fixingdates.cpp.

                                                                    {
    fixingDates_.insert(requiredFixings.fixingDates_.begin(), requiredFixings.fixingDates_.end());
    zeroInflationFixingDates_.insert(requiredFixings.zeroInflationFixingDates_.begin(),
                                     requiredFixings.zeroInflationFixingDates_.end());
    yoyInflationFixingDates_.insert(requiredFixings.yoyInflationFixingDates_.begin(),
                                    requiredFixings.yoyInflationFixingDates_.end());
}

Here is the caller graph for this function:

unsetPayDates()

void unsetPayDates

(

)

Set all pay dates to Date::maxDate(), fixingDatesIndices() will then not filter the required fixings by the given settlement date any more. Needed by total return swaps on bonds for example, where a cashflow in a bond with past payment date can still be relevant for the payment of the current return period.

Definition at line 186 of file fixingdates.cpp.

                                    {
    // we can't modify the elements of a set directly, need to make a copy and reassign
    std::set<FixingEntry> newFixingDates;
    std::set<ZeroInflationFixingEntry> newZeroInflationFixingDates;
    std::set<InflationFixingEntry> newYoYInflationFixingDates;
    for (auto f : fixingDates_) {
        f.payDate = Date::maxDate();
        f.alwaysAddIfPaysOnSettlement = true;
        newFixingDates.insert(f);
    }
    for (auto f : zeroInflationFixingDates_) {
        f.payDate = Date::maxDate();
        f.alwaysAddIfPaysOnSettlement = true;
        newZeroInflationFixingDates.insert(f);
    }
    for (auto f : yoyInflationFixingDates_) {
        f.payDate = Date::maxDate();
        f.alwaysAddIfPaysOnSettlement = true;
        newYoYInflationFixingDates.insert(f);
    }
    fixingDates_ = newFixingDates;
    zeroInflationFixingDates_ = newZeroInflationFixingDates;
    yoyInflationFixingDates_ = newYoYInflationFixingDates;
}

Here is the caller graph for this function:

makeCopyWithMandatoryOverride()

RequiredFixings makeCopyWithMandatoryOverride

(

bool

mandatory

)

Create a copy and set mandatory flag to mandatory for all fixing entries

Definition at line 211 of file fixingdates.cpp.

                                                                             {
    RequiredFixings result(*this);
    // we can't modify the elements of a set directly, need to make a copy and reassign
    std::set<FixingEntry> newFixingDates;
    std::set<ZeroInflationFixingEntry> newZeroInflationFixingDates;
    std::set<InflationFixingEntry> newYoYInflationFixingDates;
    for (auto f : result.fixingDates_) {
        f.mandatory = mandatory;
        newFixingDates.insert(f);
    }
    for (auto f : result.zeroInflationFixingDates_) {
        f.mandatory = mandatory;
        newZeroInflationFixingDates.insert(f);
    }
    for (auto f : yoyInflationFixingDates_) {
        f.mandatory = mandatory;
        newYoYInflationFixingDates.insert(f);
    }
    result.fixingDates_ = newFixingDates;
    result.zeroInflationFixingDates_ = newZeroInflationFixingDates;
    result.yoyInflationFixingDates_ = newYoYInflationFixingDates;
    return result;
}

Here is the caller graph for this function:

filteredFixingDates()

RequiredFixings filteredFixingDates

(

const QuantLib::Date &

settlementDate = QuantLib::Date()

)

Definition at line 235 of file fixingdates.cpp.

                                                                               {
    RequiredFixings rf;
    // If settlement date is an empty date, update to evaluation date.
    Date d = settlementDate == Date() ? Settings::instance().evaluationDate() : settlementDate;
    // handle the general case
    for (auto f : fixingDates_) {
        // get the data
        std::string indexName = f.indexName;
        Date fixingDate = f.fixingDate;
        Date payDate = f.payDate;
        bool alwaysAddIfPaysOnSettlement = f.alwaysAddIfPaysOnSettlement;
        // add to result
        if (fixingDate > d)
            continue;
        SimpleCashFlow dummyCf(0.0, payDate);
        if (!dummyCf.hasOccurred(d) || (alwaysAddIfPaysOnSettlement && dummyCf.date() == d)) {
            f.payDate = Date::maxDate();
            f.alwaysAddIfPaysOnSettlement = true;
            rf.addFixingDate(f);
        }
    }
 
    // handle zero inflation index based coupons
    for (auto f : zeroInflationFixingDates_) {
        // get the data
        std::string indexName = f.indexName;
        Date payDate = f.payDate;
        bool alwaysAddIfPaysOnSettlement = f.alwaysAddIfPaysOnSettlement;
        // add to result
        SimpleCashFlow dummyCf(0.0, payDate);
        if (!dummyCf.hasOccurred(d) || (alwaysAddIfPaysOnSettlement && dummyCf.date() == d)) {
            f.payDate = Date::maxDate();
            f.alwaysAddIfPaysOnSettlement = true;
            rf.addZeroInflationFixingDate(f);
        }
    }
 
    // handle yoy inflation index based coupons
    for (auto f : yoyInflationFixingDates_) {
        // get the data
        std::string indexName = f.indexName;
        Date payDate = f.payDate;
        bool alwaysAddIfPaysOnSettlement = f.alwaysAddIfPaysOnSettlement;
        // add to result
        SimpleCashFlow dummyCf(0.0, payDate);
        if (!dummyCf.hasOccurred(d) || (alwaysAddIfPaysOnSettlement && dummyCf.date() == d)) {
            f.payDate = Date::maxDate();
            f.alwaysAddIfPaysOnSettlement = true;
            rf.addYoYInflationFixingDate(f);
        }
    }
    return rf;
}

Here is the call graph for this function:

Friends And Related Function Documentation

operator<<

std::ostream & operator<< ( std::ostream &  , const RequiredFixings &    )

friend

allow output of required fixings data via streams

Definition at line 467 of file fixingdates.cpp.

                                                                                {
    out << "IndexName FixingDate PayDate AlwaysAddIfPaysOnSettlement\n";
    out << requiredFixings.fixingDates_;
    out << requiredFixings.zeroInflationFixingDates_;
    out << requiredFixings.yoyInflationFixingDates_;
    return out;
}

Member Data Documentation

fixingDates_

std::set<FixingEntry> fixingDates_

private

Definition at line 241 of file fixingdates.hpp.

zeroInflationFixingDates_

std::set<ZeroInflationFixingEntry> zeroInflationFixingDates_

private

Definition at line 243 of file fixingdates.hpp.

yoyInflationFixingDates_

std::set<InflationFixingEntry> yoyInflationFixingDates_

private

Definition at line 245 of file fixingdates.hpp.