1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
|
/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
Copyright (C) 2000, 2001, 2002, 2003 RiskMap srl
Copyright (C) 2003, 2004, 2005, 2006, 2007 StatPro Italia srl
Copyright (C) 2006, 2008 Ferdinando Ametrano
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.
*/
/*! \file fixedvsfloatingswap.hpp
\brief Fixed-rate vs floating-rate swap
*/
#ifndef quantlib_fixed_vs_floating_swap_hpp
#define quantlib_fixed_vs_floating_swap_hpp
#include <ql/instruments/swap.hpp>
#include <ql/time/daycounter.hpp>
#include <ql/time/schedule.hpp>
#include <ql/optional.hpp>
namespace QuantLib {
class IborIndex;
//! Fixed vs floating swap
/*! \ingroup instruments
If no payment convention is passed, the convention of the
floating-rate schedule is used.
\warning if <tt>Settings::includeReferenceDateCashFlows()</tt>
is set to <tt>true</tt>, payments occurring at the
settlement date of the swap might be included in the
NPV and therefore affect the fair-rate and
fair-spread calculation. This might not be what you
want.
*/
class FixedVsFloatingSwap : public Swap {
public:
class arguments;
class results;
class engine;
FixedVsFloatingSwap(Type type,
std::vector<Real> fixedNominals,
Schedule fixedSchedule,
Rate fixedRate,
DayCounter fixedDayCount,
std::vector<Real> floatingNominals,
Schedule floatingSchedule,
ext::shared_ptr<IborIndex> iborIndex,
Spread spread,
DayCounter floatingDayCount,
ext::optional<BusinessDayConvention> paymentConvention = ext::nullopt,
Integer paymentLag = 0,
const Calendar& paymentCalendar = Calendar());
//! \name Inspectors
//@{
Type type() const;
/*! This throws if the nominal is not constant across coupons. */
Real nominal() const;
/*! This throws if the nominals are not the same for the two legs. */
const std::vector<Real>& nominals() const;
const std::vector<Real>& fixedNominals() const;
const Schedule& fixedSchedule() const;
Rate fixedRate() const;
const DayCounter& fixedDayCount() const;
const std::vector<Real>& floatingNominals() const;
const Schedule& floatingSchedule() const;
const ext::shared_ptr<IborIndex>& iborIndex() const;
Spread spread() const;
const DayCounter& floatingDayCount() const;
BusinessDayConvention paymentConvention() const;
const Leg& fixedLeg() const;
const Leg& floatingLeg() const;
//@}
//! \name Results
//@{
Real fixedLegBPS() const;
Real fixedLegNPV() const;
Rate fairRate() const;
Real floatingLegBPS() const;
Real floatingLegNPV() const;
Spread fairSpread() const;
//@}
// other
void setupArguments(PricingEngine::arguments* args) const override;
void fetchResults(const PricingEngine::results*) const override;
private:
void setupExpired() const override;
virtual void setupFloatingArguments(arguments* args) const = 0;
Type type_;
std::vector<Real> fixedNominals_;
Schedule fixedSchedule_;
Rate fixedRate_;
DayCounter fixedDayCount_;
std::vector<Real> floatingNominals_;
Schedule floatingSchedule_;
ext::shared_ptr<IborIndex> iborIndex_;
Spread spread_;
DayCounter floatingDayCount_;
BusinessDayConvention paymentConvention_;
// results
mutable Rate fairRate_;
mutable Spread fairSpread_;
bool constantNominals_, sameNominals_;
};
//! %Arguments for simple swap calculation
class FixedVsFloatingSwap::arguments : public Swap::arguments {
public:
arguments() : nominal(Null<Real>()) {}
Type type = Receiver;
Real nominal;
std::vector<Real> fixedNominals;
std::vector<Date> fixedResetDates;
std::vector<Date> fixedPayDates;
std::vector<Real> floatingNominals;
std::vector<Time> floatingAccrualTimes;
std::vector<Date> floatingResetDates;
std::vector<Date> floatingFixingDates;
std::vector<Date> floatingPayDates;
std::vector<Real> fixedCoupons;
std::vector<Spread> floatingSpreads;
std::vector<Real> floatingCoupons;
void validate() const override;
};
//! %Results from simple swap calculation
class FixedVsFloatingSwap::results : public Swap::results {
public:
Rate fairRate;
Spread fairSpread;
void reset() override;
};
class FixedVsFloatingSwap::engine : public GenericEngine<FixedVsFloatingSwap::arguments,
FixedVsFloatingSwap::results> {};
// inline definitions
inline Swap::Type FixedVsFloatingSwap::type() const {
return type_;
}
inline Real FixedVsFloatingSwap::nominal() const {
QL_REQUIRE(constantNominals_, "nominal is not constant");
return fixedNominals_[0];
}
inline const std::vector<Real>& FixedVsFloatingSwap::nominals() const {
QL_REQUIRE(sameNominals_, "different nominals on fixed and floating leg");
return fixedNominals_;
}
inline const std::vector<Real>& FixedVsFloatingSwap::fixedNominals() const {
return fixedNominals_;
}
inline const Schedule& FixedVsFloatingSwap::fixedSchedule() const {
return fixedSchedule_;
}
inline Rate FixedVsFloatingSwap::fixedRate() const {
return fixedRate_;
}
inline const DayCounter& FixedVsFloatingSwap::fixedDayCount() const {
return fixedDayCount_;
}
inline const std::vector<Real>& FixedVsFloatingSwap::floatingNominals() const {
return floatingNominals_;
}
inline const Schedule& FixedVsFloatingSwap::floatingSchedule() const {
return floatingSchedule_;
}
inline const ext::shared_ptr<IborIndex>& FixedVsFloatingSwap::iborIndex() const {
return iborIndex_;
}
inline Spread FixedVsFloatingSwap::spread() const {
return spread_;
}
inline const DayCounter& FixedVsFloatingSwap::floatingDayCount() const {
return floatingDayCount_;
}
inline BusinessDayConvention FixedVsFloatingSwap::paymentConvention() const {
return paymentConvention_;
}
inline const Leg& FixedVsFloatingSwap::fixedLeg() const {
return legs_[0];
}
inline const Leg& FixedVsFloatingSwap::floatingLeg() const {
return legs_[1];
}
}
#endif
|
