NumericLgmBgsFlexiSwapEngine Class Reference

Numerical engine for balance guaranteed swaps using a flexi swap proxy in the LGM model. More...

#include <qle/pricingengines/numericlgmbgsflexiswapengine.hpp>

Inheritance diagram for NumericLgmBgsFlexiSwapEngine:

Collaboration diagram for NumericLgmBgsFlexiSwapEngine:

Public Member Functions
	NumericLgmBgsFlexiSwapEngine (const QuantLib::ext::shared_ptr< LinearGaussMarkovModel > &model, const Real sy, const Size ny, const Real sx, const Size nx, const Handle< Quote > &minCpr, const Handle< Quote > &maxCpr, const Handle< YieldTermStructure > &discountCurve=Handle< YieldTermStructure >(), const Method method=Method::Automatic, const Real singleSwaptionThreshold=20.0)
Public Member Functions inherited from NumericLgmFlexiSwapEngineBase
	NumericLgmFlexiSwapEngineBase (const QuantLib::ext::shared_ptr< LinearGaussMarkovModel > &model, const Real sy, const Size ny, const Real sx, const Size nx, const Handle< YieldTermStructure > &discountCurve=Handle< YieldTermStructure >(), const Method method=Method::Automatic, const Real singleSwaptionThreshold=20.0)
Public Member Functions inherited from LgmConvolutionSolver
	LgmConvolutionSolver (const QuantLib::ext::shared_ptr< LinearGaussMarkovModel > &model, const Real sy, const Size ny, const Real sx, const Size nx)
	Numerical convolution solver for the LGM model. More...
Size	gridSize () const
std::vector< Real >	stateGrid (const Real t) const
template<typename ValueType = Real>
std::vector< ValueType >	rollback (const std::vector< ValueType > &v, const Real t1, const Real t0, const ValueType zero=ValueType(0.0)) const
const QuantLib::ext::shared_ptr< LinearGaussMarkovModel > &	model () const

Private Member Functions
void	calculate () const override

Private Attributes
const Handle< Quote >	minCpr_
const Handle< Quote >	maxCpr_

Additional Inherited Members
Public Types inherited from NumericLgmFlexiSwapEngineBase
enum class	Method { SwaptionArray , SingleSwaptions , Automatic }
Protected Member Functions inherited from NumericLgmFlexiSwapEngineBase
std::pair< Real, Real >	calculate () const
Real	underlyingValue (const Real, const Real, const Date &, const Size, const Size, const Real, const Real) const
Protected Attributes inherited from NumericLgmFlexiSwapEngineBase
const Handle< YieldTermStructure >	discountCurve_
const Method	method_
const Real	singleSwaptionThreshold_
QuantLib::ext::shared_ptr< IborIndex >	iborModelIndex_
QuantLib::ext::shared_ptr< LgmImpliedYieldTermStructure >	iborModelCurve_
VanillaSwap::Type	type
std::vector< Real >	fixedNominal
std::vector< Real >	floatingNominal
std::vector< Date >	fixedResetDates
std::vector< Date >	fixedPayDates
std::vector< Time >	floatingAccrualTimes
std::vector< Date >	floatingResetDates
std::vector< Date >	floatingFixingDates
std::vector< Date >	floatingPayDates
std::vector< Real >	fixedCoupons
std::vector< Real >	fixedRate
std::vector< Real >	floatingGearings
std::vector< Real >	floatingSpreads
std::vector< Real >	cappedRate
std::vector< Real >	flooredRate
std::vector< Real >	floatingCoupons
QuantLib::ext::shared_ptr< IborIndex >	iborIndex
std::vector< Real >	lowerNotionalBound
QuantLib::Position::Type	optionPosition
std::vector< bool >	notionalCanBeDecreased

Detailed Description

Numerical engine for balance guaranteed swaps using a flexi swap proxy in the LGM model.

Two notional schedules are constructed using a simple prepayment model with rates minCpr and maxCpr. These two schedules define a lower / upper notional bounds of a flexi swap. The NPV of this flexi swap is by definition the NPV of the BGS itself.

The prepayment model assumes that prepayments amortise the tranches in the order of their seniority.

Notice that prepayments start in the first period of the tranche nominal schedule that has a start date that lies in the future. Therefore the tranche notionals in the BGS should contain past (known) prepayments already, only for future periods the notionals should be given under a zero CPR assumption.

Definition at line 42 of file numericlgmbgsflexiswapengine.hpp.

Constructor & Destructor Documentation

NumericLgmBgsFlexiSwapEngine()

NumericLgmBgsFlexiSwapEngine	(	const QuantLib::ext::shared_ptr< LinearGaussMarkovModel > &	model,
		const Real	sy,
		const Size	ny,
		const Real	sx,
		const Size	nx,
		const Handle< Quote > &	minCpr,
		const Handle< Quote > &	maxCpr,
		const Handle< YieldTermStructure > &	discountCurve = Handle<YieldTermStructure>(),
		const Method	method = Method::Automatic,
		const Real	singleSwaptionThreshold = 20.0
	)

Definition at line 25 of file numericlgmbgsflexiswapengine.cpp.

    : NumericLgmFlexiSwapEngineBase(model, sy, ny, sx, nx, discountCurve, method, singleSwaptionThreshold),
      minCpr_(minCpr), maxCpr_(maxCpr) {
    registerWith(this->model());
    registerWith(discountCurve_);
    registerWith(minCpr_);
    registerWith(maxCpr_);
} // NumericLgmFlexiSwapEngine::NumericLgmFlexiSwapEngine

Here is the call graph for this function:

Member Function Documentation

calculate()

void calculate ( ) const

overrideprivate

Definition at line 50 of file numericlgmbgsflexiswapengine.cpp.

                                                   {
    Date today = Settings::instance().evaluationDate();
    // compute the lower and upper notionals bounds, in terms of the tranche notional schedule
    Real currentLowerNotionalAfterPrepayment = 0.0, currentUpperNotionalAfterPrepayment = 0.0,
         lastAggregatePrincipal = 0.0;
    std::vector<Real> tmpLowerNotionalBound, tmpUpperNotionalBound;
    Real effectiveMinCpr = minCpr_->value() / static_cast<Real>(arguments_.trancheNominalFrequency);
    Real effectiveMaxCpr = maxCpr_->value() / static_cast<Real>(arguments_.trancheNominalFrequency);
    for (Size i = 0; i < arguments_.trancheNominalDates.size() - 1; ++i) {
        Real aggregatePrincipal = 0.0;
        for (Size j = 0; j < arguments_.trancheNominals.size(); ++j)
            aggregatePrincipal += arguments_.trancheNominals[j][i];
        if (i == 0) {
            // in the first period we do not have a prepayment
            currentUpperNotionalAfterPrepayment = aggregatePrincipal;
            currentLowerNotionalAfterPrepayment = aggregatePrincipal;
        }
        if (i > 0) {
            // ratio of zero-cpr notionals
            Real amortisationRate =
                QuantLib::close_enough(aggregatePrincipal, 0.0) ? 0.0 : (aggregatePrincipal / lastAggregatePrincipal);
            // we only prepay if the start date of the nominal is in the future
            currentUpperNotionalAfterPrepayment =
                currentUpperNotionalAfterPrepayment *
                std::max(amortisationRate - (arguments_.trancheNominalDates[i] > today ? effectiveMinCpr : 0.0), 0.0);
            currentLowerNotionalAfterPrepayment =
                currentLowerNotionalAfterPrepayment *
                std::max(amortisationRate - (arguments_.trancheNominalDates[i] > today ? effectiveMaxCpr : 0.0), 0.0);
        }
        // now that we have the current notional of the period we can determine the swap notional
        // for this, we subtract the notionals of all tranches which are less senior...
        Real subordinatedPrincipal = 0;
        for (Size k = arguments_.trancheNominals.size() - 1; k > arguments_.referencedTranche; --k) {
            subordinatedPrincipal += arguments_.trancheNominals[k][i];
        }
        // and then cap the result at the referenced tranche's volume and floor it at zero
        tmpLowerNotionalBound.push_back(
            std::min(std::max(currentLowerNotionalAfterPrepayment - subordinatedPrincipal, 0.0),
                     arguments_.trancheNominals[arguments_.referencedTranche][i]));
        tmpUpperNotionalBound.push_back(
            std::min(std::max(currentUpperNotionalAfterPrepayment - subordinatedPrincipal, 0.0),
                     arguments_.trancheNominals[arguments_.referencedTranche][i]));
        // update the aggregate principal for the next period
        lastAggregatePrincipal = aggregatePrincipal;
    }
 
    // convert the bounds to notional vectors for the fixed and floating schedule
    std::vector<Real> lowerNotionalFixedBound, upperNotionalFixedBound, upperNotionalFloatingBound;
    for (Size i = 0; i < arguments_.fixedResetDates.size(); ++i) {
        lowerNotionalFixedBound.push_back(
            getNotional(tmpLowerNotionalBound, arguments_.trancheNominalDates, arguments_.fixedResetDates[i]));
        upperNotionalFixedBound.push_back(
            getNotional(tmpUpperNotionalBound, arguments_.trancheNominalDates, arguments_.fixedResetDates[i]));
    }
    // derive floating nominal schedule from fixed to ensure they match
    Size ratio =
        arguments_.floatingResetDates.size() / arguments_.fixedResetDates.size(); // we know there is no remainder
    upperNotionalFloatingBound.resize(upperNotionalFixedBound.size() * ratio);
    Size i = 0; // remove in C++14 and instead write [i=0, &fixedNotional] in the capture below
    std::generate(upperNotionalFloatingBound.begin(), upperNotionalFloatingBound.end(),
                  [i, &upperNotionalFixedBound, ratio]() mutable { return upperNotionalFixedBound[i++ / ratio]; });
 
    // recalculate the fixed and floating coupons belonging to the upper Notional
    std::vector<Real> upperFixedCoupons, upperFloatingCoupons;
    for (Size i = 0; i < arguments_.fixedLeg.size(); ++i) {
        auto cp = QuantLib::ext::dynamic_pointer_cast<QuantLib::Coupon>(arguments_.fixedLeg[i]);
        upperFixedCoupons.push_back(cp->accrualPeriod() * cp->rate() * upperNotionalFixedBound[i]);
    }
    for (Size i = 0; i < arguments_.floatingLeg.size(); ++i) {
        auto cp = QuantLib::ext::dynamic_pointer_cast<QuantLib::Coupon>(arguments_.floatingLeg[i]);
        try {
            upperFloatingCoupons.push_back(cp->accrualPeriod() * cp->rate() * upperNotionalFloatingBound[i]);
        } catch (...) {
            upperFloatingCoupons.push_back(Null<Real>());
        }
    }
 
    // determine the option position, the holder is the payer of the structured (i.e. fixed) leg
    QuantLib::Position::Type flexiOptionPosition =
        arguments_.type == VanillaSwap::Payer ? QuantLib::Position::Long : QuantLib::Position::Short;
 
    // set arguments in base engine
    type = arguments_.type;
    fixedNominal = upperNotionalFixedBound;       // computed above
    floatingNominal = upperNotionalFloatingBound; // computed above
    fixedResetDates = arguments_.fixedResetDates;
    fixedPayDates = arguments_.fixedPayDates;
    floatingAccrualTimes = arguments_.floatingAccrualTimes;
    floatingResetDates = arguments_.floatingResetDates;
    floatingFixingDates = arguments_.floatingFixingDates;
    floatingPayDates = arguments_.floatingPayDates;
    fixedCoupons = upperFixedCoupons;
    fixedRate = arguments_.fixedRate;
    floatingGearings = arguments_.floatingGearings;
    floatingSpreads = arguments_.floatingSpreads;
    cappedRate = arguments_.cappedRate;
    flooredRate = arguments_.flooredRate;
    floatingCoupons = upperFloatingCoupons;
    iborIndex = arguments_.iborIndex;
    lowerNotionalBound = lowerNotionalFixedBound; // computed above
    optionPosition = flexiOptionPosition;         // computed above
    notionalCanBeDecreased =
        std::vector<bool>(fixedNominal.size(), true); // each period is eligable for notional decrease
 
    // calculate and set results
    auto result = NumericLgmFlexiSwapEngineBase::calculate();
    results_.value = result.first;
    results_.additionalResults = getAdditionalResultsMap(model()->getCalibrationInfo());
} // NumericLgmBgsFlexiSwapEngine::calculate

Here is the call graph for this function:

Member Data Documentation

minCpr_

const Handle<Quote> minCpr_

private

Definition at line 53 of file numericlgmbgsflexiswapengine.hpp.

maxCpr_

const Handle<Quote> maxCpr_

private

Definition at line 53 of file numericlgmbgsflexiswapengine.hpp.