Discounting FX Forward Engine providing analytical deltas and gammas. More...

#include <qle/pricingengines/discountingfxforwardenginedeltagamma.hpp>

Inheritance diagram for DiscountingFxForwardEngineDeltaGamma:

Collaboration diagram for DiscountingFxForwardEngineDeltaGamma:

Public Member Functions
	DiscountingFxForwardEngineDeltaGamma (const Currency &domCcy, const Handle< YieldTermStructure > &domCurve, const Currency &forCcy, const Handle< YieldTermStructure > &forCurve, const Handle< Quote > &spotFx, const std::vector< Time > &bucketTimes=std::vector< Time >(), const bool computeDelta=false, const bool computeGamma=false, const bool linearInZero=true, boost::optional< bool > includeSettlementDateFlows=boost::none, const Date &settlementDate=Date(), const Date &npvDate=Date(), const bool applySimmExemptions=false)

void	calculate () const override

const Handle< YieldTermStructure > &	domCurve () const

const Handle< YieldTermStructure > &	forCurve () const

const Currency &	domCcy () const

const Currency &	forCcy () const

const Handle< Quote > &	spotFx () const

Private Attributes
Currency	domCcy_

Currency	forCcy_

Handle< YieldTermStructure >	domCurve_

Handle< YieldTermStructure >	forCurve_

Handle< Quote >	spotFx_

const std::vector< Time >	bucketTimes_

const bool	computeDelta_

const bool	computeGamma_

const bool	linearInZero_

boost::optional< bool >	includeSettlementDateFlows_

Date	settlementDate_

Date	npvDate_

bool	applySimmExemptions_

Detailed Description

Discounting FX Forward Engine providing analytical deltas and gammas.

This class generalises QuantExt's DiscountingFxForwardEngine, in analogy to the DiscountingCurrencySwapEngineDeltaGamma. Additional results are

deltaDiscount (map<Currency, vector<Real>> ): Delta on discount curve, rebucketed, values are in currency deltaFxSpot (map<Currency, Real> ): Delta on FX Spot (for ccy != npvCcy)

gamma (map<Currency, Matrix> ): Gamma matrix per currency between discount curve tenor points

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 to be reinterpreted as values in domestic currency)

fxSpot (map<Currency, Real> ): FX Spot used for conversion to npvCurrency (for ccy != npvCcy) bucketTimes (vector<Real> ): Bucketing grid for deltas and gammas

npvDom, npvFor : NPV of domestic flow resp. foreign flow (in dom resp. for ccy)

Definition at line 56 of file discountingfxforwardenginedeltagamma.hpp.

Constructor & Destructor Documentation

◆ DiscountingFxForwardEngineDeltaGamma()

DiscountingFxForwardEngineDeltaGamma	(	const Currency &	domCcy,
		const Handle< YieldTermStructure > &	domCurve,
		const Currency &	forCcy,
		const Handle< YieldTermStructure > &	forCurve,
		const Handle< Quote > &	spotFx,
		const std::vector< Time > &	bucketTimes = `std::vector<Time>()`,
		const bool	computeDelta = `false`,
		const bool	computeGamma = `false`,
		const bool	linearInZero = `true`,
		boost::optional< bool >	includeSettlementDateFlows = `boost::none`,
		const Date &	settlementDate = `Date()`,
		const Date &	npvDate = `Date()`,
		const bool	applySimmExemptions = `false`
	)

Parameters

domCcy,domCurve	Currency 1 and its discount curve.
forCcy,forCurve	Currency 2 and its discount curve.
spotFx	The market spot rate quote, given as units of domCcy for one unit of forCcy. The spot rate must be given w.r.t. a settlement equal to the npv date.
bucketTimes	Bucketing grid for deltas and gammas
computeDelta,computeGamma	Switch to enable/disable delta and gamma calculation
linearInZero	Interpolation used in the delta/gamma rebucketing to the desired time grid
includeSettlementDateFlows,settlementDate	If includeSettlementDateFlows is true (false), cashflows on the settlementDate are (not) included in the NPV. If not given the settlement date is set to the npv date.
npvDate	The date w.r.t. which the npv should be computed.
applySimmExemptions	If true, physically settled flows are ignored in sensi calculation, i.e. in he additional results above, including npvDom and npvFor

Definition at line 30 of file discountingfxforwardenginedeltagamma.cpp.

    : domCcy_(domCcy), forCcy_(forCcy), domCurve_(domCurve), forCurve_(forCurve), spotFx_(spotFx),
      bucketTimes_(bucketTimes), computeDelta_(computeDelta), computeGamma_(computeGamma), linearInZero_(linearInZero),
      includeSettlementDateFlows_(includeSettlementDateFlows), settlementDate_(settlementDate), npvDate_(npvDate),
      applySimmExemptions_(applySimmExemptions) {
    registerWith(domCurve_);
    registerWith(forCurve_);
    registerWith(spotFx_);
}

Member Function Documentation

◆ calculate()

void calculate ( ) const

override

Definition at line 45 of file discountingfxforwardenginedeltagamma.cpp.

                                                           {
 
    QL_REQUIRE(!domCurve_.empty(), "domestic curve is empty");
    QL_REQUIRE(!forCurve_.empty(), "foreign curve is empty");
    QL_REQUIRE(!spotFx_.empty(), "FX quote is empty");
 
    // we build this engine similar to the currency swap engine
 
    std::vector<Leg> legs;
    legs.push_back(Leg(1, QuantLib::ext::make_shared<SimpleCashFlow>(arguments_.nominal1, arguments_.maturityDate)));
    legs.push_back(Leg(1, QuantLib::ext::make_shared<SimpleCashFlow>(arguments_.nominal2, arguments_.maturityDate)));
 
    std::vector<Currency> currencies = {arguments_.currency1, arguments_.currency2};
 
    std::vector<Real> payer = {arguments_.payCurrency1 ? -1.0 : 1.0, arguments_.payCurrency1 ? 1.0 : -1.0};
 
    results_.value = 0.0;
 
    std::map<Currency, std::map<Date, Real>, CurrencyComparator> deltaDiscountRaw, gammaDiscountRaw;
    std::map<Currency, Real, CurrencyComparator> fxSpot, fxSpotDelta;
    std::map<Date, Real> empty;
    std::map<std::pair<Date, Date>, Real> empty2;
    Real empty3 = 0.0;
 
    Real domFlow = 0, forFlow = 0, domNPV = 0, forNPV = 0;
    for (Size i = 0; i < 2; ++i) {
        try {
            Handle<YieldTermStructure> yts;
            if (currencies[i] == domCcy_)
                yts = domCurve_;
            else if (currencies[i] == forCcy_)
                yts = forCurve_;
            else {
                QL_FAIL("ccy " << currencies[i] << " not handled.");
            }
            Real npv = 0.0, bps = 0.0, simpleCashFlowNpv = 0.0;
            detail::NpvDeltaGammaCalculator calc(
                yts, payer[i], npv, bps, computeDelta_, computeGamma_, false, deltaDiscountRaw[currencies[i]], empty,
                empty, gammaDiscountRaw[currencies[i]], empty2, empty2, empty, empty3,
                applySimmExemptions_ && arguments_.isPhysicallySettled, simpleCashFlowNpv);
            for (Size ii = 0; ii < legs[i].size(); ++ii) {
                CashFlow& cf = *legs[i][ii];
                if (cf.date() <= yts->referenceDate()) {
                    continue;
                }
                cf.accept(calc);
                if (currencies[i] == domCcy_)
                    domFlow = cf.amount();
                if (currencies[i] == forCcy_)
                    forFlow = cf.amount();
            }
            if (currencies[i] == domCcy_) {
                domNPV = npv;
                results_.additionalResults["npvDom"] = npv;
                results_.value += npv + simpleCashFlowNpv;
            } else {
                forNPV = npv;
                results_.additionalResults["npvFor"] = npv;
                results_.value += (npv + simpleCashFlowNpv) * spotFx_->value();
                fxSpot[currencies[i]] = spotFx_->value();
                fxSpotDelta[currencies[i]] += npv;
            }
        } catch (const std::exception& e) {
            QL_FAIL("DiscountingFxForwardEngineDeltaGamma, leg " << i << ": " << e.what());
        }
    } // for i = 0, 1 (legs)
 
    results_.additionalResults["fxSpot"] = fxSpot;
    results_.additionalResults["deltaFxSpot"] = fxSpotDelta;
 
    Date npvDate = npvDate_;
    if (npvDate == Null<Date>()) {
        npvDate = domCurve_->referenceDate();
    }
    Date settlementDate = settlementDate_;
    if (settlementDate == Null<Date>()) {
        settlementDate = npvDate;
    }
 
    // convert raw deltas to given bucketing structure
    if (computeDelta_) {
        std::map<Currency, std::vector<Real>, CurrencyComparator> deltaDiscount;
        for (std::map<Currency, std::map<Date, Real>, CurrencyComparator>::const_iterator i = deltaDiscountRaw.begin();
             i != deltaDiscountRaw.end(); ++i) {
            Handle<YieldTermStructure> yts = i->first == domCcy_ ? domCurve_ : forCurve_;
            deltaDiscount[i->first] =
                detail::rebucketDeltas(bucketTimes_, i->second, yts->referenceDate(), yts->dayCounter(), linearInZero_);
        }
        results_.additionalResults["deltaDiscount"] = deltaDiscount;
        results_.additionalResults["bucketTimes"] = bucketTimes_;
    }
 
    // convert raw gammas to given bucketing structure
    if (computeGamma_) {
        std::map<Currency, Matrix, CurrencyComparator> gamma;
        for (std::vector<Currency>::const_iterator i = currencies.begin(); i != currencies.end(); ++i) {
            Handle<YieldTermStructure> yts = *i == domCcy_ ? domCurve_ : forCurve_;
            Matrix tmp = detail::rebucketGammas(bucketTimes_, gammaDiscountRaw[*i], empty2, empty2, false,
                                                yts->referenceDate(), yts->dayCounter(), linearInZero_);
            gamma[*i] = tmp;
        }
        results_.additionalResults["gamma"] = gamma;
        results_.additionalResults["bucketTimes"] = bucketTimes_;
    }
 
    // Align notional with ISDA AANA/GRID guidance as of November 2020 for deliverable forwards
    if (fabs(domNPV) > fabs(forNPV) * spotFx_->value()) {
        results_.additionalResults["currentNotional"] = domFlow;
        results_.additionalResults["notionalCurrency"] = domCcy_.code();
    } else {
        results_.additionalResults["currentNotional"] = forFlow;
        results_.additionalResults["notionalCurrency"] = forCcy_.code();
     }
    
} // calculate