#include <qle/pricingengines/discountingswapenginedeltagamma.hpp>

Inheritance diagram for NpvDeltaGammaCalculator:

Collaboration diagram for NpvDeltaGammaCalculator:

Public Member Functions
	NpvDeltaGammaCalculator (Handle< YieldTermStructure > discountCurve, const Real payer, Real &npv, Real &bps, const bool computeDelta, const bool computeGamma, const bool computeBPS, std::map< Date, Real > &deltaDiscount, std::map< Date, Real > &deltaForward, std::map< Date, Real > &deltaBPS, std::map< Date, Real > &gammaDiscount, std::map< std::pair< Date, Date >, Real > &gammaForward, std::map< std::pair< Date, Date >, Real > &gammaDscFwd, std::map< Date, Real > &gammaBPS, Real &fxLinkedForeignNpv, const bool excludeSimpleCashFlowsFromSensis, Real &simpleCashFlowNpv)

void	visit (CashFlow &c) override

void	visit (SimpleCashFlow &c) override

void	visit (FixedRateCoupon &c) override

void	visit (IborCoupon &c) override

void	visit (FloatingRateFXLinkedNotionalCoupon &c) override

void	visit (FXLinkedCashFlow &c) override

void	visit (QuantExt::OvernightIndexedCoupon &c) override

Private Member Functions
void	processIborCoupon (FloatingRateCoupon &c)

Private Attributes
Handle< YieldTermStructure >	discountCurve_

const Real	payer_

Real &	npv_

Real &	bps_

const bool	computeDelta_

const bool	computeGamma_

const bool	computeBPS_

std::map< Date, Real > &	deltaDiscount_

std::map< Date, Real > &	deltaForward_

std::map< Date, Real > &	deltaBPS_

std::map< Date, Real > &	gammaDiscount_

std::map< std::pair< Date, Date >, Real > &	gammaForward_

std::map< std::pair< Date, Date >, Real > &	gammaDscFwd_

std::map< Date, Real > &	gammaBPS_

Real &	fxLinkedForeignNpv_

const bool	excludeSimpleCashFlowsFromSensis_

Real &	simpleCashFlowNpv_

Detailed Description

Definition at line 87 of file discountingswapenginedeltagamma.hpp.

Constructor & Destructor Documentation

◆ NpvDeltaGammaCalculator()

NpvDeltaGammaCalculator	(	Handle< YieldTermStructure >	discountCurve,
		const Real	payer,
		Real &	npv,
		Real &	bps,
		const bool	computeDelta,
		const bool	computeGamma,
		const bool	computeBPS,
		std::map< Date, Real > &	deltaDiscount,
		std::map< Date, Real > &	deltaForward,
		std::map< Date, Real > &	deltaBPS,
		std::map< Date, Real > &	gammaDiscount,
		std::map< std::pair< Date, Date >, Real > &	gammaForward,
		std::map< std::pair< Date, Date >, Real > &	gammaDscFwd,
		std::map< Date, Real > &	gammaBPS,
		Real &	fxLinkedForeignNpv,
		const bool	excludeSimpleCashFlowsFromSensis,
		Real &	simpleCashFlowNpv
	)

Definition at line 36 of file discountingswapenginedeltagamma.cpp.

    : discountCurve_(discountCurve), payer_(payer), npv_(npv), bps_(bps), computeDelta_(computeDelta),
      computeGamma_(computeGamma), computeBPS_(computeBPS), deltaDiscount_(deltaDiscount), deltaForward_(deltaForward),
      deltaBPS_(deltaBPS), gammaDiscount_(gammaDiscount), gammaForward_(gammaForward), gammaDscFwd_(gammaDscFwd),
      gammaBPS_(gammaBPS), fxLinkedForeignNpv_(fxLinkedForeignNpv),
      excludeSimpleCashFlowsFromSensis_(excludeSimpleCashFlowsFromSensis), simpleCashFlowNpv_(simpleCashFlowNpv) {}

Member Function Documentation

◆ visit() [1/7]

void visit ( CashFlow & c )

override

Definition at line 51 of file discountingswapenginedeltagamma.cpp.

                                               {
    Real dsc = discountCurve_->discount(c.date());
    Real a = payer_ * c.amount() * dsc;
    npv_ += a;
    Real t = discountCurve_->timeFromReference(c.date());
    if (computeDelta_) {
        getMapEntry(deltaDiscount_, c.date()) += -t * a;
    }
    if (computeGamma_) {
        getMapEntry(gammaDiscount_, c.date()) += t * t * a;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ visit() [2/7]

void visit ( SimpleCashFlow & c )

override

Definition at line 64 of file discountingswapenginedeltagamma.cpp.

                                                     {
    if (excludeSimpleCashFlowsFromSensis_) {
        // even when excluding the cf from the sensis we want to colect their npv contribution, but in a separate field
        Real dsc = discountCurve_->discount(c.date());
        Real a = payer_ * c.amount() * dsc;
        simpleCashFlowNpv_ += a;
        return;
    }
    visit(static_cast<CashFlow&>(c));
}

Here is the call graph for this function:

◆ visit() [3/7]

void visit ( FixedRateCoupon & c )

override

Definition at line 75 of file discountingswapenginedeltagamma.cpp.

                                                      {
    Real dsc = discountCurve_->discount(c.date());
    Real a = payer_ * c.amount() * dsc;
    npv_ += a;
    Real t = discountCurve_->timeFromReference(c.date());
    if (computeDelta_) {
        getMapEntry(deltaDiscount_, c.date()) += -t * a;
    }
    if (computeGamma_) {
        getMapEntry(gammaDiscount_, c.date()) += t * t * a;
    }
    if (computeBPS_) {
        Real tau = c.accrualPeriod();
        bps_ += payer_ * c.nominal() * tau * dsc;
        if (computeDelta_) {
            getMapEntry(deltaBPS_, c.date()) += -t * payer_ * c.nominal() * tau * dsc;
        }
        if (computeGamma_) {
            getMapEntry(gammaBPS_, c.date()) += t * t * payer_ * c.nominal() * tau * dsc;
        }
    }
}

Here is the call graph for this function:

◆ visit() [4/7]

void visit ( IborCoupon & c )

override

Definition at line 163 of file discountingswapenginedeltagamma.cpp.

163{ processIborCoupon(c); }

QuantExt::detail::NpvDeltaGammaCalculator::processIborCoupon

void processIborCoupon(FloatingRateCoupon &c)

Definition: discountingswapenginedeltagamma.cpp:98

Here is the call graph for this function:

◆ visit() [5/7]

void visit ( FloatingRateFXLinkedNotionalCoupon & c )

override

Definition at line 165 of file discountingswapenginedeltagamma.cpp.

                                                                         {
    // only add to the foreign npv (and hence effectively to the fx spot delta) if the fx rate is not yet fixed
    
     if (c.fxFixingDate() > discountCurve_->referenceDate() ||
        (c.fxFixingDate() == discountCurve_->referenceDate() &&
         c.fxIndex()->pastFixing(c.fxFixingDate()) == Null<Real>())) {
        Real tmp = c.fxIndex()->forecastFixing(0.0);
        fxLinkedForeignNpv_ += payer_ * c.amount() * discountCurve_->discount(c.date()) / tmp;
    }
    processIborCoupon(c);
}

Here is the call graph for this function:

◆ visit() [6/7]

void visit ( FXLinkedCashFlow & c )

override

Definition at line 177 of file discountingswapenginedeltagamma.cpp.

                                                       {
    Real dsc = discountCurve_->discount(c.date());
    Real a = payer_ * c.amount() * dsc;
    npv_ += a;
    Real t = discountCurve_->timeFromReference(c.date());
    if (computeDelta_) {
        getMapEntry(deltaDiscount_, c.date()) += -t * a;
    }
    if (computeGamma_) {
        getMapEntry(gammaDiscount_, c.date()) += t * t * a;
    }
    // only add to the foreign npv (and hence effectively to the fx spot delta) if the fx rate is not yet fixed
    if (c.fxFixingDate() > discountCurve_->referenceDate() ||
        (c.fxFixingDate() == discountCurve_->referenceDate() &&
         c.fxIndex()->pastFixing(c.fxFixingDate()) == Null<Real>())) {
        Real tmp = c.fxIndex()->forecastFixing(0.0);
        Real b = a / tmp;
        fxLinkedForeignNpv_ += b;
    }
}

Here is the call graph for this function:

◆ visit() [7/7]

void visit ( QuantExt::OvernightIndexedCoupon & c )

override

Definition at line 198 of file discountingswapenginedeltagamma.cpp.

{
    processIborCoupon(c);
}

Here is the call graph for this function:

◆ processIborCoupon()

void processIborCoupon ( FloatingRateCoupon & c )

private

Definition at line 98 of file discountingswapenginedeltagamma.cpp.

                                                                     {
    Real dsc = discountCurve_->discount(c.date());
    Real a = payer_ * c.amount() * dsc;
    npv_ += a;
    Date d3 = c.date();
    Real t3 = discountCurve_->timeFromReference(d3);
    if (computeDelta_) {
        getMapEntry(deltaDiscount_, d3) += -t3 * a;
    }
    if (computeGamma_) {
        getMapEntry(gammaDiscount_, d3) += t3 * t3 * a;
    }
    if (computeBPS_) {
        Real tau = c.accrualPeriod();
        bps_ += payer_ * tau * c.nominal() * dsc;
        if (computeDelta_) {
            getMapEntry(deltaBPS_, d3) += -t3 * payer_ * tau * c.nominal() * dsc;
        }
        if (computeGamma_) {
            getMapEntry(gammaBPS_, d3) += t3 * t3 * payer_ * tau * c.nominal() * dsc;
        }
    }
    Date fixing = c.fixingDate();
 
    // is it actually a floating rate coupon?
    if (fixing > discountCurve_->referenceDate() ||
        (fixing == discountCurve_->referenceDate() && c.index()->pastFixing(fixing) == Null<Real>())) {
        Date d1 = c.index()->valueDate(fixing);
        Date d2;
        if (IborCoupon::Settings::instance().usingAtParCoupons() && fixing <= c.accrualStartDate()) {
            // par coupon approximation
            Date nextFixingDate =
                c.index()->fixingCalendar().advance(c.accrualEndDate(), -static_cast<Integer>(c.fixingDays()), Days);
            d2 = c.index()->fixingCalendar().advance(nextFixingDate, c.fixingDays(), Days);
        } else if (IborCoupon::Settings::instance().usingAtParCoupons()) {
            // in arreas
            d2 = c.index()->maturityDate(d1);
        } else {
            // use indexed coupon
            d2 = c.index()->maturityDate(d1);
        }
       
        // if the coupon is degenerated we exit early
        if (d2 <= d1)
            return;
 
        Real t1 = discountCurve_->timeFromReference(d1);
        Real t2 = discountCurve_->timeFromReference(d2);
        Real r = payer_ * dsc *
                 (c.nominal() * c.accrualPeriod() *
                  (c.gearing() / c.index()->dayCounter().yearFraction(d1, d2) - c.spread()));
        if (computeDelta_) {
            getMapEntry(deltaForward_, d1) += -t1 * (a + r);
            getMapEntry(deltaForward_, d2) += t2 * (a + r);
        }
        if (computeGamma_) {
            getMapEntry(gammaForward_, std::make_pair(d1, d1)) += t1 * t1 * (a + r);
            getMapEntry(gammaForward_, std::make_pair(d2, d2)) += t2 * t2 * (a + r);
            getMapEntry(gammaForward_, std::make_pair(d1, d2)) += -2.0 * t1 * t2 * (a + r);
            getMapEntry(gammaDscFwd_, std::make_pair(d3, d1)) += t1 * t3 * (a + r);
            getMapEntry(gammaDscFwd_, std::make_pair(d3, d2)) += -t2 * t3 * (a + r);
        }
    }
} // process IborCoupon