Discounting currency swap engine providing analytical deltas and gammas. More...

#include <qle/pricingengines/discountingcurrencyswapenginedeltagamma.hpp>

Inheritance diagram for DiscountingCurrencySwapEngineDeltaGamma:

Collaboration diagram for DiscountingCurrencySwapEngineDeltaGamma:

Public Types
typedef std::map< Currency, Matrix, CurrencyComparator >	result_type_matrix

typedef std::map< Currency, std::vector< Real >, CurrencyComparator >	result_type_vector

typedef std::map< Currency, Real, CurrencyComparator >	result_type_scalar

Public Member Functions
	DiscountingCurrencySwapEngineDeltaGamma (const std::vector< Handle< YieldTermStructure > > &discountCurves, const std::vector< Handle< Quote > > &fxQuotes, const std::vector< Currency > &currencies, const Currency &npvCurrency, const std::vector< Time > &bucketTimes=std::vector< Time >(), const bool computeDelta=false, const bool computeGamma=false, const bool linearInZero=true, const bool applySimmExemptions=false)

void	calculate () const override

std::vector< Handle< YieldTermStructure > >	discountCurves ()

std::vector< Currency >	currencies ()

Currency	npvCurrency ()

Private Member Functions
Handle< YieldTermStructure >	fetchTS (Currency ccy) const

Handle< Quote >	fetchFX (Currency ccy) const

Private Attributes
const std::vector< Handle< YieldTermStructure > >	discountCurves_

const std::vector< Handle< Quote > >	fxQuotes_

const std::vector< Currency >	currencies_

const Currency	npvCurrency_

const std::vector< Time >	bucketTimes_

const bool	computeDelta_

const bool	computeGamma_

const bool	linearInZero_

const bool	applySimmExemptions_

Detailed Description

Discounting currency swap engine providing analytical deltas and gammas.

This class generalizes QuantLib's DiscountingSwapEngine. It takes leg currencies into account and converts into the provided "npv currency", which must be one of the leg currencies. The evaluation date is the reference date of either of the discounting curves (which must be equal).

The same comments as in discountingswapenginedeltagamma.hpp apply here, so read them first.

The engine processes FX linked flows from xccy resetting swaps, but only captures the additional FX Spot Delta risk coming from the reset feature. Interest Deltas and Gammas coming from the FX forwarding factor P_for / P_dom are neglected, this factor is treated as a constant for the purpose of sensitivity calculation.

Here, the additional results are:

deltaDiscount (map<Currency, vector<Real>> ): Delta on discount curve, rebucketed, values are in currency deltaForward (map<Currency, vector<Real>> ): Delta on forward curve, rebucketed, value are in currency deltaFxSpot (map<Currency, Real> ): Delta on FX Spot (for all leg currencies, even if = npv ccy)

gamma (map<Currency, Matrix> ): Gamma matrix per currency with blocks | dsc-dsc dsc-fwd | | dsc-fwd fwd-fwd | (note that the second derivatives including the FX Spot are zero for the pure second derivative w.r.t. the FX Spot or given by the in currency delta values provided as the additional result deltaDiscount, deltaForward, to be reinterpreted as values in domestic currency)

fxSpot (map<Currency, Real> ): FX Spot used for conversion to npvCurrency (for all leg ccys) bucketTimes (vector<Real> ): Bucketing grid for deltas and gammas

Warning:: : The assumption is that per currency we only have one discount and one forward curve. It is possible to have several, but then the computed deltas will be aggregated over all those curves.

Definition at line 69 of file discountingcurrencyswapenginedeltagamma.hpp.

Member Typedef Documentation

◆ result_type_matrix

typedef std::map<Currency, Matrix, CurrencyComparator> result_type_matrix

Definition at line 71 of file discountingcurrencyswapenginedeltagamma.hpp.

◆ result_type_vector

typedef std::map<Currency, std::vector<Real>, CurrencyComparator> result_type_vector

Definition at line 72 of file discountingcurrencyswapenginedeltagamma.hpp.

◆ result_type_scalar

typedef std::map<Currency, Real, CurrencyComparator> result_type_scalar

Definition at line 73 of file discountingcurrencyswapenginedeltagamma.hpp.

Constructor & Destructor Documentation

◆ DiscountingCurrencySwapEngineDeltaGamma()

DiscountingCurrencySwapEngineDeltaGamma	(	const std::vector< Handle< YieldTermStructure > > &	discountCurves,
		const std::vector< Handle< Quote > > &	fxQuotes,
		const std::vector< Currency > &	currencies,
		const Currency &	npvCurrency,
		const std::vector< Time > &	bucketTimes = `std::vector<Time>()`,
		const bool	computeDelta = `false`,
		const bool	computeGamma = `false`,
		const bool	linearInZero = `true`,
		const bool	applySimmExemptions = `false`
	)

The FX spots must be given as units of npvCurrency per respective currency. The spots must be given w.r.t. a settlement date equal to the npv date (which is the reference date of the term structures).

If applySimmExemptions = true, simple cashflows will be excluded from the additional results listed above (but not from the npv / leg npv results) if

the underlying instrument is physically settled and
the underlying instrument is not a resettable swap Notice that the SIMM adjustments for resettable swaps are not applied though!

Definition at line 34 of file discountingcurrencyswapenginedeltagamma.cpp.

    : discountCurves_(discountCurves), fxQuotes_(fxQuotes), currencies_(currencies), npvCurrency_(npvCurrency),
      bucketTimes_(bucketTimes), computeDelta_(computeDelta), computeGamma_(computeGamma), linearInZero_(linearInZero),
      applySimmExemptions_(applySimmExemptions) {
 
    QL_REQUIRE(discountCurves_.size() == currencies_.size(), "Number of "
                                                             "currencies does not match number of discount curves.");
    QL_REQUIRE(fxQuotes_.size() == currencies_.size(), "Number of "
                                                       "currencies does not match number of FX quotes.");
 
    for (Size i = 0; i < discountCurves_.size(); i++) {
        registerWith(discountCurves_[i]);
        registerWith(fxQuotes_[i]);
    }
 
    QL_REQUIRE(!bucketTimes_.empty() || (!computeDelta && !computeGamma),
               "bucket times are empty, although sensitivities have to be calculated");
}

Member Function Documentation

◆ calculate()

void calculate ( ) const

override

Definition at line 72 of file discountingcurrencyswapenginedeltagamma.cpp.

                                                              {
 
    for (Size i = 0; i < arguments_.currency.size(); i++) {
        Currency ccy = arguments_.currency[i];
        Handle<YieldTermStructure> yts = fetchTS(ccy);
        QL_REQUIRE(!yts.empty(), "Discounting term structure is "
                                 "empty for "
                                     << ccy.name());
        Handle<Quote> fxQuote = fetchFX(ccy);
        QL_REQUIRE(!fxQuote.empty(), "FX quote is empty "
                                     "for "
                                         << ccy.name());
    }
 
    // Prepare the results containers
    Size numLegs = arguments_.legs.size();
 
    // - Instrument::results
    results_.value = 0.0;
    results_.errorEstimate = Null<Real>();
 
    // - CurrencySwap::results
    results_.legNPV.resize(numLegs);
    results_.inCcyLegNPV.resize(numLegs);
 
    // compute npv and raw deltas
 
    std::map<Currency, std::map<Date, Real>, CurrencyComparator> deltaDiscountRaw, deltaForwardRaw, gammaDiscountRaw;
    std::map<Currency, std::map<std::pair<Date, Date>, Real>, CurrencyComparator> gammaForwardRaw, gammaDscFwdRaw;
    std::map<Currency, Real, CurrencyComparator> fxLinkedForeignNpv; // foreign ccy => npv in foreign ccy
    std::map<Currency, Real, CurrencyComparator> fxSpot, fxSpotDelta;
    std::set<Currency, CurrencyComparator> currencies;
    std::map<Date, Real> empty, fxLinkedDeltaEmpty;
 
    for (Size i = 0; i < numLegs; ++i) {
        try {
            Currency ccy = arguments_.currency[i];
 
            // look for second ccy, we need this for FX Linked Coupons - the assumption is then that there are
            // exactly two currencies in the swap; if we don't find a second ccy, we do not collect contributions
            // from fx linked coupons below
            Currency ccy2;
            Real fx2 = 1.0;
            for (Size j = 0; j < numLegs; ++j) {
                if (arguments_.currency[j] != ccy) {
                    ccy2 = arguments_.currency[j];
                    fx2 = fetchFX(ccy2)->value();
                    fxSpot[ccy2] = fx2;
                }
            }
 
            currencies.insert(ccy);
            Handle<YieldTermStructure> yts = fetchTS(ccy);
            Real npv = 0.0, bps = 0.0, simpleCashFlowNpv = 0.0;
            Real fxLinkedForeignNpvTmp = 0.0;
            detail::NpvDeltaGammaCalculator calc(
                yts, arguments_.payer[i], npv, bps, computeDelta_, computeGamma_, false, deltaDiscountRaw[ccy],
                deltaForwardRaw[ccy], empty, gammaDiscountRaw[ccy], gammaForwardRaw[ccy], gammaDscFwdRaw[ccy], empty,
                fxLinkedForeignNpvTmp,
                applySimmExemptions_ && arguments_.isPhysicallySettled && !arguments_.isResettable, simpleCashFlowNpv);
            Leg& leg = arguments_.legs[i];
            for (Size ii = 0; ii < leg.size(); ++ii) {
                CashFlow& cf = *leg[ii];
                if (cf.date() <= yts->referenceDate()) {
                    continue;
                }
                cf.accept(calc);
            }
            Real fx = fetchFX(ccy)->value();
            fxSpotDelta[ccy] += npv;
            fxSpot[ccy] = fx;
            results_.inCcyLegNPV[i] = npv + simpleCashFlowNpv;
            results_.legNPV[i] = results_.inCcyLegNPV[i] * fx;
            results_.value += results_.legNPV[i];
            // handle contribution from FX Linked Coupon:
            // - these should be subtracted from the fx spot delta in the converted ccy,
            // - and added to the fx spot delta in the original ccy.
            if (!ccy2.empty()) {
                fxSpotDelta[ccy] -= fxLinkedForeignNpvTmp * fx2 / fx;
                fxLinkedForeignNpv[ccy2] += fxLinkedForeignNpvTmp;
            }
        } catch (std::exception& e) {
            QL_FAIL("DiscountingCurrencySwapEngineDeltaGamma, leg " << i << ": " << e.what());
        }
    } // i = 0, ... ,numlegs
 
    // contributions from FX Linked Coupons to fx spot delta
 
    for (auto const& f : fxLinkedForeignNpv) {
        fxSpotDelta[f.first] += f.second;
    }
 
    // set results
 
    results_.additionalResults["fxSpot"] = fxSpot;
    results_.additionalResults["deltaFxSpot"] = fxSpotDelta;
 
    // convert raw deltas to given bucketing structure
 
    results_.additionalResults["bucketTimes"] = bucketTimes_;
 
    if (computeDelta_) {
        std::map<Currency, std::vector<Real>, CurrencyComparator> deltaDiscount, deltaForward;
        for (std::map<Currency, std::map<Date, Real>, CurrencyComparator>::const_iterator i = deltaDiscountRaw.begin();
             i != deltaDiscountRaw.end(); ++i) {
            Handle<YieldTermStructure> yts = fetchTS(i->first);
            deltaDiscount[i->first] =
                detail::rebucketDeltas(bucketTimes_, i->second, yts->referenceDate(), yts->dayCounter(), linearInZero_);
        }
        results_.additionalResults["deltaDiscount"] = deltaDiscount;
 
        for (std::map<Currency, std::map<Date, Real>, CurrencyComparator>::const_iterator i = deltaForwardRaw.begin();
             i != deltaForwardRaw.end(); ++i) {
            Handle<YieldTermStructure> yts = fetchTS(i->first);
            deltaForward[i->first] =
                detail::rebucketDeltas(bucketTimes_, i->second, yts->referenceDate(), yts->dayCounter(), linearInZero_);
        }
        results_.additionalResults["deltaForward"] = deltaForward;
    }
 
    // convert raw gammas to given bucketing structure
 
    if (computeGamma_) {
        std::map<Currency, Matrix, CurrencyComparator> gamma;
        for (std::set<Currency>::const_iterator i = currencies.begin(); i != currencies.end(); ++i) {
            Handle<YieldTermStructure> yts = fetchTS(*i);
            Matrix tmp =
                detail::rebucketGammas(bucketTimes_, gammaDiscountRaw[*i], gammaForwardRaw[*i], gammaDscFwdRaw[*i],
                                       true, yts->referenceDate(), yts->dayCounter(), linearInZero_);
            gamma[*i] = tmp;
        }
        results_.additionalResults["gamma"] = gamma;
    }
 
} // calculate

Here is the call graph for this function:

◆ discountCurves()

std::vector< Handle< YieldTermStructure > > discountCurves ( )

Definition at line 91 of file discountingcurrencyswapenginedeltagamma.hpp.

91{ return discountCurves_; }

◆ currencies()

std::vector< Currency > currencies ( )

Definition at line 92 of file discountingcurrencyswapenginedeltagamma.hpp.

92{ return currencies_; }

Here is the caller graph for this function:

◆ npvCurrency()

Currency npvCurrency ( )

Definition at line 93 of file discountingcurrencyswapenginedeltagamma.hpp.

93{ return npvCurrency_; }

◆ fetchTS()

Handle< YieldTermStructure > fetchTS ( Currency ccy ) const

private

Definition at line 56 of file discountingcurrencyswapenginedeltagamma.cpp.

                                                                                              {
    std::vector<Currency>::const_iterator i = std::find(currencies_.begin(), currencies_.end(), ccy);
    if (i == currencies_.end())
        return Handle<YieldTermStructure>();
    else
        return discountCurves_[i - currencies_.begin()];
}

Here is the caller graph for this function:

◆ fetchFX()

Handle< Quote > fetchFX ( Currency ccy ) const

private

Definition at line 64 of file discountingcurrencyswapenginedeltagamma.cpp.

                                                                                 {
    std::vector<Currency>::const_iterator i = std::find(currencies_.begin(), currencies_.end(), ccy);
    if (i == currencies_.end())
        return Handle<Quote>();
    else
        return fxQuotes_[i - currencies_.begin()];
}

Here is the caller graph for this function:

Member Data Documentation

◆ discountCurves_

const std::vector<Handle<YieldTermStructure> > discountCurves_

private

Definition at line 99 of file discountingcurrencyswapenginedeltagamma.hpp.

◆ fxQuotes_

const std::vector<Handle<Quote> > fxQuotes_

private

Definition at line 100 of file discountingcurrencyswapenginedeltagamma.hpp.

◆ currencies_

const std::vector<Currency> currencies_

private

Definition at line 101 of file discountingcurrencyswapenginedeltagamma.hpp.

◆ npvCurrency_

const Currency npvCurrency_

private

Definition at line 102 of file discountingcurrencyswapenginedeltagamma.hpp.

◆ bucketTimes_

const std::vector<Time> bucketTimes_

private

Definition at line 103 of file discountingcurrencyswapenginedeltagamma.hpp.

◆ computeDelta_

const bool computeDelta_

private

Definition at line 104 of file discountingcurrencyswapenginedeltagamma.hpp.

◆ computeGamma_

const bool computeGamma_

private

Definition at line 104 of file discountingcurrencyswapenginedeltagamma.hpp.

◆ linearInZero_

const bool linearInZero_

private

Definition at line 104 of file discountingcurrencyswapenginedeltagamma.hpp.

◆ applySimmExemptions_

const bool applySimmExemptions_

private

Definition at line 104 of file discountingcurrencyswapenginedeltagamma.hpp.

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ result_type_matrix

◆ result_type_vector

◆ result_type_scalar

Constructor & Destructor Documentation

◆ DiscountingCurrencySwapEngineDeltaGamma()

Member Function Documentation

◆ calculate()

◆ discountCurves()

◆ currencies()

◆ npvCurrency()

◆ fetchTS()

◆ fetchFX()

Member Data Documentation

◆ discountCurves_

◆ fxQuotes_

◆ currencies_

◆ npvCurrency_

◆ bucketTimes_

◆ computeDelta_

◆ computeGamma_

◆ linearInZero_

◆ applySimmExemptions_