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
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
|
/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
Copyright (C) 2008 Mark Joshi
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.
*/
#ifndef quantlib_pathwise_accounting_engine_hpp
#define quantlib_pathwise_accounting_engine_hpp
#include <ql/models/marketmodels/pathwisemultiproduct.hpp>
#include <ql/models/marketmodels/pathwisediscounter.hpp>
#include <ql/math/statistics/sequencestatistics.hpp>
#include <ql/models/marketmodels/pathwisegreeks/ratepseudorootjacobian.hpp>
#include <ql/utilities/clone.hpp>
#include <ql/types.hpp>
#include <vector>
namespace QuantLib {
class LogNormalFwdRateEuler;
class MarketModel;
//! Engine collecting cash flows along a market-model simulation for doing pathwise computation of Deltas
// using Giles--Glasserman smoking adjoints method
// note only works with displaced LMM, and requires knowledge of pseudo-roots and displacements
// This is tested in MarketModelTest::testPathwiseGreeks
class PathwiseAccountingEngine
{
public:
PathwiseAccountingEngine(
ext::shared_ptr<LogNormalFwdRateEuler> evolver, // method relies heavily on LMM Euler
const Clone<MarketModelPathwiseMultiProduct>& product,
ext::shared_ptr<MarketModel>
pseudoRootStructure, // we need pseudo-roots and displacements
Real initialNumeraireValue);
void multiplePathValues(SequenceStatisticsInc& stats,
Size numberOfPaths);
private:
Real singlePathValues(std::vector<Real>& values);
ext::shared_ptr<LogNormalFwdRateEuler> evolver_;
Clone<MarketModelPathwiseMultiProduct> product_;
ext::shared_ptr<MarketModel> pseudoRootStructure_;
Real initialNumeraireValue_;
Size numberProducts_;
Size numberRates_;
Size numberCashFlowTimes_;
Size numberSteps_;
std::vector<Real> currentForwards_, lastForwards_;
bool doDeflation_;
// workspace
std::vector<Real> numerairesHeld_;
std::vector<Size> numberCashFlowsThisStep_;
std::vector<std::vector<MarketModelPathwiseMultiProduct::CashFlow> >
cashFlowsGenerated_;
std::vector<MarketModelPathwiseDiscounter> discounters_;
std::vector<Matrix> V_; // one V for each product, with components for each time step and rate
// std::vector<std::vector<std::vector<Real> > > V_; // one V for each product, with components for each time step and rate
Matrix LIBORRatios_; // dimensions are step and rate number
Matrix Discounts_; // dimensions are step and rate number, goes from 0 to n. P(t_0, t_j)
Matrix StepsDiscountsSquared_; // dimensions are step and rate number
Matrix LIBORRates_; // dimensions are step and rate number
Matrix partials_; // dimensions are factor and rate
std::vector<Real> deflatorAndDerivatives_;
std::vector<std::vector<Size> > numberCashFlowsThisIndex_;
std::vector<Matrix> totalCashFlowsThisIndex_; // need product cross times cross which sensitivity
std::vector<std::vector<Size> > cashFlowIndicesThisStep_;
};
//! Engine collecting cash flows along a market-model simulation for doing pathwise computation of Deltas and vegas
// using Giles--Glasserman smoking adjoints method
// note only works with displaced LMM,
//
// The method is intimately connected with log-normal Euler evolution
//
// We must work with discretely compounding MM account
// To compute a vega means changing the pseudo-square root at each time step
// So for each vega, we have a vector of matrices. So we need a vector of vectors of matrices to compute all the vegas.
// We do the outermost vector by time step and inner one by which vega.
// This is tested in MarketModelTest::testPathwiseVegas
class PathwiseVegasAccountingEngine
{
public:
PathwiseVegasAccountingEngine(
ext::shared_ptr<LogNormalFwdRateEuler> evolver, // method relies heavily on LMM Euler
const Clone<MarketModelPathwiseMultiProduct>& product,
ext::shared_ptr<MarketModel>
pseudoRootStructure, // we need pseudo-roots and displacements
const std::vector<std::vector<Matrix> >& VegaBumps,
Real initialNumeraireValue);
void multiplePathValues(std::vector<Real>& means,
std::vector<Real>& errors,
Size numberOfPaths);
private:
Real singlePathValues(std::vector<Real>& values);
ext::shared_ptr<LogNormalFwdRateEuler> evolver_;
Clone<MarketModelPathwiseMultiProduct> product_;
ext::shared_ptr<MarketModel> pseudoRootStructure_;
std::vector<Size> numeraires_;
Real initialNumeraireValue_;
Size numberProducts_;
Size numberRates_;
Size numberCashFlowTimes_;
Size numberSteps_;
Size numberBumps_;
std::vector<RatePseudoRootJacobian> jacobianComputers_;
bool doDeflation_;
// workspace
std::vector<Real> currentForwards_, lastForwards_;
std::vector<Real> numerairesHeld_;
std::vector<Size> numberCashFlowsThisStep_;
std::vector<std::vector<MarketModelPathwiseMultiProduct::CashFlow> >
cashFlowsGenerated_;
std::vector<MarketModelPathwiseDiscounter> discounters_;
std::vector<Matrix> V_; // one V for each product, with components for each time step and rate
Matrix LIBORRatios_; // dimensions are step and rate number
Matrix Discounts_; // dimensions are step and rate number, goes from 0 to n. P(t_0, t_j)
Matrix StepsDiscountsSquared_; // dimensions are step and rate number
std::vector<Real> stepsDiscounts_;
Matrix LIBORRates_; // dimensions are step and rate number
Matrix partials_; // dimensions are factor and rate
Matrix vegasThisPath_; // dimensions are product and which vega
std::vector<Matrix> jacobiansThisPaths_; // dimensions are step, rate and factor
std::vector<Real> deflatorAndDerivatives_;
std::vector<Real> fullDerivatives_;
std::vector<std::vector<Size> > numberCashFlowsThisIndex_;
std::vector<Matrix> totalCashFlowsThisIndex_; // need product cross times cross which sensitivity
std::vector<std::vector<Size> > cashFlowIndicesThisStep_;
};
//! Engine collecting cash flows along a market-model simulation for doing pathwise computation of Deltas and vegas
// using Giles--Glasserman smoking adjoints method
// note only works with displaced LMM,
//
// The method is intimately connected with log-normal Euler evolution
//
// We must work with discretely compounding MM account
// To compute a vega means changing the pseudo-square root at each time step
// So for each vega, we have a vector of matrices. So we need a vector of vectors of matrices to compute all the vegas.
// We do the outermost vector by time step and inner one by which vega.
// This implementation is different in that all the linear combinations by the bumps are done as late as possible,
// whereas PathwiseVegasAccountingEngine does them as early as possible.
// This is tested in MarketModelTest::testPathwiseVegas
class PathwiseVegasOuterAccountingEngine
{
public:
PathwiseVegasOuterAccountingEngine(
ext::shared_ptr<LogNormalFwdRateEuler> evolver, // method relies heavily on LMM Euler
const Clone<MarketModelPathwiseMultiProduct>& product,
ext::shared_ptr<MarketModel>
pseudoRootStructure, // we need pseudo-roots and displacements
const std::vector<std::vector<Matrix> >& VegaBumps,
Real initialNumeraireValue);
//! Use to get vegas with respect to VegaBumps
void multiplePathValues(std::vector<Real>& means,
std::vector<Real>& errors,
Size numberOfPaths);
//! Use to get vegas with respect to pseudo-root-elements
void multiplePathValuesElementary(std::vector<Real>& means,
std::vector<Real>& errors,
Size numberOfPaths);
private:
Real singlePathValues(std::vector<Real>& values);
ext::shared_ptr<LogNormalFwdRateEuler> evolver_;
Clone<MarketModelPathwiseMultiProduct> product_;
ext::shared_ptr<MarketModel> pseudoRootStructure_;
std::vector<std::vector<Matrix> > vegaBumps_;
std::vector<Size> numeraires_;
Real initialNumeraireValue_;
Size numberProducts_;
Size numberRates_;
Size numberCashFlowTimes_;
Size numberSteps_;
Size factors_;
Size numberBumps_;
Size numberElementaryVegas_;
std::vector<RatePseudoRootJacobianAllElements> jacobianComputers_;
bool doDeflation_;
// workspace
std::vector<Real> currentForwards_, lastForwards_;
std::vector<Real> numerairesHeld_;
std::vector<Size> numberCashFlowsThisStep_;
std::vector<std::vector<MarketModelPathwiseMultiProduct::CashFlow> >
cashFlowsGenerated_;
std::vector<MarketModelPathwiseDiscounter> discounters_;
std::vector<Matrix> V_; // one V for each product, with components for each time step and rate
Matrix LIBORRatios_; // dimensions are step and rate number
Matrix Discounts_; // dimensions are step and rate number, goes from 0 to n. P(t_0, t_j)
Matrix StepsDiscountsSquared_; // dimensions are step and rate number
std::vector<Real> stepsDiscounts_;
Matrix LIBORRates_; // dimensions are step and rate number
Matrix partials_; // dimensions are factor and rate
std::vector<std::vector<Matrix> > elementary_vegas_ThisPath_; // dimensions are product, step, rate and factor
std::vector<std::vector<Matrix> > jacobiansThisPaths_; // dimensions are step, rate, rate and factor
std::vector<Real> deflatorAndDerivatives_;
std::vector<Real> fullDerivatives_;
std::vector<std::vector<Size> > numberCashFlowsThisIndex_;
std::vector<Matrix> totalCashFlowsThisIndex_; // need product cross times cross which sensitivity
std::vector<std::vector<Size> > cashFlowIndicesThisStep_;
/*
// experimental
std::vector<std::vector<Real> > gaussians_;
int distinguishedFactor_;
int distinguishedRate_;
int distinguishedStep_;
*/
};
}
#endif
|
