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
|
/*
* Copyright © 2005 Ondra Kamenik
* Copyright © 2019 Dynare Team
*
* This file is part of Dynare.
*
* Dynare is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Dynare 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
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Dynare. If not, see <https://www.gnu.org/licenses/>.
*/
// Dynamic model abstraction
/* This file only defines a generic interface to a DSGE model. The model
takes the form:
𝔼ₜ(f(g**(g*(y,uₜ),uₜ₊₁),g(y,uₜ),yₜ,uₜ)) = 0
The interface is defined via pure virtual class DynamicModel. */
#ifndef DYNAMIC_MODEL_H
#define DYNAMIC_MODEL_H
#include "t_container.hh"
#include "sparse_tensor.hh"
#include "Vector.hh"
#include <memory>
#include <string>
/* The class is a virtual pure class which provides an access to names
of the variables. */
class NameList
{
public:
virtual ~NameList() = default;
virtual int getNum() const = 0;
virtual const std::string &getName(int i) const = 0;
void print() const;
void writeMat(mat_t *fd, const std::string &vname) const;
void writeMatIndices(mat_t *fd, const std::string &prefix) const;
};
/* This is the interface to an information on a generic DSGE model. It is
sufficient for calculations of policy rule Taylor approximations at some
(not necessarily deterministic) steady state.
We need to know a partitioning of endogenous variables y. We suppose that y
is partitioned as:
⎡ static⎤
⎢ pred ⎥
y = ⎢ both ⎥
⎣forward⎦
of which we define:
⎡pred⎤ ⎡ both ⎤
y* = ⎣both⎦ y** = ⎣forward⎦
where “static” are meant those variables, which appear only at time t;
“pred” are meant those variables, which appear only at t and t−1; “both” are
meant those variables, which appear at least at t−1 and t+1; and “forward”
are meant those variables, which appear only at t and t+1. This partitioning
is given by methods nstat(), npred(), nboth(), and nforw(). The number of
equations numeq() must be the same as a number of endogenous variables.
In order to complete description, we need to know a number of exogenous
variables, which is a size of u, hence nexog() method.
The model contains an information about names of variables, the
variance-covariance matrix of the shocks, the derivatives of equations of f
at some steady state, and the steady state. These can be retrieved by the
corresponding methods.
The derivatives of the system are calculated with respect to stacked
variables, the stack looks like:
⎡y**ₜ₊₁⎤
⎢ yₜ ⎥
⎢ y*ₜ₋₁⎥
⎣ uₜ ⎦
There are only three operations. The first solveDeterministicSteady() solves
the deterministic steady steate which can be retrieved by getSteady() later.
The method evaluateSystem() calculates f(y**,y,y*,u), where y and u are
passed, or f(y**ₜ₊₁, yₜ, y*ₜ₋₁, u), where y**ₜ₊₁, yₜ, y*ₜ₋₁, u are passed.
Finally, the method calcDerivativesAtSteady() calculates derivatives of f at
the current steady state, and zero shocks. The derivatives can be retrieved
with getModelDerivatives(). All the derivatives are done up to a given order
in the model, which can be retrieved by order().
The model initialization is done in a constructor of the implementing class.
The constructor usually calls a parser, which parses a given file (usually a
text file), and retrieves all necessary information about the model,
inluding variables, partitioning, variance-covariance matrix, information
helpful for calculation of the deterministic steady state, and so on. */
class DynamicModel
{
public:
virtual std::unique_ptr<DynamicModel> clone() const = 0;
virtual ~DynamicModel() = default;
virtual int nstat() const = 0;
virtual int nboth() const = 0;
virtual int npred() const = 0;
virtual int nforw() const = 0;
virtual int nexog() const = 0;
virtual int order() const = 0;
int
numeq() const
{
return nstat()+nboth()+npred()+nforw();
}
virtual const NameList &getAllEndoNames() const = 0;
virtual const NameList &getStateNames() const = 0;
virtual const NameList &getExogNames() const = 0;
virtual const TwoDMatrix &getVcov() const = 0;
virtual const TensorContainer<FSSparseTensor> &getModelDerivatives() const = 0;
virtual const Vector &getSteady() const = 0;
virtual Vector &getSteady() = 0;
virtual void solveDeterministicSteady() = 0;
virtual void evaluateSystem(Vector &out, const ConstVector &yy, const Vector &xx) = 0;
virtual void evaluateSystem(Vector &out, const ConstVector &yym, const ConstVector &yy,
const ConstVector &yyp, const Vector &xx) = 0;
virtual void calcDerivativesAtSteady() = 0;
};
#endif
|
