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

#include <qle/pricingengines/discountingswapenginedeltagamma.hpp>

Inheritance diagram for DiscountingSwapEngineDeltaGamma:

Collaboration diagram for DiscountingSwapEngineDeltaGamma:

Public Member Functions
	DiscountingSwapEngineDeltaGamma (const Handle< YieldTermStructure > &discountCurve=Handle< YieldTermStructure >(), const std::vector< Time > &bucketTimes=std::vector< Time >(), const bool computeDelta=false, const bool computeGamma=false, const bool computeBPS=false, const bool linearInZero=true)

void	calculate () const override

Handle< YieldTermStructure >	discountCurve () const

Private Attributes
Handle< YieldTermStructure >	discountCurve_

const std::vector< Real >	bucketTimes_

const bool	computeDelta_

const bool	computeGamma_

const bool	computeBPS_

const bool	linearInZero_

Detailed Description

Discounting swap engine providing analytical deltas and gammas.

The provided deltas and gammas are (continuously compounded) zero yield deltas assuming linear in zero or loglinear in discount factor interpolation on the discounting and forwarding curves with flat extrapolation of the zero rate before the first and last bucket time. The deltas are provided as additional results

deltaDiscount (vector<Real> ): Delta on discount curve, rebucketed on time grid deltaForward (vector<Real> ): Delta on forward curve, rebucketed on time grid deltaBPS (vector<vector<Real>> ): Delta of BPS (on discount curve, per leg)

The gammas, likewise,

gamma (Matrix ): Gamma matrix with blocks | dsc-dsc dsc-fwd | | dsc-fwd fwd-fwd | gammaBps (vector<Matrix> ): Gamma of BPS (on dsc, per leg)

bucketTimes (vector<Real> ): Bucketing grid for deltas and gammas

Warning:: Deltas and gammas are produced only for fixed and Ibor coupons without caps or floors, for Ibor coupons they are ignoring convexity adjustments (like in arrears adjustments). It is possible to have different Ibor coupons (with different forward curves) on a leg, but the computed deltas would be aggregated over all underlying curves then.

Warning:

Derivatives are not w.r.t. basispoints, but w.r.t. the usual unit

BPS is the value of one unit (not one basispoint actually), it has to be divided by 10000.0 to get QL's BPS

Definition at line 70 of file discountingswapenginedeltagamma.hpp.

Constructor & Destructor Documentation

◆ DiscountingSwapEngineDeltaGamma()

DiscountingSwapEngineDeltaGamma	(	const Handle< YieldTermStructure > &	discountCurve = `Handle<YieldTermStructure>()`,
		const std::vector< Time > &	bucketTimes = `std::vector<Time>()`,
		const bool	computeDelta = `false`,
		const bool	computeGamma = `false`,
		const bool	computeBPS = `false`,
		const bool	linearInZero = `true`
	)

Definition at line 375 of file discountingswapenginedeltagamma.cpp.

    : discountCurve_(discountCurve), bucketTimes_(bucketTimes), computeDelta_(computeDelta),
      computeGamma_(computeGamma), computeBPS_(computeBPS), linearInZero_(linearInZero) {
    registerWith(discountCurve_);
    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 386 of file discountingswapenginedeltagamma.cpp.

                                                      {
    QL_REQUIRE(!discountCurve_.empty(), "discounting term structure handle is empty");
 
    // compute npv and raw deltas
 
    results_.value = 0.0;
    results_.errorEstimate = Null<Real>();
    results_.legNPV.resize(arguments_.legs.size());
    if (computeBPS_)
        results_.legBPS.resize(arguments_.legs.size());
 
    std::map<Date, Real> deltaDiscountRaw, deltaForwardRaw, gammaDiscountRaw;
    std::map<std::pair<Date, Date>, Real> gammaForwardRaw, gammaDscFwdRaw;
 
    std::vector<std::vector<Real>> deltaBPS;
    std::vector<Matrix> gammaBPS;
 
    Real empty = 0.0;
 
    for (Size j = 0; j < arguments_.legs.size(); ++j) {
        Real npv = 0.0, bps = 0.0;
        std::map<Date, Real> deltaBPSRaw, gammaBPSRaw; // these results are per leg
        detail::NpvDeltaGammaCalculator calc(discountCurve_, arguments_.payer[j], npv, bps, computeDelta_,
                                             computeGamma_, computeBPS_, deltaDiscountRaw, deltaForwardRaw, deltaBPSRaw,
                                             gammaDiscountRaw, gammaForwardRaw, gammaDscFwdRaw, gammaBPSRaw, empty,
                                             false, empty);
        Leg& leg = arguments_.legs[j];
        for (Size i = 0; i < leg.size(); ++i) {
            CashFlow& cf = *leg[i];
            if (cf.date() <= discountCurve_->referenceDate()) {
                continue;
            }
            cf.accept(calc);
        }
        results_.legNPV[j] = npv;
        results_.value += npv;
        if (computeBPS_) {
            std::map<std::pair<Date, Date>, Real> empty;
            results_.legBPS[j] += bps;
            // bps delta and gamma are per leg, i.e. we have to compute delta and gamma already here,
            // the result vectors are then set below where the rest of the delta / gamma computation is done
            std::vector<Real> tmp = detail::rebucketDeltas(bucketTimes_, deltaBPSRaw, discountCurve_->referenceDate(),
                                                           discountCurve_->dayCounter(), linearInZero_);
            deltaBPS.push_back(tmp);
            Matrix tmp2 =
                detail::rebucketGammas(bucketTimes_, gammaBPSRaw, empty, empty, false, discountCurve_->referenceDate(),
                                       discountCurve_->dayCounter(), linearInZero_);
            gammaBPS.push_back(tmp2);
        }
    }
 
    // convert raw deltas to given bucketing structure
 
    results_.additionalResults["bucketTimes"] = bucketTimes_;
 
    if (computeDelta_) {
        std::vector<Real> deltaDiscount =
            detail::rebucketDeltas(bucketTimes_, deltaDiscountRaw, discountCurve_->referenceDate(),
                                   discountCurve_->dayCounter(), linearInZero_);
        std::vector<Real> deltaForward =
            detail::rebucketDeltas(bucketTimes_, deltaForwardRaw, discountCurve_->referenceDate(),
                                   discountCurve_->dayCounter(), linearInZero_);
 
        results_.additionalResults["deltaDiscount"] = deltaDiscount;
        results_.additionalResults["deltaForward"] = deltaForward;
        if (computeBPS_) {
            results_.additionalResults["deltaBPS"] = deltaBPS;
        }
    }
 
    // convert raw gammas to given bucketing structure
 
    if (computeGamma_) {
        Matrix gamma =
            detail::rebucketGammas(bucketTimes_, gammaDiscountRaw, gammaForwardRaw, gammaDscFwdRaw, true,
                                   discountCurve_->referenceDate(), discountCurve_->dayCounter(), linearInZero_);
        results_.additionalResults["gamma"] = gamma;
        if (computeBPS_) {
            results_.additionalResults["gammaBPS"] = gammaBPS;
        }
    }
 
} // calculate()