Cross currency basis MtM resettable swap. More...

#include <qle/instruments/crossccybasismtmresetswap.hpp>

Inheritance diagram for CrossCcyBasisMtMResetSwap:

Collaboration diagram for CrossCcyBasisMtMResetSwap:

Classes
class	arguments

class	results

Public Member Functions
Constructors
	CrossCcyBasisMtMResetSwap (Real foreignNominal, const Currency &foreignCurrency, const Schedule &foreignSchedule, const QuantLib::ext::shared_ptr< IborIndex > &foreignIndex, Spread foreignSpread, const Currency &domesticCurrency, const Schedule &domesticSchedule, const QuantLib::ext::shared_ptr< IborIndex > &domesticIndex, Spread domesticSpread, const QuantLib::ext::shared_ptr< FxIndex > &fxIdx, bool receiveDomestic=true, Size foreignPaymentLag=0, Size recPaymentLag=0, boost::optional< bool > foreignIncludeSpread=boost::none, boost::optional< Period > foreignLookback=boost::none, boost::optional< Size > foreignFixingDays=boost::none, boost::optional< Size > foreignRateCutoff=boost::none, boost::optional< bool > foreignIsAveraged=boost::none, boost::optional< bool > domesticIncludeSpread=boost::none, boost::optional< Period > domesticLookback=boost::none, boost::optional< Size > domesticFixingDays=boost::none, boost::optional< Size > domesticRateCutoff=boost::none, boost::optional< bool > domesticIsAveraged=boost::none, const bool telescopicValueDates=false, bool fairSpreadLegIsForeign=true)

Inspectors
Real	foreignNominal () const

const Currency &	foreignCurrency () const

const Schedule &	foreignSchedule () const

const QuantLib::ext::shared_ptr< IborIndex > &	foreignIndex () const

Spread	foreignSpread () const

const Currency &	domesticCurrency () const

const Schedule &	domesticSchedule () const

const QuantLib::ext::shared_ptr< IborIndex > &	domesticIndex () const

Spread	domesticSpread () const

Additional interface
Spread	fairForeignSpread () const

Spread	fairDomesticSpread () const

Spread	fairSpread () const

Public Member Functions inherited from CrossCcySwap
const Currency &	legCurrency (Size j) const

Real	inCcyLegBPS (Size j) const

Real	inCcyLegNPV (Size j) const

DiscountFactor	npvDateDiscounts (Size j) const

void	setupArguments (PricingEngine::arguments *args) const override

void	fetchResults (const PricingEngine::results *) const override

	CrossCcySwap (const Leg &firstLeg, const Currency &firstLegCcy, const Leg &secondLeg, const Currency &secondLegCcy)
	First leg is paid and the second is received. More...

	CrossCcySwap (const std::vector< Leg > &legs, const std::vector< bool > &payer, const std::vector< Currency > &currencies)

Instrument interface
Real	foreignNominal_

Currency	foreignCurrency_

Schedule	foreignSchedule_

QuantLib::ext::shared_ptr< IborIndex >	foreignIndex_

Spread	foreignSpread_

Currency	domesticCurrency_

Schedule	domesticSchedule_

QuantLib::ext::shared_ptr< IborIndex >	domesticIndex_

Spread	domesticSpread_

QuantLib::ext::shared_ptr< FxIndex >	fxIndex_

bool	receiveDomestic_

Size	foreignPaymentLag_

Size	domesticPaymentLag_

boost::optional< bool >	foreignIncludeSpread_

boost::optional< QuantLib::Period >	foreignLookback_

boost::optional< QuantLib::Size >	foreignFixingDays_

boost::optional< Size >	foreignRateCutoff_

boost::optional< bool >	foreignIsAveraged_

boost::optional< bool >	domesticIncludeSpread_

boost::optional< QuantLib::Period >	domesticLookback_

boost::optional< QuantLib::Size >	domesticFixingDays_

boost::optional< Size >	domesticRateCutoff_

boost::optional< bool >	domesticIsAveraged_

bool	telescopicValueDates_

bool	fairSpreadLegIsForeign_

Spread	fairForeignSpread_

Spread	fairDomesticSpread_

void	setupArguments (PricingEngine::arguments *args) const override

void	fetchResults (const PricingEngine::results *) const override

void	setupExpired () const override

void	initialize ()

Additional Inherited Members
Protected Member Functions inherited from CrossCcySwap
void	setupExpired () const override

	CrossCcySwap (Size legs)

Protected Attributes inherited from CrossCcySwap
std::vector< Currency >	currencies_

Detailed Description

Cross currency basis MtM resettable swap.

The foreign leg holds the pay currency cashflows and domestic leg holds the receive currency cashflows. The notional resets are applied to the domestic leg.

    \ingroup instruments

Definition at line 42 of file crossccybasismtmresetswap.hpp.

Constructor & Destructor Documentation

◆ CrossCcyBasisMtMResetSwap()

CrossCcyBasisMtMResetSwap	(	Real	foreignNominal,
		const Currency &	foreignCurrency,
		const Schedule &	foreignSchedule,
		const QuantLib::ext::shared_ptr< IborIndex > &	foreignIndex,
		Spread	foreignSpread,
		const Currency &	domesticCurrency,
		const Schedule &	domesticSchedule,
		const QuantLib::ext::shared_ptr< IborIndex > &	domesticIndex,
		Spread	domesticSpread,
		const QuantLib::ext::shared_ptr< FxIndex > &	fxIdx,
		bool	receiveDomestic = `true`,
		Size	foreignPaymentLag = `0`,
		Size	recPaymentLag = `0`,
		boost::optional< bool >	foreignIncludeSpread = `boost::none`,
		boost::optional< Period >	foreignLookback = `boost::none`,
		boost::optional< Size >	foreignFixingDays = `boost::none`,
		boost::optional< Size >	foreignRateCutoff = `boost::none`,
		boost::optional< bool >	foreignIsAveraged = `boost::none`,
		boost::optional< bool >	domesticIncludeSpread = `boost::none`,
		boost::optional< Period >	domesticLookback = `boost::none`,
		boost::optional< Size >	domesticFixingDays = `boost::none`,
		boost::optional< Size >	domesticRateCutoff = `boost::none`,
		boost::optional< bool >	domesticIsAveraged = `boost::none`,
		const bool	telescopicValueDates = `false`,
		bool	fairSpreadLegIsForeign = `true`
	)

First leg holds the pay currency cashflows and the second leg holds the receive currency cashflows.

Definition at line 32 of file crossccybasismtmresetswap.cpp.

    : CrossCcySwap(3), foreignNominal_(foreignNominal), foreignCurrency_(foreignCurrency),
      foreignSchedule_(foreignSchedule), foreignIndex_(foreignIndex), foreignSpread_(foreignSpread),
      domesticCurrency_(domesticCurrency), domesticSchedule_(domesticSchedule), domesticIndex_(domesticIndex),
      domesticSpread_(domesticSpread), fxIndex_(fxIdx), receiveDomestic_(receiveDomestic),
      foreignPaymentLag_(foreignPaymentLag), domesticPaymentLag_(domesticPaymentLag),
      foreignIncludeSpread_(foreignIncludeSpread), foreignLookback_(foreignLookback),
      foreignFixingDays_(foreignFixingDays), foreignRateCutoff_(foreignRateCutoff),
      foreignIsAveraged_(foreignIsAveraged), domesticIncludeSpread_(domesticIncludeSpread),
      domesticLookback_(domesticLookback), domesticFixingDays_(domesticFixingDays),
      domesticRateCutoff_(domesticRateCutoff), domesticIsAveraged_(domesticIsAveraged),
      telescopicValueDates_(telescopicValueDates), fairSpreadLegIsForeign_(fairSpreadLegIsForeign) {
    registerWith(foreignIndex_);
    registerWith(domesticIndex_);
    registerWith(fxIndex_);
    initialize();
}

Here is the call graph for this function:

Member Function Documentation

◆ setupArguments()

void setupArguments ( PricingEngine::arguments * args ) const

override

Definition at line 171 of file crossccybasismtmresetswap.cpp.

                                                                                 {
 
    CrossCcySwap::setupArguments(args);
 
    CrossCcyBasisMtMResetSwap::arguments* arguments = dynamic_cast<CrossCcyBasisMtMResetSwap::arguments*>(args);
 
    /* Returns here if e.g. args is CrossCcySwap::arguments which
       is the case if PricingEngine is a CrossCcySwap::engine. */
    if (!arguments)
        return;
 
    arguments->domesticSpread = domesticSpread_;
    arguments->foreignSpread = foreignSpread_;
}

Here is the call graph for this function:

◆ fetchResults()

void fetchResults ( const PricingEngine::results * r ) const

override

Definition at line 186 of file crossccybasismtmresetswap.cpp.

                                                                                {
 
    CrossCcySwap::fetchResults(r);
 
    const CrossCcyBasisMtMResetSwap::results* results = dynamic_cast<const CrossCcyBasisMtMResetSwap::results*>(r);
    if (results) {
        /* If PricingEngine::results are of type
           CrossCcyBasisSwap::results */
        fairForeignSpread_ = results->fairForeignSpread;
        fairDomesticSpread_ = results->fairDomesticSpread;
    } else {
        /* If not, e.g. if the engine is a CrossCcySwap::engine */
        fairForeignSpread_ = Null<Spread>();
        fairDomesticSpread_ = Null<Spread>();
    }
 
    /* Calculate the fair pay and receive spreads if they are null */
    static Spread basisPoint = 1.0e-4;
    if (fairForeignSpread_ == Null<Spread>()) {
        if (legBPS_[0] != Null<Real>())
            fairForeignSpread_ = foreignSpread_ - NPV_ / (legBPS_[0] / basisPoint);
    }
    if (fairDomesticSpread_ == Null<Spread>()) {
        if (legBPS_[1] != Null<Real>())
            fairDomesticSpread_ = domesticSpread_ - NPV_ / (legBPS_[1] / basisPoint);
    }
}

Here is the call graph for this function:

◆ foreignNominal()

Real foreignNominal ( ) const

Definition at line 72 of file crossccybasismtmresetswap.hpp.

72{ return foreignNominal_; }

◆ foreignCurrency()

const Currency & foreignCurrency ( ) const

Definition at line 73 of file crossccybasismtmresetswap.hpp.

73{ return foreignCurrency_; }

◆ foreignSchedule()

const Schedule & foreignSchedule ( ) const

Definition at line 74 of file crossccybasismtmresetswap.hpp.

74{ return foreignSchedule_; }

◆ foreignIndex()

const QuantLib::ext::shared_ptr< IborIndex > & foreignIndex ( ) const

Definition at line 75 of file crossccybasismtmresetswap.hpp.

75{ return foreignIndex_; }

◆ foreignSpread()

Spread foreignSpread ( ) const

Definition at line 76 of file crossccybasismtmresetswap.hpp.

76{ return foreignSpread_; }

◆ domesticCurrency()

const Currency & domesticCurrency ( ) const

Definition at line 78 of file crossccybasismtmresetswap.hpp.

78{ return domesticCurrency_; }

◆ domesticSchedule()

const Schedule & domesticSchedule ( ) const

Definition at line 79 of file crossccybasismtmresetswap.hpp.

79{ return domesticSchedule_; }

◆ domesticIndex()

const QuantLib::ext::shared_ptr< IborIndex > & domesticIndex ( ) const

Definition at line 80 of file crossccybasismtmresetswap.hpp.

80{ return domesticIndex_; }

◆ domesticSpread()

Spread domesticSpread ( ) const

Definition at line 81 of file crossccybasismtmresetswap.hpp.

81{ return domesticSpread_; }

◆ fairForeignSpread()

Spread fairForeignSpread ( ) const

Definition at line 86 of file crossccybasismtmresetswap.hpp.

                                     {
        calculate();
        QL_REQUIRE(fairForeignSpread_ != Null<Real>(), "Fair foreign spread is not available");
        return fairForeignSpread_;
    }

Here is the caller graph for this function:

◆ fairDomesticSpread()

Spread fairDomesticSpread ( ) const

Definition at line 91 of file crossccybasismtmresetswap.hpp.

                                      {
        calculate();
        QL_REQUIRE(fairDomesticSpread_ != Null<Real>(), "Fair domestic spread is not available");
        return fairDomesticSpread_;
    }

Here is the caller graph for this function:

◆ fairSpread()

Spread fairSpread ( ) const

Definition at line 96 of file crossccybasismtmresetswap.hpp.

                              {
        if (fairSpreadLegIsForeign_)
        return fairForeignSpread();
    else
        return fairDomesticSpread();
    }

Here is the call graph for this function:

◆ setupExpired()

void setupExpired ( ) const

overrideprotected

Definition at line 214 of file crossccybasismtmresetswap.cpp.

                                                   {
    CrossCcySwap::setupExpired();
    fairForeignSpread_ = Null<Spread>();
    fairDomesticSpread_ = Null<Spread>();
}

Here is the call graph for this function:

◆ initialize()

void initialize ( )

private

Definition at line 60 of file crossccybasismtmresetswap.cpp.

                                           {
    // Pay (foreign) leg
    if (auto on = QuantLib::ext::dynamic_pointer_cast<QuantLib::OvernightIndex>(foreignIndex_)) {
        // ON leg
        if (foreignIsAveraged_ && *foreignIsAveraged_) {
            legs_[0] = QuantExt::AverageONLeg(foreignSchedule_, on)
                           .withNotional(foreignNominal_)
                           .withSpread(foreignSpread_)
                           .withPaymentLag(foreignPaymentLag_)
                           .withLookback(foreignLookback_ ? *foreignLookback_ : 0 * Days)
                           .withFixingDays(foreignFixingDays_ ? *foreignFixingDays_ : 0)
                           .withRateCutoff(foreignRateCutoff_ ? *foreignRateCutoff_ : 0)
                           .withTelescopicValueDates(telescopicValueDates_);
        } else {
            legs_[0] = QuantExt::OvernightLeg(foreignSchedule_, on)
                           .withNotionals(foreignNominal_)
                           .withSpreads(foreignSpread_)
                           .withPaymentLag(foreignPaymentLag_)
                           .includeSpread(foreignIncludeSpread_ ? *foreignIncludeSpread_ : false)
                           .withLookback(foreignLookback_ ? *foreignLookback_ : 0 * Days)
                           .withFixingDays(foreignFixingDays_ ? *foreignFixingDays_ : 0)
                           .withRateCutoff(foreignRateCutoff_ ? *foreignRateCutoff_ : 0)
                           .withTelescopicValueDates(telescopicValueDates_);
        }
    } else {
        // Ibor leg
        legs_[0] = IborLeg(foreignSchedule_, foreignIndex_)
                       .withNotionals(foreignNominal_)
                       .withSpreads(foreignSpread_)
                       .withPaymentLag(foreignPaymentLag_);
    }
    receiveDomestic_ ? payer_[0] = -1.0 : payer_[0] = +1.0;
 
    currencies_[0] = foreignCurrency_;
    // Pay leg notional exchange at start.
    Date initialPayDate = foreignSchedule_.dates().front();
    QuantLib::ext::shared_ptr<CashFlow> initialPayCF(new SimpleCashFlow(-foreignNominal_, initialPayDate));
    legs_[0].insert(legs_[0].begin(), initialPayCF);
    // Pay leg notional exchange at end.
    Date finalPayDate = foreignSchedule_.dates().back();
    QuantLib::ext::shared_ptr<CashFlow> finalPayCF(new SimpleCashFlow(foreignNominal_, finalPayDate));
    legs_[0].push_back(finalPayCF);
 
    // Receive (domestic/resettable) leg
    // start by creating a dummy vanilla floating leg
    if (auto on = QuantLib::ext::dynamic_pointer_cast<QuantLib::OvernightIndex>(domesticIndex_)) {
        // ON leg
        if (domesticIsAveraged_ && *domesticIsAveraged_) {
            legs_[1] = QuantExt::AverageONLeg(domesticSchedule_, on)
                           .withNotional(0.0)
                           .withSpread(domesticSpread_)
                           .withPaymentLag(domesticPaymentLag_)
                           .withLookback(domesticLookback_ ? *domesticLookback_ : 0 * Days)
                           .withFixingDays(domesticFixingDays_ ? *domesticFixingDays_ : 0)
                           .withRateCutoff(domesticRateCutoff_ ? *domesticRateCutoff_ : 0)
                           .withTelescopicValueDates(telescopicValueDates_);
        } else {
            legs_[1] = QuantExt::OvernightLeg(domesticSchedule_, on)
                           .withNotionals(0.0)
                           .withSpreads(domesticSpread_)
                           .withPaymentLag(domesticPaymentLag_)
                           .includeSpread(domesticIncludeSpread_ ? *domesticIncludeSpread_ : false)
                           .withLookback(domesticLookback_ ? *domesticLookback_ : 0 * Days)
                           .withFixingDays(domesticFixingDays_ ? *domesticFixingDays_ : 0)
                           .withRateCutoff(domesticRateCutoff_ ? *domesticRateCutoff_ : 0)
                           .withTelescopicValueDates(telescopicValueDates_);
        }
    } else {
        // Ibor leg
        legs_[1] = IborLeg(domesticSchedule_, domesticIndex_)
                       .withNotionals(0.0)
                       .withSpreads(domesticSpread_)
                       .withPaymentLag(domesticPaymentLag_);
    }
    receiveDomestic_ ? payer_[1] = +1.0 : payer_[1] = -1.0;
    currencies_[1] = domesticCurrency_;
    // replace the coupons with a FloatingRateFXLinkedNotionalCoupon
    // (skip the first coupon as it has a fixed notional)
    for (Size j = 0; j < legs_[1].size(); ++j) {
        QuantLib::ext::shared_ptr<FloatingRateCoupon> coupon = QuantLib::ext::dynamic_pointer_cast<FloatingRateCoupon>(legs_[1][j]);
        Date fixingDate = fxIndex_->fixingCalendar().advance(coupon->accrualStartDate(),
                                                             -static_cast<Integer>(fxIndex_->fixingDays()), Days);
        QuantLib::ext::shared_ptr<FloatingRateFXLinkedNotionalCoupon> fxLinkedCoupon(
            new FloatingRateFXLinkedNotionalCoupon(fixingDate, foreignNominal_, fxIndex_, coupon));
        legs_[1][j] = fxLinkedCoupon;
    }
    // now build a separate leg to store the domestic (resetting) notionals
    receiveDomestic_ ? payer_[2] = +1.0 : payer_[2] = -1.0;
    currencies_[2] = domesticCurrency_;
    for (Size j = 0; j < legs_[1].size(); j++) {
        QuantLib::ext::shared_ptr<Coupon> c = QuantLib::ext::dynamic_pointer_cast<Coupon>(legs_[1][j]);
        QL_REQUIRE(c, "Resetting XCCY - expected Coupon"); // TODO: fixed fx resettable?
        // build a pair of notional flows, one at the start and one at the end of
        // the accrual period. Both with the same FX fixing date
        Date fixingDate = fxIndex_->fixingCalendar().advance(c->accrualStartDate(),
                                                             -static_cast<Integer>(fxIndex_->fixingDays()), Days);
        legs_[2].push_back(QuantLib::ext::shared_ptr<CashFlow>(
            new FXLinkedCashFlow(c->accrualStartDate(), fixingDate, -foreignNominal_, fxIndex_)));
        legs_[2].push_back(QuantLib::ext::shared_ptr<CashFlow>(
            new FXLinkedCashFlow(c->accrualEndDate(), fixingDate, foreignNominal_, fxIndex_)));
    }
 
    // Register the instrument with all cashflows on each leg.
    for (Size legNo = 0; legNo < legs_.size(); legNo++) {
        Leg::iterator it;
        for (it = legs_[legNo].begin(); it != legs_[legNo].end(); ++it) {
            registerWith(*it);
        }
    }
}