Discounting FX Forward Engine. More...

#include <qle/pricingengines/discountingfxforwardengine.hpp>

Inheritance diagram for DiscountingFxForwardEngine:

Collaboration diagram for DiscountingFxForwardEngine:

Public Member Functions
	DiscountingFxForwardEngine (const Currency &ccy1, const Handle< YieldTermStructure > &currency1Discountcurve, const Currency &ccy2, const Handle< YieldTermStructure > &currency2Discountcurve, const Handle< Quote > &spotFX, boost::optional< bool > includeSettlementDateFlows=boost::none, const Date &settlementDate=Date(), const Date &npvDate=Date())

void	calculate () const override

const Handle< YieldTermStructure > &	currency1Discountcurve () const

const Handle< YieldTermStructure > &	currency2Discountcurve () const

const Currency &	currency1 () const

const Currency &	currency2 () const

const Handle< Quote > &	spotFX () const

Private Attributes
Currency	ccy1_

Handle< YieldTermStructure >	currency1Discountcurve_

Currency	ccy2_

Handle< YieldTermStructure >	currency2Discountcurve_

Handle< Quote >	spotFX_

boost::optional< bool >	includeSettlementDateFlows_

Date	settlementDate_

Date	npvDate_

Detailed Description

Discounting FX Forward Engine.

This class implements pricing of FX Forwards by discounting the future nominal cash flows using the respective yield curves. The npv is expressed in ccy1. The given currencies ccy1 and ccy2 are matched to the correct fx forward legs. The evaluation date is the reference date of either discounting curve (which must be equal).

    \ingroup engines

Definition at line 44 of file discountingfxforwardengine.hpp.

Constructor & Destructor Documentation

◆ DiscountingFxForwardEngine()

DiscountingFxForwardEngine	(	const Currency &	ccy1,
		const Handle< YieldTermStructure > &	currency1Discountcurve,
		const Currency &	ccy2,
		const Handle< YieldTermStructure > &	currency2Discountcurve,
		const Handle< Quote > &	spotFX,
		boost::optional< bool >	includeSettlementDateFlows = `boost::none`,
		const Date &	settlementDate = `Date()`,
		const Date &	npvDate = `Date()`
	)

Parameters

ccy1,currency1Discountcurve	Currency 1 and its discount curve.y
ccy2,currency2Discountcurve	Currency 2 and its discount curve.
spotFX	The market spot rate quote, given as units of ccy1 for one unit of ccy2. The spot rate must be given w.r.t. a settlement equal to the npv date.
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	Discount to this date. If not given the npv date is set to the evaluation date

Definition at line 26 of file discountingfxforwardengine.cpp.

    : ccy1_(ccy1), currency1Discountcurve_(currency1Discountcurve), ccy2_(ccy2),
      currency2Discountcurve_(currency2Discountcurve), spotFX_(spotFX),
      includeSettlementDateFlows_(includeSettlementDateFlows), settlementDate_(settlementDate), npvDate_(npvDate) {
    registerWith(currency1Discountcurve_);
    registerWith(currency2Discountcurve_);
    registerWith(spotFX_);
}

Member Function Documentation

◆ calculate()

void calculate ( ) const

override

Definition at line 38 of file discountingfxforwardengine.cpp.

                                                 {
    Date npvDate = npvDate_;
    if (npvDate == Null<Date>()) {
        npvDate = currency1Discountcurve_->referenceDate();
    }
    Date settlementDate = settlementDate_;
    if (settlementDate == Null<Date>()) {
        settlementDate = npvDate;
    }
 
    Real tmpNominal1, tmpNominal2;
    bool tmpPayCurrency1;
    if (ccy1_ == arguments_.currency1) {
        QL_REQUIRE(ccy2_ == arguments_.currency2, "mismatched currency pairs ("
                                                      << ccy1_ << "," << ccy2_ << ") in the engine and ("
                                                      << arguments_.currency1 << "," << arguments_.currency2
                                                      << ") in the instrument");
        tmpNominal1 = arguments_.nominal1;
        tmpNominal2 = arguments_.nominal2;
        tmpPayCurrency1 = arguments_.payCurrency1;
    } else {
        QL_REQUIRE(ccy1_ == arguments_.currency2 && ccy2_ == arguments_.currency1,
                   "mismatched currency pairs (" << ccy1_ << "," << ccy2_ << ") in the engine and ("
                                                 << arguments_.currency1 << "," << arguments_.currency2
                                                 << ") in the instrument");
        tmpNominal1 = arguments_.nominal2;
        tmpNominal2 = arguments_.nominal1;
        tmpPayCurrency1 = !arguments_.payCurrency1;
    }
 
    QL_REQUIRE(!currency1Discountcurve_.empty() && !currency2Discountcurve_.empty(),
               "Discounting term structure handle is empty.");
 
    QL_REQUIRE(currency1Discountcurve_->referenceDate() == currency2Discountcurve_->referenceDate(),
               "Term structures should have the same reference date.");
 
    QL_REQUIRE(arguments_.payDate >= currency1Discountcurve_->referenceDate(),
               "FX forward maturity should exceed or equal the "
               "discount curve reference date.");
 
    results_.value = 0.0;
    results_.fairForwardRate = ExchangeRate(ccy2_, ccy1_, tmpNominal1 / tmpNominal2); // strike rate
    results_.additionalResults["fairForwardRate"] = tmpNominal1 / tmpNominal2;
    results_.additionalResults["currency[1]"] = ccy1_.code();
    results_.additionalResults["currency[2]"] = ccy2_.code();
 
    // The instrument flag overrides what is passed to the engine c'tor
    bool includeSettlementDateFlows = arguments_.includeSettlementDateFlows;
    
    if (!detail::simple_event(arguments_.payDate).hasOccurred(settlementDate, includeSettlementDateFlows)) {
        Real disc1near = currency1Discountcurve_->discount(npvDate);
        Real disc1far = currency1Discountcurve_->discount(arguments_.payDate);
        Real disc2near = currency2Discountcurve_->discount(npvDate);
        Real disc2far = currency2Discountcurve_->discount(arguments_.payDate);
        Real fxfwd = disc1near / disc1far * disc2far / disc2near * spotFX_->value();
 
        // settle ccy is ccy1 if no pay ccy provided
        Currency settleCcy = arguments_.payCcy.empty() ? ccy1_ : arguments_.payCcy;
        bool settleCcy1 = ccy1_ == settleCcy;
 
        Real discNear = settleCcy1 ? disc1near : disc2near;
        Real discFar = settleCcy1 ? disc1far : disc2far;
        Real fx1 = settleCcy1 ? 1.0 : fxfwd;
        Real fx2 = settleCcy1 ? 1 / fxfwd : 1.0;
 
        QL_REQUIRE(arguments_.isPhysicallySettled || arguments_.payDate <= arguments_.fixingDate ||
                       arguments_.fxIndex != nullptr,
                   "If pay date (" << arguments_.payDate << ") is strictly after fixing date (" << arguments_.fixingDate
                                   << "), an FX Index must be given for a cash-settled FX Forward.");
        if (!arguments_.isPhysicallySettled && arguments_.payDate >= arguments_.fixingDate &&
            arguments_.fxIndex != nullptr) {
            fx1 = settleCcy1 ? 1.0 : arguments_.fxIndex->fixing(arguments_.fixingDate);
            fx2 = settleCcy1 ? arguments_.fxIndex->fixing(arguments_.fixingDate) : 1.0;
            fxfwd = arguments_.fxIndex->fixing(arguments_.fixingDate);
        }
 
        // populate cashflow results
        std::vector<CashFlowResults> cashFlowResults;
        CashFlowResults cf1, cf2;
        cf1.payDate = arguments_.payDate;
        cf1.type = "Notional";
        cf2.payDate = arguments_.payDate;
        cf2.type = "Notional";
        if (!arguments_.isPhysicallySettled) {
            if (arguments_.payDate >= arguments_.fixingDate) {
                cf1.fixingDate = arguments_.fixingDate;
                cf2.fixingDate = arguments_.fixingDate;
            }
            cf1.fixingValue = 1.0 / fx1;
            cf2.fixingValue = 1.0 / fx2;
            cf1.amount = (tmpPayCurrency1 ? -1.0 : 1.0) * tmpNominal1 / fx1;
            cf2.amount = (tmpPayCurrency1 ? -1.0 : 1.0) * (-tmpNominal2 / fx2);
            cf1.currency = settleCcy.code();
            cf2.currency = settleCcy.code();
        } else {
            cf1.amount = (tmpPayCurrency1 ? -1.0 : 1.0) * tmpNominal1;
            cf2.amount = (tmpPayCurrency1 ? -1.0 : 1.0) * (-tmpNominal2);
            cf1.currency = ccy1_.code();
            cf2.currency = ccy2_.code();
        }
        if (ccy1_ == arguments_.currency1) {
            cf1.legNumber = 0;
            cf2.legNumber = 1;
            cashFlowResults.push_back(cf1);
            cashFlowResults.push_back(cf2);
        } else {
            cf1.legNumber = 1;
            cf2.legNumber = 0;
            cashFlowResults.push_back(cf2);
            cashFlowResults.push_back(cf1);
        }
        results_.additionalResults["cashFlowResults"] = cashFlowResults;
 
        results_.value = (tmpPayCurrency1 ? -1.0 : 1.0) * discFar / discNear * (tmpNominal1 / fx1 - tmpNominal2 / fx2);
 
        results_.npv = Money(settleCcy, results_.value);
 
        results_.fairForwardRate = ExchangeRate(ccy2_, ccy1_, fxfwd);
        results_.additionalResults["fairForwardRate"] = fxfwd;
        results_.additionalResults["fxSpot"] = spotFX_->value();
        results_.additionalResults["discountFactor[1]"] = disc1far;
        results_.additionalResults["discountFactor[2]"] = disc2far;
        results_.additionalResults["legNPV[1]"] = (tmpPayCurrency1 ? -1.0 : 1.0) * discFar / discNear * tmpNominal1 / fx1;
        results_.additionalResults["legNPV[2]"] = (tmpPayCurrency1 ? -1.0 : 1.0) * discFar / discNear * (-tmpNominal2 / fx2);
 
        // set notional
        if (arguments_.isPhysicallySettled) {
            // Align notional with ISDA AANA/GRID guidance as of November 2020 for deliverable forwards
            if (tmpNominal1 > tmpNominal2 * fxfwd) {
                results_.additionalResults["currentNotional"] = tmpNominal1;
                results_.additionalResults["notionalCurrency"] = ccy1_.code();
            } else {
                results_.additionalResults["currentNotional"] = tmpNominal2;
                results_.additionalResults["notionalCurrency"] = ccy2_.code();
            }
        } else {
            // for cash settled forwards we take the notional from the settlement ccy leg
            results_.additionalResults["currentNotional"] =
                arguments_.currency1 == arguments_.payCcy ? arguments_.nominal1 : arguments_.nominal2;
            results_.additionalResults["notionalCurrency"] = arguments_.payCcy.code();
        }
    }
 
} // calculate