8391917148

Committed 22 Mar 2024 02:31PM UTC coverage: 72.481% (-0.001%) from 72.482%

Build # 8391917148

Build Type

push

github

Committed by

web-flow

Commit Message

LinearTsrPricer: fix past payment dates, support overnight swap indices, add missing include (#1775)

Run Details

16 of 22 new or added lines in 1 file covered. (72.73%)

2 existing lines in 1 file now uncovered.

54920 of 75772 relevant lines covered (72.48%)

8590713.19 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

63.73

/ql/cashflows/lineartsrpricer.cpp

/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/*
  Copyright (C) 2014, 2016 Peter Caspers

  This file is part of QuantLib, a free-software/open-source library
  for financial quantitative analysts and developers - http://quantlib.org/

  QuantLib is free software: you can redistribute it and/or modify it
  under the terms of the QuantLib license.  You should have received a
  copy of the license along with this program; if not, please email
  <quantlib-dev@lists.sf.net>. The license is also available online at
  <http://quantlib.org/license.shtml>.


  This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  or FITNESS FOR A PARTICULAR PURPOSE. See the license for more details.
*/

/*! \file lineartsrpricer.cpp
*/

#include <ql/cashflows/cmscoupon.hpp>
#include <ql/cashflows/fixedratecoupon.hpp>
#include <ql/cashflows/iborcoupon.hpp>
#include <ql/cashflows/lineartsrpricer.hpp>
#include <ql/indexes/iborindex.hpp>
#include <ql/instruments/vanillaswap.hpp>
#include <ql/instruments/overnightindexedswap.hpp>
#include <ql/math/integrals/kronrodintegral.hpp>
#include <ql/math/solvers1d/brent.hpp>
#include <ql/pricingengines/blackformula.hpp>
#include <ql/quotes/simplequote.hpp>
#include <ql/termstructures/volatility/atmsmilesection.hpp>
#include <ql/termstructures/yieldtermstructure.hpp>
#include <ql/time/schedule.hpp>
#include <utility>

namespace QuantLib {

    class LinearTsrPricer::integrand_f {
        const LinearTsrPricer* pricer;
      public:
        explicit integrand_f(const LinearTsrPricer* pricer) : pricer(pricer) {}
        Real operator()(Real x) const {
            return pricer->integrand(x);
        }
    };

    const Real LinearTsrPricer::defaultLowerBound = 0.0001,
             LinearTsrPricer::defaultUpperBound = 2.0000;

    LinearTsrPricer::LinearTsrPricer(const Handle<SwaptionVolatilityStructure>& swaptionVol,
                                     Handle<Quote> meanReversion,
                                     Handle<YieldTermStructure> couponDiscountCurve,
                                     const Settings& settings,
                                     ext::shared_ptr<Integrator> integrator)
    : CmsCouponPricer(swaptionVol), meanReversion_(std::move(meanReversion)),
      couponDiscountCurve_(std::move(couponDiscountCurve)), settings_(settings),
      volDayCounter_(swaptionVol->dayCounter()), integrator_(std::move(integrator)) {

        if (!couponDiscountCurve_.empty())
            registerWith(couponDiscountCurve_);

        if (integrator_ == nullptr)
            integrator_ =
                ext::make_shared<GaussKronrodNonAdaptive>(1E-10, 5000, 1E-10);
    }

    Real LinearTsrPricer::GsrG(const Date &d) const {

        Real yf = volDayCounter_.yearFraction(fixingDate_, d);
        if (std::fabs(meanReversion_->value()) < 1.0E-4)
            return yf;
        else
            return (1.0 - std::exp(-meanReversion_->value() * yf)) /
                   meanReversion_->value();
    }

    Real LinearTsrPricer::singularTerms(const Option::Type type,
                                        const Real strike) const {

        Real omega = (type == Option::Call ? 1.0 : -1.0);
        Real s1 = std::max(omega * (swapRateValue_ - strike), 0.0) *
                  (a_ * swapRateValue_ + b_);
        Real s2 = (a_ * strike + b_) *
                  smileSection_->optionPrice(strike, strike < swapRateValue_
                                                         ? Option::Put
                                                         : Option::Call);
        return s1 + s2;
    }

    Real LinearTsrPricer::integrand(const Real strike) const {
        return 2.0 * a_ * smileSection_->optionPrice(
                              strike, strike < swapRateValue_ ? Option::Put
                                                              : Option::Call);
    }

    void LinearTsrPricer::initialize(const FloatingRateCoupon &coupon) {

        coupon_ = dynamic_cast<const CmsCoupon *>(&coupon);
        QL_REQUIRE(coupon_, "CMS coupon needed");
        gearing_ = coupon_->gearing();
        spread_ = coupon_->spread();

        fixingDate_ = coupon_->fixingDate();
        paymentDate_ = coupon_->date();
        swapIndex_ = coupon_->swapIndex();

        forwardCurve_ = swapIndex_->forwardingTermStructure();
        if (swapIndex_->exogenousDiscount())
            discountCurve_ = swapIndex_->discountingTermStructure();
        else
            discountCurve_ = forwardCurve_;

        // if no coupon discount curve is given just use the discounting curve
        // from the swap index. for rate calculation this curve cancels out in
        // the computation, so e.g. the discounting swap engine will produce
        // correct results, even if the couponDiscountCurve is not set here.
        // only the price member function in this class will be dependent on the
        // coupon discount curve.

        today_ = QuantLib::Settings::instance().evaluationDate();

        Real couponCurvePaymentDiscount;
        if (!couponDiscountCurve_.empty() && paymentDate_ > couponDiscountCurve_->referenceDate()) {
            couponCurvePaymentDiscount = couponDiscountCurve_->discount(paymentDate_);
        } else {
            couponCurvePaymentDiscount = 1.0;
        }

        if (paymentDate_ > discountCurve_->referenceDate()) {
            discountCurvePaymentDiscount_ = discountCurve_->discount(paymentDate_);
        } else {
            discountCurvePaymentDiscount_ = 1.0;
        }


        couponDiscountRatio_ = couponCurvePaymentDiscount / discountCurvePaymentDiscount_;

        spreadLegValue_ = spread_ * coupon_->accrualPeriod() * discountCurvePaymentDiscount_ *
                          couponDiscountRatio_;

        if (fixingDate_ > today_) {

            swapTenor_ = swapIndex_->tenor();

            if (auto on = ext::dynamic_pointer_cast<OvernightIndexedSwapIndex>(swapIndex_)) {
                swap_ = on->underlyingSwap(fixingDate_);
            } else {
                swap_ = swapIndex_->underlyingSwap(fixingDate_);
            }
            swapRateValue_ = swap_->fairRate();
            annuity_ = 1.0E4 * std::fabs(swap_->fixedLegBPS());
            Leg swapFixedLeg = swap_->fixedLeg();

            ext::shared_ptr<SmileSection> sectionTmp =
                swaptionVolatility()->smileSection(fixingDate_, swapTenor_);

            adjustedLowerBound_ = settings_.lowerRateBound_;
            adjustedUpperBound_ = settings_.upperRateBound_;

            if(sectionTmp->volatilityType() == Normal) {
                // adjust lower bound if it was not set explicitly
                if(settings_.defaultBounds_)
                    adjustedLowerBound_ = std::min(adjustedLowerBound_, -adjustedUpperBound_);
            } else {
                // adjust bounds by section's shift
                adjustedLowerBound_ -= sectionTmp->shift();
                adjustedUpperBound_ -= sectionTmp->shift();
            }

            // if the section does not provide an atm level, we enhance it to
            // have one, no need to exit with an exception ...

            if (sectionTmp->atmLevel() == Null<Real>())
                smileSection_ = ext::make_shared<AtmSmileSection>(
                    sectionTmp, swapRateValue_);
            else
                smileSection_ = sectionTmp;

            // compute linear model's parameters

            Real gx = 0.0, gy = 0.0;
            for (const auto& i : swapFixedLeg) {
                ext::shared_ptr<Coupon> c = ext::dynamic_pointer_cast<Coupon>(i);
                Real yf = c->accrualPeriod();
                Date d = c->date();
                Real pv = yf * discountCurve_->discount(d);
                gx += pv * GsrG(d);
                gy += pv;
            }

            Real gamma = gx / gy;
            Date lastd = swapFixedLeg.back()->date();

            a_ = discountCurve_->discount(paymentDate_) *
                 (gamma - GsrG(paymentDate_)) /
                 (discountCurve_->discount(lastd) * GsrG(lastd) +
                  swapRateValue_ * gy * gamma);

            b_ = discountCurve_->discount(paymentDate_) / gy -
                 a_ * swapRateValue_;
        }
    }

    Real LinearTsrPricer::strikeFromVegaRatio(Real ratio,
                                              Option::Type optionType,
                                              Real referenceStrike) const {

        Real a, b, min, max, k;
        if (optionType == Option::Call) {
            a = swapRateValue_;
            min = referenceStrike;
            // NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
            b = max = k =
                std::min(smileSection_->maxStrike(), adjustedUpperBound_);
        } else {
            // NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
            a = min = k =
                std::max(smileSection_->minStrike(), adjustedLowerBound_);
            b = swapRateValue_;
            max = referenceStrike;
        }

        VegaRatioHelper h(&*smileSection_,
                          smileSection_->vega(swapRateValue_) * ratio);
        Brent solver;

        try {
            k = solver.solve(h, 1.0E-5, (a + b) / 2.0, a, b);
        }
        catch (...) {
            // use default value set above
        }

        return std::min(std::max(k, min), max);
    }

    Real LinearTsrPricer::strikeFromPrice(Real price, Option::Type optionType,
                                          Real referenceStrike) const {

        Real a, b, min, max, k;
        if (optionType == Option::Call) {
            a = swapRateValue_;
            min = referenceStrike;
            // NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
            b = max = k =
                std::min(smileSection_->maxStrike(), adjustedUpperBound_);
        } else {
            // NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
            a = min = k =
                std::max(smileSection_->minStrike(), adjustedLowerBound_);
            b = swapRateValue_;
            max = referenceStrike;
        }

        PriceHelper h(&*smileSection_, optionType, price);
        Brent solver;

        try {
            k = solver.solve(h, 1.0E-5, swapRateValue_, a, b);
        }
        catch (...) {
            // use default value set above
        }

        return std::min(std::max(k, min), max);
    }

    Real LinearTsrPricer::optionletPrice(Option::Type optionType,
                                         Real strike) const {

        if (optionType == Option::Call && strike >= adjustedUpperBound_)
            return 0.0;
        if (optionType == Option::Put && strike <= adjustedLowerBound_)
            return 0.0;

        // determine lower or upper integration bound (depending on option type)

        Real lower = strike, upper = strike;

        switch (settings_.strategy_) {

        case Settings::RateBound: {
            if (optionType == Option::Call)
                upper = adjustedUpperBound_;
            else
                lower = adjustedLowerBound_;
            break;
        }

        case Settings::VegaRatio: {
            // strikeFromVegaRatio ensures that returned strike is on the
            // expected side of strike
            Real bound =
                strikeFromVegaRatio(settings_.vegaRatio_, optionType, strike);
            if (optionType == Option::Call)
                upper = std::min(bound, adjustedUpperBound_);
            else
                lower = std::max(bound, adjustedLowerBound_);
            break;
        }

        case Settings::PriceThreshold: {
            // strikeFromPrice ensures that returned strike is on the expected
            // side of strike
            Real bound =
                strikeFromPrice(settings_.vegaRatio_, optionType, strike);
            if (optionType == Option::Call)
                upper = std::min(bound, adjustedUpperBound_);
            else
                lower = std::max(bound, adjustedLowerBound_);
            break;
        }

        case Settings::BSStdDevs : {
            Real atm = smileSection_->atmLevel();
            Real atmVol = smileSection_->volatility(atm);
            Real shift = smileSection_->shift();
            Real lowerTmp, upperTmp;
            if (smileSection_->volatilityType() == ShiftedLognormal) {
                upperTmp = (atm + shift) *
                               std::exp(settings_.stdDevs_ * atmVol -
                                        0.5 * atmVol * atmVol *
                                            smileSection_->exerciseTime()) -
                           shift;
                lowerTmp = (atm + shift) *
                               std::exp(-settings_.stdDevs_ * atmVol -
                                        0.5 * atmVol * atmVol *
                                            smileSection_->exerciseTime()) -
                           shift;
            } else {
                Real tmp = settings_.stdDevs_ * atmVol *
                           std::sqrt(smileSection_->exerciseTime());
                upperTmp = atm + tmp;
                lowerTmp = atm - tmp;
            }
            upper = std::min(upperTmp - shift, adjustedUpperBound_);
            lower = std::max(lowerTmp - shift, adjustedLowerBound_);
            break;
        }

        default:
            QL_FAIL("Unknown strategy (" << settings_.strategy_ << ")");
        }

        // compute the relevant integral

        Real result = 0.0;
        Real tmpBound;
        if (upper > lower) {
            tmpBound = std::min(upper, swapRateValue_);
            if (tmpBound > lower) {
                result += (*integrator_)(integrand_f(this),
                                         lower, tmpBound);
            }
            tmpBound = std::max(lower, swapRateValue_);
            if (upper > tmpBound) {
                result += (*integrator_)(integrand_f(this),
                                         tmpBound, upper);
            }
            result *= (optionType == Option::Call ? 1.0 : -1.0);
        }

        result += singularTerms(optionType, strike);

        return annuity_ * result * couponDiscountRatio_ *
               coupon_->accrualPeriod();
    }

    Real LinearTsrPricer::meanReversion() const { return meanReversion_->value(); }

    Rate LinearTsrPricer::swapletRate() const {
        return swapletPrice() /
               (coupon_->accrualPeriod() * discountCurvePaymentDiscount_ * couponDiscountRatio_);
    }

    Real LinearTsrPricer::capletPrice(Rate effectiveCap) const {
        // caplet is equivalent to call option on fixing
        if (fixingDate_ <= today_) {
            // the fixing is determined
            const Rate Rs = std::max(
                coupon_->swapIndex()->fixing(fixingDate_) - effectiveCap, 0.);
            Rate price = (gearing_ * Rs) * (coupon_->accrualPeriod() *
                                            discountCurvePaymentDiscount_ * couponDiscountRatio_);
            return price;
        } else {
            Real capletPrice = optionletPrice(Option::Call, effectiveCap);
            return gearing_ * capletPrice;
        }
    }

    Rate LinearTsrPricer::capletRate(Rate effectiveCap) const {
        return capletPrice(effectiveCap) /
               (coupon_->accrualPeriod() * discountCurvePaymentDiscount_ * couponDiscountRatio_);
    }

    Real LinearTsrPricer::floorletPrice(Rate effectiveFloor) const {
        // floorlet is equivalent to put option on fixing
        if (fixingDate_ <= today_) {
            // the fixing is determined
            const Rate Rs = std::max(
                effectiveFloor - coupon_->swapIndex()->fixing(fixingDate_), 0.);
            Rate price = (gearing_ * Rs) * (coupon_->accrualPeriod() *
                                            discountCurvePaymentDiscount_ * couponDiscountRatio_);
            return price;
        } else {
            Real floorletPrice = optionletPrice(Option::Put, effectiveFloor);
            return gearing_ * floorletPrice;
        }
    }

    Rate LinearTsrPricer::floorletRate(Rate effectiveFloor) const {
        return floorletPrice(effectiveFloor) /
               (coupon_->accrualPeriod() * discountCurvePaymentDiscount_ * couponDiscountRatio_);
    }

    Real LinearTsrPricer::swapletPrice() const {
        if (fixingDate_ <= today_) {
            // the fixing is determined
            const Rate Rs = coupon_->swapIndex()->fixing(fixingDate_);
            Rate price =
                (gearing_ * Rs + spread_) *
                (coupon_->accrualPeriod() * discountCurvePaymentDiscount_ * couponDiscountRatio_);
            return price;
        } else {
            Real atmCapletPrice = optionletPrice(Option::Call, swapRateValue_);
            Real atmFloorletPrice = optionletPrice(Option::Put, swapRateValue_);
            return gearing_ * (coupon_->accrualPeriod() * discountCurvePaymentDiscount_ *
                                   swapRateValue_ * couponDiscountRatio_ +
                               atmCapletPrice - atmFloorletPrice) +
                   spreadLegValue_;
        }
    }
}

1	/* -- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -- */
2
3	/*
4	Copyright (C) 2014, 2016 Peter Caspers
5
6	This file is part of QuantLib, a free-software/open-source library
7	for financial quantitative analysts and developers - http://quantlib.org/
8
9	QuantLib is free software: you can redistribute it and/or modify it
10	under the terms of the QuantLib license. You should have received a
11	copy of the license along with this program; if not, please email
12	<quantlib-dev@lists.sf.net>. The license is also available online at
13	<http://quantlib.org/license.shtml>.
14
15
16	This program is distributed in the hope that it will be useful, but
17	WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
18	or FITNESS FOR A PARTICULAR PURPOSE. See the license for more details.
19	*/
20
21	/*! \file lineartsrpricer.cpp
22	*/
23
24	#include <ql/cashflows/cmscoupon.hpp>
25	#include <ql/cashflows/fixedratecoupon.hpp>
26	#include <ql/cashflows/iborcoupon.hpp>
27	#include <ql/cashflows/lineartsrpricer.hpp>
28	#include <ql/indexes/iborindex.hpp>
29	#include <ql/instruments/vanillaswap.hpp>
30	#include <ql/instruments/overnightindexedswap.hpp>
31	#include <ql/math/integrals/kronrodintegral.hpp>
32	#include <ql/math/solvers1d/brent.hpp>
33	#include <ql/pricingengines/blackformula.hpp>
34	#include <ql/quotes/simplequote.hpp>
35	#include <ql/termstructures/volatility/atmsmilesection.hpp>
36	#include <ql/termstructures/yieldtermstructure.hpp>
37	#include <ql/time/schedule.hpp>
38	#include <utility>
39
40	namespace QuantLib {
41
42	class LinearTsrPricer::integrand_f {
43	const LinearTsrPricer* pricer;
44	public:
45	explicit integrand_f(const LinearTsrPricer* pricer) : pricer(pricer) {}
46	Real operator()(Real x) const {
47	return pricer->integrand(x);	18,302✔
48	}
49	};
50
51	const Real LinearTsrPricer::defaultLowerBound = 0.0001,
52	LinearTsrPricer::defaultUpperBound = 2.0000;
53
54	LinearTsrPricer::LinearTsrPricer(const Handle<SwaptionVolatilityStructure>& swaptionVol,	10✔
55	Handle<Quote> meanReversion,
56	Handle<YieldTermStructure> couponDiscountCurve,
57	const Settings& settings,
58	ext::shared_ptr<Integrator> integrator)	10✔
59	: CmsCouponPricer(swaptionVol), meanReversion_(std::move(meanReversion)),
60	couponDiscountCurve_(std::move(couponDiscountCurve)), settings_(settings),	10✔
61	volDayCounter_(swaptionVol->dayCounter()), integrator_(std::move(integrator)) {	20✔
62
63	if (!couponDiscountCurve_.empty())
64	registerWith(couponDiscountCurve_);	12✔
65
66	if (integrator_ == nullptr)	10✔
67	integrator_ =
68	ext::make_shared<GaussKronrodNonAdaptive>(1E-10, 5000, 1E-10);	20✔
69	}	10✔
70
71	Real LinearTsrPricer::GsrG(const Date &d) const {	1,632✔
72
73	Real yf = volDayCounter_.yearFraction(fixingDate_, d);	1,632✔
74	if (std::fabs(meanReversion_->value()) < 1.0E-4)	1,632✔
75	return yf;
76	else
77	return (1.0 - std::exp(-meanReversion_->value() * yf)) /	348✔
78	meanReversion_->value();	348✔
79	}
80
81	Real LinearTsrPricer::singularTerms(const Option::Type type,	304✔
82	const Real strike) const {
83
84	Real omega = (type == Option::Call ? 1.0 : -1.0);	304✔
85	Real s1 = std::max(omega * (swapRateValue_ - strike), 0.0) *	304✔
86	(a_ * swapRateValue_ + b_);	304✔
87	Real s2 = (a_ * strike + b_) *	304✔
88	smileSection_->optionPrice(strike, strike < swapRateValue_	602✔
89	? Option::Put
90	: Option::Call);	304✔
91	return s1 + s2;	304✔
92	}
93
94	Real LinearTsrPricer::integrand(const Real strike) const {	18,302✔
95	return 2.0 * a_ * smileSection_->optionPrice(	36,604✔
96	strike, strike < swapRateValue_ ? Option::Put	18,302✔
97	: Option::Call);	18,302✔
98	}
99
100	void LinearTsrPricer::initialize(const FloatingRateCoupon &coupon) {	151✔
101
102	coupon_ = dynamic_cast<const CmsCoupon *>(&coupon);	151✔
103	QL_REQUIRE(coupon_, "CMS coupon needed");	151✔
104	gearing_ = coupon_->gearing();	151✔
105	spread_ = coupon_->spread();	151✔
106
107	fixingDate_ = coupon_->fixingDate();	151✔
108	paymentDate_ = coupon_->date();	151✔
109	swapIndex_ = coupon_->swapIndex();	151✔
110
111	forwardCurve_ = swapIndex_->forwardingTermStructure();	151✔
112	if (swapIndex_->exogenousDiscount())	151✔
113	discountCurve_ = swapIndex_->discountingTermStructure();	88✔
114	else
115	discountCurve_ = forwardCurve_;
116
117	// if no coupon discount curve is given just use the discounting curve
118	// from the swap index. for rate calculation this curve cancels out in
119	// the computation, so e.g. the discounting swap engine will produce
120	// correct results, even if the couponDiscountCurve is not set here.
121	// only the price member function in this class will be dependent on the
122	// coupon discount curve.
123
124	today_ = QuantLib::Settings::instance().evaluationDate();	151✔
125
126	Real couponCurvePaymentDiscount;
127	if (!couponDiscountCurve_.empty() && paymentDate_ > couponDiscountCurve_->referenceDate()) {	151✔
128	couponCurvePaymentDiscount = couponDiscountCurve_->discount(paymentDate_);	34✔
129	} else {
130	couponCurvePaymentDiscount = 1.0;
131	}
132
133	if (paymentDate_ > discountCurve_->referenceDate()) {	151✔
134	discountCurvePaymentDiscount_ = discountCurve_->discount(paymentDate_);	151✔
135	} else {
NEW 136	discountCurvePaymentDiscount_ = 1.0;	×
137	}
138
139
140	couponDiscountRatio_ = couponCurvePaymentDiscount / discountCurvePaymentDiscount_;	151✔
141
142	spreadLegValue_ = spread_ * coupon_->accrualPeriod() * discountCurvePaymentDiscount_ *	151✔
143	couponDiscountRatio_;	151✔
144
145	if (fixingDate_ > today_) {	151✔
146
147	swapTenor_ = swapIndex_->tenor();	146✔
148
149	if (auto on = ext::dynamic_pointer_cast<OvernightIndexedSwapIndex>(swapIndex_)) {	146✔
NEW 150	swap_ = on->underlyingSwap(fixingDate_);	×
151	} else {
152	swap_ = swapIndex_->underlyingSwap(fixingDate_);	292✔
153	}
154	swapRateValue_ = swap_->fairRate();	146✔
155	annuity_ = 1.0E4 * std::fabs(swap_->fixedLegBPS());	146✔
156	Leg swapFixedLeg = swap_->fixedLeg();	146✔
157
158	ext::shared_ptr<SmileSection> sectionTmp =
159	swaptionVolatility()->smileSection(fixingDate_, swapTenor_);	146✔
160
161	adjustedLowerBound_ = settings_.lowerRateBound_;	146✔
162	adjustedUpperBound_ = settings_.upperRateBound_;	146✔
163
164	if(sectionTmp->volatilityType() == Normal) {	146✔
165	// adjust lower bound if it was not set explicitly
166	if(settings_.defaultBounds_)	10✔
167	adjustedLowerBound_ = std::min(adjustedLowerBound_, -adjustedUpperBound_);	20✔
168	} else {
169	// adjust bounds by section's shift
170	adjustedLowerBound_ -= sectionTmp->shift();	136✔
171	adjustedUpperBound_ -= sectionTmp->shift();	136✔
172	}
173
174	// if the section does not provide an atm level, we enhance it to
175	// have one, no need to exit with an exception ...
176
177	if (sectionTmp->atmLevel() == Null<Real>())	146✔
178	smileSection_ = ext::make_shared<AtmSmileSection>(	134✔
179	sectionTmp, swapRateValue_);	134✔
180	else
181	smileSection_ = sectionTmp;	12✔
182
183	// compute linear model's parameters
184
185	Real gx = 0.0, gy = 0.0;
186	for (const auto& i : swapFixedLeg) {	1,486✔
187	ext::shared_ptr<Coupon> c = ext::dynamic_pointer_cast<Coupon>(i);	1,340✔
188	Real yf = c->accrualPeriod();	1,340✔
189	Date d = c->date();	1,340✔
190	Real pv = yf * discountCurve_->discount(d);	1,340✔
191	gx += pv * GsrG(d);	1,340✔
192	gy += pv;	1,340✔
193	}
194
195	Real gamma = gx / gy;	146✔
196	Date lastd = swapFixedLeg.back()->date();	146✔
197
198	a_ = discountCurve_->discount(paymentDate_) *	146✔
199	(gamma - GsrG(paymentDate_)) /	146✔
200	(discountCurve_->discount(lastd) * GsrG(lastd) +	146✔
201	swapRateValue_ * gy * gamma);	146✔
202
203	b_ = discountCurve_->discount(paymentDate_) / gy -	146✔
204	a_ * swapRateValue_;	146✔
205	}	146✔
206	}	151✔
207
208	Real LinearTsrPricer::strikeFromVegaRatio(Real ratio,	×
209	Option::Type optionType,
210	Real referenceStrike) const {
211
212	Real a, b, min, max, k;
213	if (optionType == Option::Call) {	×
214	a = swapRateValue_;	×
215	min = referenceStrike;	×
216	// NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
217	b = max = k =	×
218	std::min(smileSection_->maxStrike(), adjustedUpperBound_);	×
219	} else {
220	// NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
221	a = min = k =	×
222	std::max(smileSection_->minStrike(), adjustedLowerBound_);	×
223	b = swapRateValue_;	×
224	max = referenceStrike;	×
225	}
226
227	VegaRatioHelper h(&*smileSection_,	×
228	smileSection_->vega(swapRateValue_) * ratio);	×
229	Brent solver;
230
231	try {
232	k = solver.solve(h, 1.0E-5, (a + b) / 2.0, a, b);	×
233	}
234	catch (...) {	×
235	// use default value set above
236	}	×
237
238	return std::min(std::max(k, min), max);	×
239	}
240
241	Real LinearTsrPricer::strikeFromPrice(Real price, Option::Type optionType,	×
242	Real referenceStrike) const {
243
244	Real a, b, min, max, k;
245	if (optionType == Option::Call) {	×
246	a = swapRateValue_;	×
247	min = referenceStrike;	×
248	// NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
249	b = max = k =	×
250	std::min(smileSection_->maxStrike(), adjustedUpperBound_);	×
251	} else {
252	// NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
253	a = min = k =	×
254	std::max(smileSection_->minStrike(), adjustedLowerBound_);	×
255	b = swapRateValue_;	×
256	max = referenceStrike;	×
257	}
258
259	PriceHelper h(&*smileSection_, optionType, price);	×
260	Brent solver;
261
262	try {
263	k = solver.solve(h, 1.0E-5, swapRateValue_, a, b);	×
264	}
265	catch (...) {	×
266	// use default value set above
267	}	×
268
269	return std::min(std::max(k, min), max);	×
270	}
271
272	Real LinearTsrPricer::optionletPrice(Option::Type optionType,	304✔
273	Real strike) const {
274
275	if (optionType == Option::Call && strike >= adjustedUpperBound_)	304✔
276	return 0.0;
277	if (optionType == Option::Put && strike <= adjustedLowerBound_)	304✔
278	return 0.0;
279
280	// determine lower or upper integration bound (depending on option type)
281
282	Real lower = strike, upper = strike;	304✔
283
284	switch (settings_.strategy_) {	304✔
285
286	case Settings::RateBound: {	304✔
287	if (optionType == Option::Call)	304✔
288	upper = adjustedUpperBound_;	152✔
289	else
290	lower = adjustedLowerBound_;	152✔
291	break;
292	}
293
294	case Settings::VegaRatio: {	×
295	// strikeFromVegaRatio ensures that returned strike is on the
296	// expected side of strike
297	Real bound =
298	strikeFromVegaRatio(settings_.vegaRatio_, optionType, strike);	×
299	if (optionType == Option::Call)	×
300	upper = std::min(bound, adjustedUpperBound_);	×
301	else
302	lower = std::max(bound, adjustedLowerBound_);	×
303	break;
304	}
305
306	case Settings::PriceThreshold: {	×
307	// strikeFromPrice ensures that returned strike is on the expected
308	// side of strike
309	Real bound =
310	strikeFromPrice(settings_.vegaRatio_, optionType, strike);	×
311	if (optionType == Option::Call)	×
312	upper = std::min(bound, adjustedUpperBound_);	×
313	else
314	lower = std::max(bound, adjustedLowerBound_);	×
315	break;
316	}
317
318	case Settings::BSStdDevs : {	×
319	Real atm = smileSection_->atmLevel();	×
320	Real atmVol = smileSection_->volatility(atm);	×
321	Real shift = smileSection_->shift();	×
322	Real lowerTmp, upperTmp;
323	if (smileSection_->volatilityType() == ShiftedLognormal) {	×
324	upperTmp = (atm + shift) *	×
325	std::exp(settings_.stdDevs_ * atmVol -	×
326	0.5 * atmVol * atmVol *	×
327	smileSection_->exerciseTime()) -	×
328	shift;
329	lowerTmp = (atm + shift) *	×
330	std::exp(-settings_.stdDevs_ * atmVol -	×
331	0.5 * atmVol * atmVol *	×
332	smileSection_->exerciseTime()) -	×
333	shift;
334	} else {
335	Real tmp = settings_.stdDevs_ * atmVol *	×
336	std::sqrt(smileSection_->exerciseTime());	×
337	upperTmp = atm + tmp;	×
338	lowerTmp = atm - tmp;	×
339	}
340	upper = std::min(upperTmp - shift, adjustedUpperBound_);	×
341	lower = std::max(lowerTmp - shift, adjustedLowerBound_);	×
342	break;	×
343	}
344
345	default:	×
346	QL_FAIL("Unknown strategy (" << settings_.strategy_ << ")");	×
347	}
348
349	// compute the relevant integral
350
351	Real result = 0.0;
352	Real tmpBound;
353	if (upper > lower) {	304✔
354	tmpBound = std::min(upper, swapRateValue_);	304✔
355	if (tmpBound > lower) {	304✔
356	result += (*integrator_)(integrand_f(this),	155✔
357	lower, tmpBound);
358	}
359	tmpBound = std::max(lower, swapRateValue_);	304✔
360	if (upper > tmpBound) {	304✔
361	result += (*integrator_)(integrand_f(this),	155✔
362	tmpBound, upper);
363	}
364	result *= (optionType == Option::Call ? 1.0 : -1.0);	456✔
365	}
366
367	result += singularTerms(optionType, strike);	304✔
368
369	return annuity_ * result * couponDiscountRatio_ *	304✔
370	coupon_->accrualPeriod();	304✔
371	}
372
373	Real LinearTsrPricer::meanReversion() const { return meanReversion_->value(); }	×
374
375	Rate LinearTsrPricer::swapletRate() const {	151✔
376	return swapletPrice() /	151✔
377	(coupon_->accrualPeriod() * discountCurvePaymentDiscount_ * couponDiscountRatio_);	151✔
378	}
379
380	Real LinearTsrPricer::capletPrice(Rate effectiveCap) const {	6✔
381	// caplet is equivalent to call option on fixing
382	if (fixingDate_ <= today_) {	6✔
383	// the fixing is determined
384	const Rate Rs = std::max(
385	coupon_->swapIndex()->fixing(fixingDate_) - effectiveCap, 0.);	×
NEW 386	Rate price = (gearing_ * Rs) * (coupon_->accrualPeriod() *	×
NEW 387	discountCurvePaymentDiscount_ * couponDiscountRatio_);	×
UNCOV 388	return price;	×
389	} else {
390	Real capletPrice = optionletPrice(Option::Call, effectiveCap);	6✔
391	return gearing_ * capletPrice;	6✔
392	}
393	}
394
395	Rate LinearTsrPricer::capletRate(Rate effectiveCap) const {	6✔
396	return capletPrice(effectiveCap) /	6✔
397	(coupon_->accrualPeriod() * discountCurvePaymentDiscount_ * couponDiscountRatio_);	6✔
398	}
399
400	Real LinearTsrPricer::floorletPrice(Rate effectiveFloor) const {	6✔
401	// floorlet is equivalent to put option on fixing
402	if (fixingDate_ <= today_) {	6✔
403	// the fixing is determined
404	const Rate Rs = std::max(
405	effectiveFloor - coupon_->swapIndex()->fixing(fixingDate_), 0.);	×
NEW 406	Rate price = (gearing_ * Rs) * (coupon_->accrualPeriod() *	×
NEW 407	discountCurvePaymentDiscount_ * couponDiscountRatio_);	×
UNCOV 408	return price;	×
409	} else {
410	Real floorletPrice = optionletPrice(Option::Put, effectiveFloor);	6✔
411	return gearing_ * floorletPrice;	6✔
412	}
413	}
414
415	Rate LinearTsrPricer::floorletRate(Rate effectiveFloor) const {	6✔
416	return floorletPrice(effectiveFloor) /	6✔
417	(coupon_->accrualPeriod() * discountCurvePaymentDiscount_ * couponDiscountRatio_);	6✔
418	}
419
420	Real LinearTsrPricer::swapletPrice() const {	151✔
421	if (fixingDate_ <= today_) {	151✔
422	// the fixing is determined
423	const Rate Rs = coupon_->swapIndex()->fixing(fixingDate_);	5✔
424	Rate price =
425	(gearing_ * Rs + spread_) *	5✔
426	(coupon_->accrualPeriod() * discountCurvePaymentDiscount_ * couponDiscountRatio_);	5✔
427	return price;	5✔
428	} else {
429	Real atmCapletPrice = optionletPrice(Option::Call, swapRateValue_);	146✔
430	Real atmFloorletPrice = optionletPrice(Option::Put, swapRateValue_);	146✔
431	return gearing_ * (coupon_->accrualPeriod() * discountCurvePaymentDiscount_ *	146✔
432	swapRateValue_ * couponDiscountRatio_ +	146✔
433	atmCapletPrice - atmFloorletPrice) +	146✔
434	spreadLegValue_;	146✔
435	}
436	}
437	}

lballabio / QuantLib / 8391917148

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous