22825095276

Committed 08 Mar 2026 04:28PM UTC coverage: 74.241% (-0.001%) from 74.242%

Build # 22825095276

Build Type

Pull #2474

github

Committed by

web-flow

Commit Message

Merge 6644ae412 into 81d819d28

Pull Request Pull Request #2474: Add MultipleResetsSwap instrument and rate helper

Coverage Stats

135 of 191 new or added lines in 4 files covered. (70.68%)

67 existing lines in 1 file now uncovered.

57889 of 77974 relevant lines covered (74.24%)

8711976.92 hits per line

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

69.15

/ql/instruments/makemultipleresetsswap.cpp

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

/*
 Copyright (C) 2026 Zain Mughal

 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
 <https://www.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/indexes/iborindex.hpp>
#include <ql/instruments/makemultipleresetsswap.hpp>
#include <ql/pricingengines/swap/discountingswapengine.hpp>
#include <ql/settings.hpp>
#include <ql/time/schedule.hpp>

namespace QuantLib {

    MakeMultipleResetsSwap::MakeMultipleResetsSwap(
        const Period& tenor,
        const ext::shared_ptr<IborIndex>& iborIndex,
        Size resetsPerCoupon,
        Rate fixedRate,
        const Period& fwdStart)
    : tenor_(tenor), iborIndex_(iborIndex), resetsPerCoupon_(resetsPerCoupon),
      fixedRate_(fixedRate), forwardStart_(fwdStart),
      fixedDayCount_(iborIndex->dayCounter()) {}

    MakeMultipleResetsSwap::operator MultipleResetsSwap() const {
        ext::shared_ptr<MultipleResetsSwap> swap = *this;
        return *swap;
    }

    MakeMultipleResetsSwap::operator ext::shared_ptr<MultipleResetsSwap>() const {
        Calendar cal = iborIndex_->fixingCalendar();
        BusinessDayConvention bdc = iborIndex_->businessDayConvention();

        Date startDate;
        if (effectiveDate_ != Date()) {
            startDate = effectiveDate_;
        } else {
            Natural settlDays = settlementDays_ != Null<Natural>() ?
                                settlementDays_ : iborIndex_->fixingDays();
            Date refDate = Settings::instance().evaluationDate();
            startDate = cal.advance(cal.adjust(refDate), settlDays * Days);
            startDate = cal.advance(startDate, forwardStart_,
                                   forwardStart_.length() < 0 ? Preceding : Following);
        }

        Date endDate = terminationDate_ != Date() ?
                       terminationDate_ :
                       cal.advance(startDate, tenor_, bdc);

        Period resetTenor = iborIndex_->tenor();
        // Fixed coupon period: resetsPerCoupon consecutive reset periods.
        // If not overridden, derive the fixed frequency from the coupon period.
        Frequency fixedFreq = fixedFrequency_;
        if (fixedFreq == NoFrequency) {
            Period couponTenor(resetsPerCoupon_ * resetTenor.length(), resetTenor.units());
            fixedFreq = couponTenor.frequency();
        }

        Schedule fixedSchedule(startDate, endDate, Period(fixedFreq),
                               cal, fixedConvention_, fixedConvention_,
                               DateGeneration::Backward, false);

        Schedule fullResetSchedule(startDate, endDate, resetTenor,
                                   cal, bdc, bdc,
                                   DateGeneration::Backward, false);

        Rate usedFixedRate = fixedRate_;
        if (fixedRate_ == Null<Rate>()) {
            MultipleResetsSwap temp(type_, nominal_,
                                    fixedSchedule, 0.0, fixedDayCount_,
                                    fullResetSchedule, iborIndex_, resetsPerCoupon_,
                                    spread_, averagingMethod_);
            if (engine_ == nullptr) {
                Handle<YieldTermStructure> disc =
                    iborIndex_->forwardingTermStructure();
                QL_REQUIRE(!disc.empty(),
                           "null term structure set to this instance of "
                           << iborIndex_->name());
                temp.setPricingEngine(ext::make_shared<DiscountingSwapEngine>(disc, false));
            } else {
                temp.setPricingEngine(engine_);
            }
            usedFixedRate = temp.fairRate();
        }

        auto swap = ext::make_shared<MultipleResetsSwap>(
            type_, nominal_,
            fixedSchedule, usedFixedRate, fixedDayCount_,
            fullResetSchedule, iborIndex_, resetsPerCoupon_,
            spread_, averagingMethod_);

        if (engine_ == nullptr) {
            Handle<YieldTermStructure> disc = iborIndex_->forwardingTermStructure();
            if (!disc.empty())
                swap->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(disc, false));
        } else {
            swap->setPricingEngine(engine_);
        }

        return swap;
    }

    MakeMultipleResetsSwap& MakeMultipleResetsSwap::receiveFixed(bool flag) {
        type_ = flag ? Swap::Receiver : Swap::Payer;
        return *this;
    }

    MakeMultipleResetsSwap& MakeMultipleResetsSwap::withType(Swap::Type type) {
        type_ = type;
        return *this;
    }

    MakeMultipleResetsSwap& MakeMultipleResetsSwap::withNominal(Real n) {
        nominal_ = n;
        return *this;
    }

    MakeMultipleResetsSwap& MakeMultipleResetsSwap::withSettlementDays(Natural settlementDays) {
        settlementDays_ = settlementDays;
        effectiveDate_ = Date();
        return *this;
    }

    MakeMultipleResetsSwap& MakeMultipleResetsSwap::withEffectiveDate(const Date& d) {
        effectiveDate_ = d;
        return *this;
    }

    MakeMultipleResetsSwap& MakeMultipleResetsSwap::withTerminationDate(const Date& d) {
        terminationDate_ = d;
        if (d != Date())
            tenor_ = Period();
        return *this;
    }

    MakeMultipleResetsSwap& MakeMultipleResetsSwap::withFixedLegFrequency(Frequency f) {
        fixedFrequency_ = f;
        return *this;
    }

    MakeMultipleResetsSwap& MakeMultipleResetsSwap::withFixedLegDayCount(const DayCounter& dc) {
        fixedDayCount_ = dc;
        return *this;
    }

    MakeMultipleResetsSwap& MakeMultipleResetsSwap::withFixedLegConvention(BusinessDayConvention bdc) {
        fixedConvention_ = bdc;
        return *this;
    }

    MakeMultipleResetsSwap& MakeMultipleResetsSwap::withFloatingLegSpread(Spread sp) {
        spread_ = sp;
        return *this;
    }

    MakeMultipleResetsSwap& MakeMultipleResetsSwap::withAveragingMethod(RateAveraging::Type m) {
        averagingMethod_ = m;
        return *this;
    }

    MakeMultipleResetsSwap& MakeMultipleResetsSwap::withDiscountingTermStructure(
                                const Handle<YieldTermStructure>& d) {
        engine_ = ext::make_shared<DiscountingSwapEngine>(d, false);
        return *this;
    }

    MakeMultipleResetsSwap& MakeMultipleResetsSwap::withPricingEngine(
                                const ext::shared_ptr<PricingEngine>& engine) {
        engine_ = engine;
        return *this;
    }

}

1	/* -- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -- */
2
3	/*
4	Copyright (C) 2026 Zain Mughal
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	<https://www.quantlib.org/license.shtml>.
14
15	This program is distributed in the hope that it will be useful, but WITHOUT
16	ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
17	FOR A PARTICULAR PURPOSE. See the license for more details.
18	*/
19
20	#include <ql/indexes/iborindex.hpp>
21	#include <ql/instruments/makemultipleresetsswap.hpp>
22	#include <ql/pricingengines/swap/discountingswapengine.hpp>
23	#include <ql/settings.hpp>
24	#include <ql/time/schedule.hpp>
25
26	namespace QuantLib {
27
28	MakeMultipleResetsSwap::MakeMultipleResetsSwap(	12✔
29	const Period& tenor,
30	const ext::shared_ptr<IborIndex>& iborIndex,
31	Size resetsPerCoupon,
32	Rate fixedRate,
33	const Period& fwdStart)	12✔
34	: tenor_(tenor), iborIndex_(iborIndex), resetsPerCoupon_(resetsPerCoupon),	12✔
35	fixedRate_(fixedRate), forwardStart_(fwdStart),	12✔
36	fixedDayCount_(iborIndex->dayCounter()) {}	24✔
37
NEW 38	MakeMultipleResetsSwap::operator MultipleResetsSwap() const {	×
NEW 39	ext::shared_ptr<MultipleResetsSwap> swap = *this;	×
NEW 40	return *swap;	×
41	}
42
43	MakeMultipleResetsSwap::operator ext::shared_ptr<MultipleResetsSwap>() const {	12✔
44	Calendar cal = iborIndex_->fixingCalendar();	12✔
45	BusinessDayConvention bdc = iborIndex_->businessDayConvention();	12✔
46
47	Date startDate;	12✔
48	if (effectiveDate_ != Date()) {	12✔
NEW 49	startDate = effectiveDate_;	×
50	} else {
51	Natural settlDays = settlementDays_ != Null<Natural>() ?	12✔
NEW 52	settlementDays_ : iborIndex_->fixingDays();	×
53	Date refDate = Settings::instance().evaluationDate();	12✔
54	startDate = cal.advance(cal.adjust(refDate), settlDays * Days);	12✔
55	startDate = cal.advance(startDate, forwardStart_,	24✔
56	forwardStart_.length() < 0 ? Preceding : Following);
57	}
58
59	Date endDate = terminationDate_ != Date() ?	12✔
60	terminationDate_ :
61	cal.advance(startDate, tenor_, bdc);	12✔
62
63	Period resetTenor = iborIndex_->tenor();	12✔
64	// Fixed coupon period: resetsPerCoupon consecutive reset periods.
65	// If not overridden, derive the fixed frequency from the coupon period.
66	Frequency fixedFreq = fixedFrequency_;	12✔
67	if (fixedFreq == NoFrequency) {	12✔
68	Period couponTenor(resetsPerCoupon_ * resetTenor.length(), resetTenor.units());	12✔
69	fixedFreq = couponTenor.frequency();	12✔
70	}
71
72	Schedule fixedSchedule(startDate, endDate, Period(fixedFreq),	24✔
73	cal, fixedConvention_, fixedConvention_,	12✔
74	DateGeneration::Backward, false);	24✔
75
76	Schedule fullResetSchedule(startDate, endDate, resetTenor,
77	cal, bdc, bdc,
78	DateGeneration::Backward, false);	24✔
79
80	Rate usedFixedRate = fixedRate_;	12✔
81	if (fixedRate_ == Null<Rate>()) {	12✔
NEW 82	MultipleResetsSwap temp(type_, nominal_,	×
83	fixedSchedule, 0.0, fixedDayCount_,
NEW 84	fullResetSchedule, iborIndex_, resetsPerCoupon_,	×
NEW 85	spread_, averagingMethod_);	×
NEW 86	if (engine_ == nullptr) {	×
87	Handle<YieldTermStructure> disc =
NEW 88	iborIndex_->forwardingTermStructure();	×
NEW 89	QL_REQUIRE(!disc.empty(),	×
90	"null term structure set to this instance of "
91	<< iborIndex_->name());
NEW 92	temp.setPricingEngine(ext::make_shared<DiscountingSwapEngine>(disc, false));	×
93	} else {
NEW 94	temp.setPricingEngine(engine_);	×
95	}
NEW 96	usedFixedRate = temp.fairRate();	×
NEW 97	}	×
98
99	auto swap = ext::make_shared<MultipleResetsSwap>(
100	type_, nominal_,	12✔
101	fixedSchedule, usedFixedRate, fixedDayCount_,	12✔
102	fullResetSchedule, iborIndex_, resetsPerCoupon_,	12✔
103	spread_, averagingMethod_);	12✔
104
105	if (engine_ == nullptr) {	12✔
106	Handle<YieldTermStructure> disc = iborIndex_->forwardingTermStructure();	6✔
107	if (!disc.empty())	6✔
108	swap->setPricingEngine(ext::make_shared<DiscountingSwapEngine>(disc, false));	12✔
109	} else {
110	swap->setPricingEngine(engine_);	6✔
111	}
112
113	return swap;	12✔
114	}	12✔
115
NEW 116	MakeMultipleResetsSwap& MakeMultipleResetsSwap::receiveFixed(bool flag) {	×
NEW 117	type_ = flag ? Swap::Receiver : Swap::Payer;	×
NEW 118	return *this;	×
119	}
120
121	MakeMultipleResetsSwap& MakeMultipleResetsSwap::withType(Swap::Type type) {	2✔
122	type_ = type;	2✔
123	return *this;	2✔
124	}
125
126	MakeMultipleResetsSwap& MakeMultipleResetsSwap::withNominal(Real n) {	9✔
127	nominal_ = n;	9✔
128	return *this;	9✔
129	}
130
131	MakeMultipleResetsSwap& MakeMultipleResetsSwap::withSettlementDays(Natural settlementDays) {	12✔
132	settlementDays_ = settlementDays;	12✔
133	effectiveDate_ = Date();	12✔
134	return *this;	12✔
135	}
136
NEW 137	MakeMultipleResetsSwap& MakeMultipleResetsSwap::withEffectiveDate(const Date& d) {	×
NEW 138	effectiveDate_ = d;	×
NEW 139	return *this;	×
140	}
141
NEW 142	MakeMultipleResetsSwap& MakeMultipleResetsSwap::withTerminationDate(const Date& d) {	×
NEW 143	terminationDate_ = d;	×
NEW 144	if (d != Date())	×
NEW 145	tenor_ = Period();	×
NEW 146	return *this;	×
147	}
148
149	MakeMultipleResetsSwap& MakeMultipleResetsSwap::withFixedLegFrequency(Frequency f) {	3✔
150	fixedFrequency_ = f;	3✔
151	return *this;	3✔
152	}
153
154	MakeMultipleResetsSwap& MakeMultipleResetsSwap::withFixedLegDayCount(const DayCounter& dc) {	3✔
155	fixedDayCount_ = dc;
156	return *this;	3✔
157	}
158
159	MakeMultipleResetsSwap& MakeMultipleResetsSwap::withFixedLegConvention(BusinessDayConvention bdc) {	3✔
160	fixedConvention_ = bdc;	3✔
161	return *this;	3✔
162	}
163
164	MakeMultipleResetsSwap& MakeMultipleResetsSwap::withFloatingLegSpread(Spread sp) {	3✔
165	spread_ = sp;	3✔
166	return *this;	3✔
167	}
168
169	MakeMultipleResetsSwap& MakeMultipleResetsSwap::withAveragingMethod(RateAveraging::Type m) {	7✔
170	averagingMethod_ = m;	7✔
171	return *this;	7✔
172	}
173
174	MakeMultipleResetsSwap& MakeMultipleResetsSwap::withDiscountingTermStructure(	6✔
175	const Handle<YieldTermStructure>& d) {
176	engine_ = ext::make_shared<DiscountingSwapEngine>(d, false);	6✔
177	return *this;	6✔
178	}
179
NEW 180	MakeMultipleResetsSwap& MakeMultipleResetsSwap::withPricingEngine(	×
181	const ext::shared_ptr<PricingEngine>& engine) {
NEW 182	engine_ = engine;	×
NEW 183	return *this;	×
184	}
185
186	}

lballabio / QuantLib / 22825095276

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