Cross Ccy Basis Swap Rate Helper. More...

#include <qle/termstructures/crossccybasisswaphelper.hpp>

Inheritance diagram for CrossCcyBasisSwapHelper:

Collaboration diagram for CrossCcyBasisSwapHelper:

Public Member Functions
	CrossCcyBasisSwapHelper (const Handle< Quote > &spreadQuote, const Handle< Quote > &spotFX, Natural settlementDays, const Calendar &settlementCalendar, const Period &swapTenor, BusinessDayConvention rollConvention, const QuantLib::ext::shared_ptr< QuantLib::IborIndex > &flatIndex, const QuantLib::ext::shared_ptr< QuantLib::IborIndex > &spreadIndex, const Handle< YieldTermStructure > &flatDiscountCurve, const Handle< YieldTermStructure > &spreadDiscountCurve, bool eom=false, bool flatIsDomestic=true, boost::optional< QuantLib::Period > flatTenor=boost::none, boost::optional< QuantLib::Period > spreadTenor=boost::none, Real spreadOnFlatLeg=0.0, Real flatGearing=1.0, Real spreadGearing=1.0, const Calendar &flatCalendar=Calendar(), const Calendar &spreadCalendar=Calendar(), const std::vector< Natural > &spotFXSettleDaysVec=std::vector< Natural >(), const std::vector< Calendar > &spotFXSettleCalendar=std::vector< Calendar >(), Size paymentLag=0, Size flatPaymentLag=0, boost::optional< bool > includeSpread=boost::none, boost::optional< Period > lookback=boost::none, boost::optional< Size > fixingDays=boost::none, boost::optional< Size > rateCutoff=boost::none, boost::optional< bool > isAveraged=boost::none, boost::optional< bool > flatIncludeSpread=boost::none, boost::optional< Period > flatLookback=boost::none, boost::optional< Size > flatFixingDays=boost::none, boost::optional< Size > flatRateCutoff=boost::none, boost::optional< bool > flatIsAveraged=boost::none, const bool telescopicValueDates=false)

RateHelper interface
Real	impliedQuote () const override

void	setTermStructure (YieldTermStructure *) override

inspectors
QuantLib::ext::shared_ptr< CrossCcyBasisSwap >	swap () const

Visitability
Handle< Quote >	spotFX_

Natural	settlementDays_

Calendar	settlementCalendar_

Period	swapTenor_

BusinessDayConvention	rollConvention_

QuantLib::ext::shared_ptr< QuantLib::IborIndex >	flatIndex_

QuantLib::ext::shared_ptr< QuantLib::IborIndex >	spreadIndex_

Handle< YieldTermStructure >	flatDiscountCurve_

Handle< YieldTermStructure >	spreadDiscountCurve_

bool	eom_

bool	flatIsDomestic_

QuantLib::Period	flatTenor_

QuantLib::Period	spreadTenor_

Real	spreadOnFlatLeg_

Real	flatGearing_

Real	spreadGearing_

Calendar	flatCalendar_

Calendar	spreadCalendar_

std::vector< Natural >	spotFXSettleDaysVec_

std::vector< Calendar >	spotFXSettleCalendarVec_

Size	paymentLag_

Size	flatPaymentLag_

boost::optional< bool >	includeSpread_

boost::optional< QuantLib::Period >	lookback_

boost::optional< QuantLib::Size >	fixingDays_

boost::optional< Size >	rateCutoff_

boost::optional< bool >	isAveraged_

boost::optional< bool >	flatIncludeSpread_

boost::optional< QuantLib::Period >	flatLookback_

boost::optional< QuantLib::Size >	flatFixingDays_

boost::optional< Size >	flatRateCutoff_

boost::optional< bool >	flatIsAveraged_

Currency	flatLegCurrency_

Currency	spreadLegCurrency_

QuantLib::ext::shared_ptr< CrossCcyBasisSwap >	swap_

RelinkableHandle< YieldTermStructure >	termStructureHandle_

RelinkableHandle< YieldTermStructure >	flatDiscountRLH_

RelinkableHandle< YieldTermStructure >	spreadDiscountRLH_

bool	telescopicValueDates_

void	accept (AcyclicVisitor &) override

void	initializeDates () override

Detailed Description

Cross Ccy Basis Swap Rate Helper.

Rate helper for bootstrapping over cross currency basis swap spreads

Assumes that you have, at a minimum, either:

flatIndex with attached YieldTermStructure and flatDiscountCurve
spreadIndex with attached YieldTermStructure and spreadDiscountCurve

The other leg is then solved for i.e. index curve (if no YieldTermStructure is attached to its index) or discount curve (if its Handle is empty) or both.

The currencies are deduced from the ibor indexes. The spotFx to be quoted with either of these currencies, this is determined by the flatIsDomestic flag. The settlement date of the spot is assumed to be equal to the settlement date of the swap itself.

    \ingroup termstructures

Definition at line 51 of file crossccybasisswaphelper.hpp.

Constructor & Destructor Documentation

◆ CrossCcyBasisSwapHelper()

CrossCcyBasisSwapHelper	(	const Handle< Quote > &	spreadQuote,
		const Handle< Quote > &	spotFX,
		Natural	settlementDays,
		const Calendar &	settlementCalendar,
		const Period &	swapTenor,
		BusinessDayConvention	rollConvention,
		const QuantLib::ext::shared_ptr< QuantLib::IborIndex > &	flatIndex,
		const QuantLib::ext::shared_ptr< QuantLib::IborIndex > &	spreadIndex,
		const Handle< YieldTermStructure > &	flatDiscountCurve,
		const Handle< YieldTermStructure > &	spreadDiscountCurve,
		bool	eom = `false`,
		bool	flatIsDomestic = `true`,
		boost::optional< QuantLib::Period >	flatTenor = `boost::none`,
		boost::optional< QuantLib::Period >	spreadTenor = `boost::none`,
		Real	spreadOnFlatLeg = `0.0`,
		Real	flatGearing = `1.0`,
		Real	spreadGearing = `1.0`,
		const Calendar &	flatCalendar = `Calendar()`,
		const Calendar &	spreadCalendar = `Calendar()`,
		const std::vector< Natural > &	spotFXSettleDaysVec = `std::vector<Natural>()`,
		const std::vector< Calendar > &	spotFXSettleCalendar = `std::vector<Calendar>()`,
		Size	paymentLag = `0`,
		Size	flatPaymentLag = `0`,
		boost::optional< bool >	includeSpread = `boost::none`,
		boost::optional< Period >	lookback = `boost::none`,
		boost::optional< Size >	fixingDays = `boost::none`,
		boost::optional< Size >	rateCutoff = `boost::none`,
		boost::optional< bool >	isAveraged = `boost::none`,
		boost::optional< bool >	flatIncludeSpread = `boost::none`,
		boost::optional< Period >	flatLookback = `boost::none`,
		boost::optional< Size >	flatFixingDays = `boost::none`,
		boost::optional< Size >	flatRateCutoff = `boost::none`,
		boost::optional< bool >	flatIsAveraged = `boost::none`,
		const bool	telescopicValueDates = `false`
	)

Definition at line 28 of file crossccybasisswaphelper.cpp.

    : RelativeDateRateHelper(spreadQuote), spotFX_(spotFX), settlementDays_(settlementDays),
      settlementCalendar_(settlementCalendar), swapTenor_(swapTenor), rollConvention_(rollConvention),
      flatIndex_(flatIndex), spreadIndex_(spreadIndex), flatDiscountCurve_(flatDiscountCurve),
      spreadDiscountCurve_(spreadDiscountCurve), eom_(eom), flatIsDomestic_(flatIsDomestic),
      flatTenor_(flatTenor ? *flatTenor : flatIndex_->tenor()),
      spreadTenor_(spreadTenor ? *spreadTenor : spreadIndex_->tenor()), spreadOnFlatLeg_(spreadOnFlatLeg),
      flatGearing_(flatGearing), spreadGearing_(spreadGearing), flatCalendar_(flatCalendar),
      spreadCalendar_(spreadCalendar), spotFXSettleDaysVec_(spotFXSettleDaysVec),
      spotFXSettleCalendarVec_(spotFXSettleCalendarVec), paymentLag_(paymentLag), flatPaymentLag_(flatPaymentLag),
      includeSpread_(includeSpread), lookback_(lookback), fixingDays_(fixingDays), rateCutoff_(rateCutoff),
      isAveraged_(isAveraged), flatIncludeSpread_(flatIncludeSpread), flatLookback_(flatLookback),
      flatFixingDays_(flatFixingDays), flatRateCutoff_(flatRateCutoff), flatIsAveraged_(flatIsAveraged),
      telescopicValueDates_(telescopicValueDates) {
 
    flatLegCurrency_ = flatIndex_->currency();
    spreadLegCurrency_ = spreadIndex_->currency();
 
    bool flatIndexHasCurve = !flatIndex_->forwardingTermStructure().empty();
    bool spreadIndexHasCurve = !spreadIndex_->forwardingTermStructure().empty();
    bool haveFlatDiscountCurve = !flatDiscountCurve_.empty();
    bool haveSpreadDiscountCurve = !spreadDiscountCurve_.empty();
 
    QL_REQUIRE(!(flatIndexHasCurve && spreadIndexHasCurve && haveFlatDiscountCurve && haveSpreadDiscountCurve),
               "Have all curves, "
               "nothing to solve for.");
 
    if (flatCalendar_.empty())
        flatCalendar_ = settlementCalendar;
    if (spreadCalendar_.empty())
        spreadCalendar_ = settlementCalendar;
 
    // check spotFXSettleDaysVec_ and spotFXSettleCalendarVec_
    Size numSpotFXSettleDays = spotFXSettleDaysVec_.size();
    QL_REQUIRE(numSpotFXSettleDays == spotFXSettleCalendarVec_.size(),
               "Array size of spot fx settlement days must equal that of spot fx settlement calendars");
    if (numSpotFXSettleDays == 0) {
        spotFXSettleDaysVec_.resize(1, 0);
        spotFXSettleCalendarVec_.resize(1, settlementCalendar);
    }
 
    /* Link the curve being bootstrapped to the index if the index has
       no projection curve */
    if (flatIndexHasCurve && haveFlatDiscountCurve) {
        if (!spreadIndexHasCurve) {
            spreadIndex_ = spreadIndex_->clone(termStructureHandle_);
            spreadIndex_->unregisterWith(termStructureHandle_);
        }
    } else if (spreadIndexHasCurve && haveSpreadDiscountCurve) {
        if (!flatIndexHasCurve) {
            flatIndex_ = flatIndex_->clone(termStructureHandle_);
            flatIndex_->unregisterWith(termStructureHandle_);
        }
    } else {
        QL_FAIL("Need one leg of the cross currency basis swap to "
                "have all of its curves.");
    }
 
    registerWith(spotFX_);
    registerWith(flatIndex_);
    registerWith(spreadIndex_);
    registerWith(flatDiscountCurve_);
    registerWith(spreadDiscountCurve_);
 
    initializeDates();
}

Here is the call graph for this function:

Member Function Documentation

◆ impliedQuote()

Real impliedQuote ( ) const

override

Definition at line 217 of file crossccybasisswaphelper.cpp.

                                                 {
    QL_REQUIRE(termStructure_, "Term structure needs to be set");
    swap_->deepUpdate();
    return swap_->fairPaySpread();
}

◆ setTermStructure()

void setTermStructure ( YieldTermStructure * t )

override

Definition at line 197 of file crossccybasisswaphelper.cpp.

                                                                    {
 
    bool observer = false;
    QuantLib::ext::shared_ptr<YieldTermStructure> temp(t, null_deleter());
 
    termStructureHandle_.linkTo(temp, observer);
 
    if (flatDiscountCurve_.empty())
        flatDiscountRLH_.linkTo(temp, observer);
    else
        flatDiscountRLH_.linkTo(*flatDiscountCurve_, observer);
 
    if (spreadDiscountCurve_.empty())
        spreadDiscountRLH_.linkTo(temp, observer);
    else
        spreadDiscountRLH_.linkTo(*spreadDiscountCurve_, observer);
 
    RelativeDateRateHelper::setTermStructure(t);
}

◆ swap()

QuantLib::ext::shared_ptr< CrossCcyBasisSwap > swap ( ) const

Definition at line 78 of file crossccybasisswaphelper.hpp.

78{ return swap_; }

◆ accept()

void accept ( AcyclicVisitor & v )

override

Definition at line 223 of file crossccybasisswaphelper.cpp.

                                                      {
    Visitor<CrossCcyBasisSwapHelper>* v1 = dynamic_cast<Visitor<CrossCcyBasisSwapHelper>*>(&v);
    if (v1)
        v1->visit(*this);
    else
        RateHelper::accept(v);
}

◆ initializeDates()

void initializeDates ( )

overrideprotected

Definition at line 107 of file crossccybasisswaphelper.cpp.

                                              {
 
    Date refDate = evaluationDate_;
    // if the evaluation date is not a business day
    // then move to the next business day
    refDate = settlementCalendar_.adjust(refDate);
 
    Date settlementDate = settlementCalendar_.advance(refDate, settlementDays_, Days);
    Date maturityDate = settlementDate + swapTenor_;
 
    // calc spotFXSettleDate
    Date spotFXSettleDate = refDate;
    Size numSpotFXSettleDays = spotFXSettleDaysVec_.size(); // guaranteed to be at least 1
    for (Size i = 0; i < numSpotFXSettleDays; i++) {
        // Guaranteed here that spotFXSettleDaysVec_ and spotFXSettleCalendarVec_ have the same size
        spotFXSettleDate = spotFXSettleCalendarVec_[i].advance(spotFXSettleDate, spotFXSettleDaysVec_[i], Days);
    }
 
    Schedule flatLegSchedule = MakeSchedule()
                                   .from(settlementDate)
                                   .to(maturityDate)
                                   .withTenor(flatTenor_)
                                   .withCalendar(flatCalendar_)
                                   .withConvention(rollConvention_)
                                   .endOfMonth(eom_);
 
    Schedule spreadLegSchedule = MakeSchedule()
                                     .from(settlementDate)
                                     .to(maturityDate)
                                     .withTenor(spreadTenor_)
                                     .withCalendar(spreadCalendar_)
                                     .withConvention(rollConvention_)
                                     .endOfMonth(eom_);
 
    Real flatLegNominal = 1.0;
    Real spreadLegNominal = 1.0;
    if (flatIsDomestic_) {
        flatLegNominal = spotFX_->value();
    } else {
        spreadLegNominal = spotFX_->value();
    }
 
    /* Arbitrarily set the spread leg as the pay leg */
    swap_ = QuantLib::ext::make_shared<CrossCcyBasisSwap>(
        spreadLegNominal, spreadLegCurrency_, spreadLegSchedule, spreadIndex_, 0.0, spreadGearing_, flatLegNominal,
        flatLegCurrency_, flatLegSchedule, flatIndex_, spreadOnFlatLeg_, flatGearing_, paymentLag_, flatPaymentLag_,
        includeSpread_, lookback_, fixingDays_, rateCutoff_, isAveraged_, flatIncludeSpread_, flatLookback_,
        flatFixingDays_, flatRateCutoff_, flatIsAveraged_, telescopicValueDates_);
 
    QuantLib::ext::shared_ptr<PricingEngine> engine;
    if (flatIsDomestic_) {
        engine = QuantLib::ext::make_shared<CrossCcySwapEngine>(flatLegCurrency_, flatDiscountRLH_, spreadLegCurrency_,
                                                        spreadDiscountRLH_, spotFX_, boost::none, Date(), Date(),
                                                        spotFXSettleDate);
    } else {
        engine = QuantLib::ext::make_shared<CrossCcySwapEngine>(spreadLegCurrency_, spreadDiscountRLH_, flatLegCurrency_,
                                                        flatDiscountRLH_, spotFX_, boost::none, Date(), Date(),
                                                        spotFXSettleDate);
    }
    swap_->setPricingEngine(engine);
 
    earliestDate_ = swap_->startDate();
    latestDate_ = swap_->maturityDate();
 
/* May need to adjust latestDate_ if you are projecting libor based
   on tenor length rather than from accrual date to accrual date. */
    if (!IborCoupon::Settings::instance().usingAtParCoupons()) {
        if (termStructureHandle_ == spreadIndex_->forwardingTermStructure()) {
            Size numCashflows = swap_->leg(0).size();
            if (numCashflows > 2) {
                QuantLib::ext::shared_ptr<FloatingRateCoupon> lastFloating =
                    QuantLib::ext::dynamic_pointer_cast<FloatingRateCoupon>(swap_->leg(0)[numCashflows - 2]);
                Date fixingValueDate = spreadIndex_->valueDate(lastFloating->fixingDate());
                Date endValueDate = spreadIndex_->maturityDate(fixingValueDate);
                latestDate_ = std::max(latestDate_, endValueDate);
            }
        }
        if (termStructureHandle_ == flatIndex_->forwardingTermStructure()) {
            Size numCashflows = swap_->leg(1).size();
            if (numCashflows > 2) {
                QuantLib::ext::shared_ptr<FloatingRateCoupon> lastFloating =
                    QuantLib::ext::dynamic_pointer_cast<FloatingRateCoupon>(swap_->leg(1)[numCashflows - 2]);
                Date fixingValueDate = flatIndex_->valueDate(lastFloating->fixingDate());
                Date endValueDate = flatIndex_->maturityDate(fixingValueDate);
                latestDate_ = std::max(latestDate_, endValueDate);
            }
        }
    }
}