#include <qle/cashflows/durationadjustedcmscoupontsrpricer.hpp>

Inheritance diagram for DurationAdjustedCmsCouponTsrPricer:

Collaboration diagram for DurationAdjustedCmsCouponTsrPricer:

Public Member Functions
	DurationAdjustedCmsCouponTsrPricer (const Handle< SwaptionVolatilityStructure > &swaptionVol, const QuantLib::ext::shared_ptr< AnnuityMappingBuilder > &annuityMappingBuilder, const Real lowerIntegrationBound=-0.3, const Real upperIntegrationBound=0.3, const QuantLib::ext::shared_ptr< Integrator > &integrator=QuantLib::ext::shared_ptr< Integrator >())

Real	swapletPrice () const override

Rate	swapletRate () const override

Real	capletPrice (Rate effectiveCap) const override

Rate	capletRate (Rate effectiveCap) const override

Real	floorletPrice (Rate effectiveFloor) const override

Rate	floorletRate (Rate effectiveFloor) const override

Private Member Functions
void	initialize (const FloatingRateCoupon &coupon) override

Real	optionletRate (Option::Type type, Real effectiveStrike) const

Private Attributes
QuantLib::ext::shared_ptr< AnnuityMappingBuilder >	annuityMappingBuilder_

Real	lowerIntegrationBound_

Real	upperIntegrationBound_

QuantLib::ext::shared_ptr< Integrator >	integrator_

const DurationAdjustedCmsCoupon *	coupon_

Date	today_

Real	swapRate_

Real	durationAdjustment_

Real	forwardAnnuity_

QuantLib::ext::shared_ptr< SmileSection >	smileSection_

QuantLib::ext::shared_ptr< AnnuityMapping >	annuityMapping_

Detailed Description

Definition at line 39 of file durationadjustedcmscoupontsrpricer.hpp.

Constructor & Destructor Documentation

◆ DurationAdjustedCmsCouponTsrPricer()

DurationAdjustedCmsCouponTsrPricer	(	const Handle< SwaptionVolatilityStructure > &	swaptionVol,
		const QuantLib::ext::shared_ptr< AnnuityMappingBuilder > &	annuityMappingBuilder,
		const Real	lowerIntegrationBound = `-0.3`,
		const Real	upperIntegrationBound = `0.3`,
		const QuantLib::ext::shared_ptr< Integrator > &	integrator = `QuantLib::ext::shared_ptr<Integrator>()`
	)

Definition at line 37 of file durationadjustedcmscoupontsrpricer.cpp.

    : CmsCouponPricer(swaptionVol), annuityMappingBuilder_(annuityMappingBuilder),
      lowerIntegrationBound_(lowerIntegrationBound), upperIntegrationBound_(upperIntegrationBound),
      integrator_(integrator) {
    if (integrator_ == nullptr)
        integrator_ = ext::make_shared<GaussKronrodNonAdaptive>(1E-10, 5000, 1E-10);
    if (annuityMappingBuilder_ != nullptr)
        registerWith(annuityMappingBuilder_);
}

Member Function Documentation

◆ swapletPrice()

Real swapletPrice ( ) const

override

Definition at line 50 of file durationadjustedcmscoupontsrpricer.cpp.

                                                            {
    QL_FAIL("DurationAdjustedCmsCouponTsrPricer::swapletPrice() is not implemented");
}

◆ swapletRate()

Rate swapletRate ( ) const

override

Definition at line 62 of file durationadjustedcmscoupontsrpricer.cpp.

                                                           {
    return capletRate(swapRate_) - floorletRate(swapRate_) +
           (coupon_->gearing() * swapRate_ + coupon_->spread()) * durationAdjustment_;
}

Here is the call graph for this function:

◆ capletPrice()

Real capletPrice ( Rate effectiveCap ) const

override

Definition at line 54 of file durationadjustedcmscoupontsrpricer.cpp.

                                                                            {
    QL_FAIL("DurationAdjustedCmsCouponTsrPricer::swapletPrice() is not implemented");
}

◆ capletRate()

Rate capletRate ( Rate effectiveCap ) const

override

Definition at line 67 of file durationadjustedcmscoupontsrpricer.cpp.

                                                                           {
    if (coupon_->fixingDate() <= today_) {
        return durationAdjustment_ * coupon_->gearing() * std::max(swapRate_ - effectiveCap, 0.0);
    } else {
        return durationAdjustment_ * coupon_->gearing() * optionletRate(Option::Call, effectiveCap);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ floorletPrice()

Real floorletPrice ( Rate effectiveFloor ) const

override

Definition at line 58 of file durationadjustedcmscoupontsrpricer.cpp.

                                                                                {
    QL_FAIL("DurationAdjustedCmsCouponTsrPricer::swapletPrice() is not implemented");
}

◆ floorletRate()

Rate floorletRate ( Rate effectiveFloor ) const

override

Definition at line 75 of file durationadjustedcmscoupontsrpricer.cpp.

                                                                               {
    if (coupon_->fixingDate() <= today_) {
        return durationAdjustment_ * coupon_->gearing() * std::max(effectiveFloor - swapRate_, 0.0);
    } else {
        return durationAdjustment_ * coupon_->gearing() * optionletRate(Option::Put, effectiveFloor);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ initialize()

void initialize ( const FloatingRateCoupon & coupon )

overrideprivate

Definition at line 83 of file durationadjustedcmscoupontsrpricer.cpp.

                                                                                    {
 
    coupon_ = dynamic_cast<const DurationAdjustedCmsCoupon*>(&coupon);
    QL_REQUIRE(coupon_, "DurationAdjustedCmsCoupon needed");
    today_ = QuantLib::Settings::instance().evaluationDate();
    durationAdjustment_ = coupon_->durationAdjustment();
 
    if (coupon_->fixingDate() > today_) {
        Handle<YieldTermStructure> discountCurve;
        if (coupon_->swapIndex()->exogenousDiscount())
            discountCurve = coupon_->swapIndex()->discountingTermStructure();
        else
            discountCurve = coupon_->swapIndex()->forwardingTermStructure();
        auto swap = coupon_->swapIndex()->underlyingSwap(coupon_->fixingDate());
        swapRate_ = swap->fairRate();
        forwardAnnuity_ = 1.0E4 * std::fabs(swap->fixedLegBPS()) / discountCurve->discount(coupon_->date());
        smileSection_ = swaptionVolatility()->smileSection(coupon_->fixingDate(), coupon_->swapIndex()->tenor());
        // if the smile section does not have an ATM level, we add one
        if (smileSection_->atmLevel() == Null<Real>())
            smileSection_ = ext::make_shared<AtmSmileSection>(smileSection_, swapRate_);
        annuityMapping_ =
            annuityMappingBuilder_->build(today_, coupon_->fixingDate(), coupon_->date(), *swap, discountCurve);
    } else {
        swapRate_ = coupon_->swapIndex()->fixing(coupon_->fixingDate());
    }
}

Here is the call graph for this function:

◆ optionletRate()

Real optionletRate	(	Option::Type	type,
		Real	effectiveStrike
	)		const

private

Definition at line 110 of file durationadjustedcmscoupontsrpricer.cpp.

                                                                                               {
 
    Real effectiveLowerIntegrationBound = lowerIntegrationBound_;
    Real effectiveUpperIntegrationBound = upperIntegrationBound_;
 
    // adjust the lower integration bound if the vol type is lognormal
 
    if (swaptionVolatility()->volatilityType() == ShiftedLognormal) {
        effectiveLowerIntegrationBound = std::max(
            lowerIntegrationBound_, -swaptionVolatility()->shift(coupon_->fixingDate(), coupon_->swapIndex()->tenor()));
    }
 
    // the payoff function and its 1st and 2nd derivatives vanish for arguments > strike (call) resp. < strike (put)
 
    if (optionType == Option::Call)
        effectiveLowerIntegrationBound = std::max(effectiveLowerIntegrationBound, strike);
    else
        effectiveUpperIntegrationBound = std::min(effectiveUpperIntegrationBound, strike);
 
    Real integral = 0.0;
    Real omega = optionType == Option::Call ? 1.0 : -1.0;
 
    // compute the relevant integral
 
    if (effectiveLowerIntegrationBound < effectiveUpperIntegrationBound &&
        !close_enough(effectiveLowerIntegrationBound, effectiveUpperIntegrationBound)) {
 
        auto f = [this, strike, omega](const Real S) -> Real {
            return std::max(omega * (S - strike), 0.0) * this->durationAdjustment_;
        };
 
        auto fp = [this, strike, omega](const Real S) -> Real {
            if (this->coupon_->duration() == 0) {
                return omega * (omega * S > omega * strike ? 1.0 : 0.0);
            } else {
                Real dp = 0.0;
                for (Size i = 0; i < this->coupon_->duration(); ++i) {
                    dp -= static_cast<Real>(i + 1) / std::pow(1.0 + this->swapRate_, i + 2);
                }
                return this->durationAdjustment_ * omega * (omega * S > omega * strike ? 1.0 : 0.0) +
                       dp * std::max(omega * (S - strike), 0.0);
            }
        };
 
        auto fpp = [this, strike, omega](const Real S) -> Real {
            if (this->coupon_->duration() == 0) {
                return 0.0;
            } else {
                Real dp1 = 0.0, dp2 = 0.0;
                for (Size i = 0; i < this->coupon_->duration(); ++i) {
                    dp1 -= static_cast<Real>(i + 1) / std::pow(1.0 + this->swapRate_, i + 2);
                    dp2 += static_cast<Real>(i + 1) * static_cast<Real>(i + 2) / std::pow(1.0 + this->swapRate_, i + 3);
                }
                return dp1 * omega * (omega * S > omega * strike ? 1.0 : 0.0) +
                       dp2 * std::max(omega * (S - strike), 0.0);
            }
        };
 
        auto integrand = [this, &f, &fp, &fpp](const Real S) -> Real {
            Real f2 = 0.0;
            if (this->coupon_->duration() != 0) {
                f2 = this->annuityMapping_->map(S) * fpp(S);
            }
            Real f1 = 2.0 * fp(S) * this->annuityMapping_->mapPrime(S);
            Real f0 = 0.0;
            if (!this->annuityMapping_->mapPrime2IsZero())
                f0 = annuityMapping_->mapPrime2(S) * f(S);
            return (f0 + f1 + f2) * this->smileSection_->optionPrice(S, S < swapRate_ ? Option::Put : Option::Call);
        };
 
        // calculate two integrals up to and from the fair swap rate => is that better than a single integral?
        Real tmpBound;
        tmpBound = std::min(effectiveUpperIntegrationBound, swapRate_);
        if (tmpBound > effectiveLowerIntegrationBound)
            integral += (*integrator_)(integrand, effectiveLowerIntegrationBound, tmpBound);
        tmpBound = std::max(effectiveLowerIntegrationBound, swapRate_);
        if (effectiveUpperIntegrationBound > tmpBound)
            integral += (*integrator_)(integrand, tmpBound, effectiveUpperIntegrationBound);
 
        integral = (*integrator_)(integrand, effectiveLowerIntegrationBound, effectiveUpperIntegrationBound);
    }
 
    // add payoff function * annuityMapping at fair swap rate and Dirac delta contributions from integral
 
    Real singularTerms =
        annuityMapping_->map(swapRate_) * durationAdjustment_ * std::max(omega * (swapRate_ - strike), 0.0) +
        annuityMapping_->map(strike) * durationAdjustment_ *
            smileSection_->optionPrice(strike, strike < swapRate_ ? Option::Put : Option::Call);
 
    return forwardAnnuity_ * (integral + singularTerms) / durationAdjustment_;
}