This website coveralls.io/builds/59687806/source?filename=ql%2Fpricingengines%2Fcredit%2Fintegralcdsengine.cpp is currently offline. Cloudflare's Always Online™ shows a snapshot of this web page from the Internet Archive's Wayback Machine. To check for the live version, click Refresh.

4897696924

pending completion

Build # 4897696924

Build Type

Pull #1566

github

Committed by GitHub

Commit Message

Merge e80b20375 into f8fb06beb

Pull Request Pull Request #1566: Make floating-rate coupons lazy

Run Details

58 of 58 new or added lines in 13 files covered. (100.0%)

54107 of 75163 relevant lines covered (71.99%)

10582441.98 hits per line

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

78.49

/ql/pricingengines/credit/integralcdsengine.cpp

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

/*
 Copyright (C) 2008 Roland Lichters
 Copyright (C) 2008, 2009 StatPro Italia srl
 Copyright (C) 2009 Jose Aparicio

 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.
*/

#include <ql/cashflows/fixedratecoupon.hpp>
#include <ql/instruments/claim.hpp>
#include <ql/pricingengines/credit/integralcdsengine.hpp>
#include <ql/termstructures/yieldtermstructure.hpp>
#include <ql/optional.hpp>
#include <utility>

namespace QuantLib {

    IntegralCdsEngine::IntegralCdsEngine(const Period& step,
                                         Handle<DefaultProbabilityTermStructure> probability,
                                         Real recoveryRate,
                                         Handle<YieldTermStructure> discountCurve,
                                         const ext::optional<bool>& includeSettlementDateFlows)
    : integrationStep_(step), probability_(std::move(probability)), recoveryRate_(recoveryRate),
      discountCurve_(std::move(discountCurve)),
      includeSettlementDateFlows_(includeSettlementDateFlows) {
        registerWith(probability_);
        registerWith(discountCurve_);
    }

    void IntegralCdsEngine::calculate() const {
        QL_REQUIRE(integrationStep_ != Period(),
                   "null period set");
        QL_REQUIRE(!discountCurve_.empty(),
                   "no discount term structure set");
        QL_REQUIRE(!probability_.empty(),
                   "no probability term structure set");

        Date today = Settings::instance().evaluationDate();
        Date settlementDate = discountCurve_->referenceDate();

        // Upfront amount.
        Real upfPVO1 = 0.0;
        results_.upfrontNPV = 0.0;
        if (!arguments_.upfrontPayment->hasOccurred(
            settlementDate, includeSettlementDateFlows_)) {
            upfPVO1 = discountCurve_->discount(arguments_.upfrontPayment->date());
            results_.upfrontNPV = upfPVO1 * arguments_.upfrontPayment->amount();
        }

        // Accrual rebate.
        results_.accrualRebateNPV = 0.;
        // NOLINTNEXTLINE(readability-implicit-bool-conversion)
        if (arguments_.accrualRebate &&
            !arguments_.accrualRebate->hasOccurred(settlementDate, includeSettlementDateFlows_)) {
            results_.accrualRebateNPV =
                discountCurve_->discount(arguments_.accrualRebate->date()) *
                arguments_.accrualRebate->amount();
        }

        results_.couponLegNPV = 0.0;
        results_.defaultLegNPV = 0.0;
        for (Size i=0; i<arguments_.leg.size(); ++i) {
            if (arguments_.leg[i]->hasOccurred(settlementDate,
                                               includeSettlementDateFlows_))
                continue;

            ext::shared_ptr<FixedRateCoupon> coupon =
                ext::dynamic_pointer_cast<FixedRateCoupon>(arguments_.leg[i]);

            // In order to avoid a few switches, we calculate the NPV
            // of both legs as a positive quantity. We'll give them
            // the right sign at the end.

            Date paymentDate = coupon->date(),
                 startDate = (i == 0 ? arguments_.protectionStart :
                                       coupon->accrualStartDate()),
                 endDate = coupon->accrualEndDate();
            Date effectiveStartDate =
                (startDate <= today && today <= endDate) ? today : startDate;
            Real couponAmount = coupon->amount();

            Probability S = probability_->survivalProbability(paymentDate);

            // On one side, we add the fixed rate payments in case of
            // survival.
            results_.couponLegNPV +=
                S * couponAmount * discountCurve_->discount(paymentDate);

            // On the other side, we add the payment (and possibly the
            // accrual) in case of default.

            Period step = integrationStep_;
            Date d0 = effectiveStartDate;
            Date d1 = std::min(d0 + step, endDate);
            Probability P0 = probability_->defaultProbability(d0);
            DiscountFactor endDiscount = discountCurve_->discount(paymentDate);
            do {
                DiscountFactor B =
                    arguments_.paysAtDefaultTime ?
                    discountCurve_->discount(d1) :
                    endDiscount;

                Probability P1 = probability_->defaultProbability(d1);
                Probability dP = P1 - P0;

                // accrual...
                if (arguments_.settlesAccrual) {
                    if (arguments_.paysAtDefaultTime)
                        results_.couponLegNPV +=
                            coupon->accruedAmount(d1) * B * dP;
                    else
                        results_.couponLegNPV +=
                            couponAmount * B * dP;
                }

                // ...and claim.
                Real claim = arguments_.claim->amount(d1,
                                                      arguments_.notional,
                                                      recoveryRate_);
                results_.defaultLegNPV += claim * B * dP;

                // setup for next time around the loop
                P0 = P1;
                d0 = d1;
                d1 = std::min(d0 + step, endDate);
            } while (d0 < endDate);
        }

        Real upfrontSign = 1.0;
        switch (arguments_.side) {
          case Protection::Seller:
            results_.defaultLegNPV *= -1.0;
            results_.accrualRebateNPV *= -1.0;
            break;
          case Protection::Buyer:
            results_.couponLegNPV *= -1.0;
            results_.upfrontNPV   *= -1.0;
            upfrontSign = -1.0;
            break;
          default:
            QL_FAIL("unknown protection side");
        }

        results_.value =
            results_.defaultLegNPV + results_.couponLegNPV +
                results_.upfrontNPV + results_.accrualRebateNPV;
        results_.errorEstimate = Null<Real>();

        if (results_.couponLegNPV != 0.0) {
            results_.fairSpread =
                -results_.defaultLegNPV*arguments_.spread
                    /(results_.couponLegNPV + results_.accrualRebateNPV);
        } else {
            results_.fairSpread = Null<Rate>();
        }

        if (upfPVO1 > 0.0) {
            results_.fairUpfront =
                -upfrontSign*(results_.defaultLegNPV + results_.couponLegNPV +
                    results_.accrualRebateNPV)
                / (upfPVO1 * arguments_.notional);
        } else {
            results_.fairUpfront = Null<Rate>();
        }

        static const Rate basisPoint = 1.0e-4;

        if (arguments_.spread != 0.0) {
            results_.couponLegBPS =
                results_.couponLegNPV*basisPoint/arguments_.spread;
        } else {
            results_.couponLegBPS = Null<Rate>();
        }

        // NOLINTNEXTLINE(readability-implicit-bool-conversion)
        if (arguments_.upfront && *arguments_.upfront != 0.0) {
            results_.upfrontBPS =
                results_.upfrontNPV*basisPoint/(*arguments_.upfront);
        } else {
            results_.upfrontBPS = Null<Rate>();
        }
    }

}

1	/* -- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -- */
2
3	/*
4	Copyright (C) 2008 Roland Lichters
5	Copyright (C) 2008, 2009 StatPro Italia srl
6	Copyright (C) 2009 Jose Aparicio
7
8	This file is part of QuantLib, a free-software/open-source library
9	for financial quantitative analysts and developers - http://quantlib.org/
10
11	QuantLib is free software: you can redistribute it and/or modify it
12	under the terms of the QuantLib license. You should have received a
13	copy of the license along with this program; if not, please email
14	<quantlib-dev@lists.sf.net>. The license is also available online at
15	<http://quantlib.org/license.shtml>.
16
17	This program is distributed in the hope that it will be useful, but WITHOUT
18	ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
19	FOR A PARTICULAR PURPOSE. See the license for more details.
20	*/
21
22	#include <ql/cashflows/fixedratecoupon.hpp>
23	#include <ql/instruments/claim.hpp>
24	#include <ql/pricingengines/credit/integralcdsengine.hpp>
25	#include <ql/termstructures/yieldtermstructure.hpp>
26	#include <ql/optional.hpp>
27	#include <utility>
28
29	namespace QuantLib {
30
31	IntegralCdsEngine::IntegralCdsEngine(const Period& step,	2✔
32	Handle<DefaultProbabilityTermStructure> probability,
33	Real recoveryRate,
34	Handle<YieldTermStructure> discountCurve,
35	const ext::optional<bool>& includeSettlementDateFlows)	2✔
36	: integrationStep_(step), probability_(std::move(probability)), recoveryRate_(recoveryRate),	2✔
37	discountCurve_(std::move(discountCurve)),
38	includeSettlementDateFlows_(includeSettlementDateFlows) {	2✔
39	registerWith(probability_);	4✔
40	registerWith(discountCurve_);	2✔
41	}	2✔
42
43	void IntegralCdsEngine::calculate() const {	2✔
44	QL_REQUIRE(integrationStep_ != Period(),	2✔
45	"null period set");
46	QL_REQUIRE(!discountCurve_.empty(),	2✔
47	"no discount term structure set");
48	QL_REQUIRE(!probability_.empty(),	2✔
49	"no probability term structure set");
50
51	Date today = Settings::instance().evaluationDate();	2✔
52	Date settlementDate = discountCurve_->referenceDate();	2✔
53
54	// Upfront amount.
55	Real upfPVO1 = 0.0;
56	results_.upfrontNPV = 0.0;	2✔
57	if (!arguments_.upfrontPayment->hasOccurred(	2✔
58	settlementDate, includeSettlementDateFlows_)) {
59	upfPVO1 = discountCurve_->discount(arguments_.upfrontPayment->date());	×
60	results_.upfrontNPV = upfPVO1 * arguments_.upfrontPayment->amount();	×
61	}
62
63	// Accrual rebate.
64	results_.accrualRebateNPV = 0.;	2✔
65	// NOLINTNEXTLINE(readability-implicit-bool-conversion)
66	if (arguments_.accrualRebate &&	4✔
67	!arguments_.accrualRebate->hasOccurred(settlementDate, includeSettlementDateFlows_)) {	2✔
68	results_.accrualRebateNPV =	×
69	discountCurve_->discount(arguments_.accrualRebate->date()) *	×
70	arguments_.accrualRebate->amount();	×
71	}
72
73	results_.couponLegNPV = 0.0;	2✔
74	results_.defaultLegNPV = 0.0;	2✔
75	for (Size i=0; i<arguments_.leg.size(); ++i) {	42✔
76	if (arguments_.leg[i]->hasOccurred(settlementDate,	40✔
77	includeSettlementDateFlows_))
78	continue;	4✔
79
80	ext::shared_ptr<FixedRateCoupon> coupon =
81	ext::dynamic_pointer_cast<FixedRateCoupon>(arguments_.leg[i]);	36✔
82
83	// In order to avoid a few switches, we calculate the NPV
84	// of both legs as a positive quantity. We'll give them
85	// the right sign at the end.
86
87	Date paymentDate = coupon->date(),	36✔
88	startDate = (i == 0 ? arguments_.protectionStart :	36✔
89	coupon->accrualStartDate()),	36✔
90	endDate = coupon->accrualEndDate();	36✔
91	Date effectiveStartDate =
92	(startDate <= today && today <= endDate) ? today : startDate;	36✔
93	Real couponAmount = coupon->amount();	36✔
94
95	Probability S = probability_->survivalProbability(paymentDate);	36✔
96
97	// On one side, we add the fixed rate payments in case of
98	// survival.
99	results_.couponLegNPV +=	36✔
100	S * couponAmount * discountCurve_->discount(paymentDate);	36✔
101
102	// On the other side, we add the payment (and possibly the
103	// accrual) in case of default.
104
105	Period step = integrationStep_;	36✔
106	Date d0 = effectiveStartDate;	36✔
107	Date d1 = std::min(d0 + step, endDate);	36✔
108	Probability P0 = probability_->defaultProbability(d0);	36✔
109	DiscountFactor endDiscount = discountCurve_->discount(paymentDate);	36✔
110	do {
111	DiscountFactor B =
112	arguments_.paysAtDefaultTime ?	3,762✔
113	discountCurve_->discount(d1) :	3,762✔
114	endDiscount;
115
116	Probability P1 = probability_->defaultProbability(d1);	3,762✔
117	Probability dP = P1 - P0;	3,762✔
118
119	// accrual...
120	if (arguments_.settlesAccrual) {	3,762✔
121	if (arguments_.paysAtDefaultTime)	3,762✔
122	results_.couponLegNPV +=	3,762✔
123	coupon->accruedAmount(d1) * B * dP;	3,762✔
124	else
125	results_.couponLegNPV +=	×
126	couponAmount * B * dP;	×
127	}
128
129	// ...and claim.
130	Real claim = arguments_.claim->amount(d1,	3,762✔
131	arguments_.notional,
132	recoveryRate_);	3,762✔
133	results_.defaultLegNPV += claim * B * dP;	3,762✔
134
135	// setup for next time around the loop
136	P0 = P1;
137	d0 = d1;	3,762✔
138	d1 = std::min(d0 + step, endDate);	3,805✔
139	} while (d0 < endDate);	3,762✔
140	}
141
142	Real upfrontSign = 1.0;
143	switch (arguments_.side) {	2✔
144	case Protection::Seller:	2✔
145	results_.defaultLegNPV *= -1.0;	2✔
146	results_.accrualRebateNPV *= -1.0;	2✔
147	break;	2✔
148	case Protection::Buyer:	×
149	results_.couponLegNPV *= -1.0;	×
150	results_.upfrontNPV *= -1.0;	×
151	upfrontSign = -1.0;
152	break;	×
153	default:	×
154	QL_FAIL("unknown protection side");	×
155	}
156
157	results_.value =	2✔
158	results_.defaultLegNPV + results_.couponLegNPV +	2✔
159	results_.upfrontNPV + results_.accrualRebateNPV;	2✔
160	results_.errorEstimate = Null<Real>();	2✔
161
162	if (results_.couponLegNPV != 0.0) {	2✔
163	results_.fairSpread =	2✔
164	-results_.defaultLegNPV*arguments_.spread	2✔
165	/(results_.couponLegNPV + results_.accrualRebateNPV);	2✔
166	} else {
167	results_.fairSpread = Null<Rate>();	×
168	}
169
170	if (upfPVO1 > 0.0) {	2✔
171	results_.fairUpfront =	×
172	-upfrontSign*(results_.defaultLegNPV + results_.couponLegNPV +	×
173	results_.accrualRebateNPV)
174	/ (upfPVO1 * arguments_.notional);	×
175	} else {
176	results_.fairUpfront = Null<Rate>();	2✔
177	}
178
179	static const Rate basisPoint = 1.0e-4;
180
181	if (arguments_.spread != 0.0) {	2✔
182	results_.couponLegBPS =	2✔
183	results_.couponLegNPV*basisPoint/arguments_.spread;	2✔
184	} else {
185	results_.couponLegBPS = Null<Rate>();	×
186	}
187
188	// NOLINTNEXTLINE(readability-implicit-bool-conversion)
189	if (arguments_.upfront && *arguments_.upfront != 0.0) {	2✔
190	results_.upfrontBPS =	×
191	results_.upfrontNPVbasisPoint/(arguments_.upfront);	×
192	} else {
193	results_.upfrontBPS = Null<Rate>();	2✔
194	}
195	}	2✔
196
197	}

lballabio / QuantLib / 4897696924

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