442 lines
14 KiB
Plaintext
442 lines
14 KiB
Plaintext
@q $Id: global_check.cweb 1830 2008-05-18 20:06:40Z kamenik $ @>
|
|
@q Copyright 2005, Ondra Kamenik @>
|
|
|
|
@ Start of {\tt global\_check.cpp} file.
|
|
|
|
@c
|
|
#include "SymSchurDecomp.h"
|
|
|
|
#include "global_check.h"
|
|
|
|
#include "smolyak.h"
|
|
#include "product.h"
|
|
#include "quasi_mcarlo.h"
|
|
|
|
@<|ResidFunction| constructor code@>;
|
|
@<|ResidFunction| copy constructor code@>;
|
|
@<|ResidFunction| destructor code@>;
|
|
@<|ResidFunction::setYU| code@>;
|
|
@<|ResidFunction::eval| code@>;
|
|
@<|GlobalChecker::check| vector code@>;
|
|
@<|GlobalChecker::check| matrix code@>;
|
|
@<|GlobalChecker::checkAlongShocksAndSave| code@>;
|
|
@<|GlobalChecker::checkOnEllipseAndSave| code@>;
|
|
@<|GlobalChecker::checkAlongSimulationAndSave| code@>;
|
|
|
|
@ Here we just set a reference to the approximation, and create a new
|
|
|DynamicModel|.
|
|
|
|
@<|ResidFunction| constructor code@>=
|
|
ResidFunction::ResidFunction(const Approximation& app)
|
|
: VectorFunction(app.getModel().nexog(), app.getModel().numeq()), approx(app),
|
|
model(app.getModel().clone()),
|
|
yplus(NULL), ystar(NULL), u(NULL), hss(NULL)
|
|
{
|
|
}
|
|
|
|
@
|
|
@<|ResidFunction| copy constructor code@>=
|
|
ResidFunction::ResidFunction(const ResidFunction& rf)
|
|
: VectorFunction(rf), approx(rf.approx), model(rf.model->clone()),
|
|
yplus(NULL), ystar(NULL), u(NULL), hss(NULL)
|
|
{
|
|
if (rf.yplus)
|
|
yplus = new Vector(*(rf.yplus));
|
|
if (rf.ystar)
|
|
ystar = new Vector(*(rf.ystar));
|
|
if (rf.u)
|
|
u = new Vector(*(rf.u));
|
|
if (rf.hss)
|
|
hss = new FTensorPolynomial(*(rf.hss));
|
|
}
|
|
|
|
|
|
@
|
|
@<|ResidFunction| destructor code@>=
|
|
ResidFunction::~ResidFunction()
|
|
{
|
|
delete model;
|
|
@<delete |y| and |u| dependent data@>;
|
|
}
|
|
|
|
@
|
|
@<delete |y| and |u| dependent data@>=
|
|
if (yplus)
|
|
delete yplus;
|
|
if (ystar)
|
|
delete ystar;
|
|
if (u)
|
|
delete u;
|
|
if (hss)
|
|
delete hss;
|
|
|
|
|
|
@ This sets $y^*$ and $u$. We have to create |ystar|, |u|, |yplus| and
|
|
|hss|.
|
|
|
|
@<|ResidFunction::setYU| code@>=
|
|
void ResidFunction::setYU(const Vector& ys, const Vector& xx)
|
|
{
|
|
@<delete |y| and |u| dependent data@>;
|
|
|
|
ystar = new Vector(ys);
|
|
u = new Vector(xx);
|
|
yplus = new Vector(model->numeq());
|
|
approx.getFoldDecisionRule().evaluate(DecisionRule::horner,
|
|
*yplus, *ystar, *u);
|
|
|
|
@<make a tensor polynomial of in-place subtensors from decision rule@>;
|
|
@<make |ytmp_star| be a difference of |yplus| from steady@>;
|
|
@<make |hss| and add steady to it@>;
|
|
}
|
|
|
|
@ Here we use a dirty tricky of converting |const| to non-|const| to
|
|
obtain a polynomial of subtensor corresponding to non-predetermined
|
|
variables. However, this new non-|const| polynomial will be used for a
|
|
construction of |hss| and will be used in |const| context. So this
|
|
dirty thing is safe.
|
|
|
|
Note, that there is always a folded decision rule in |Approximation|.
|
|
|
|
@<make a tensor polynomial of in-place subtensors from decision rule@>=
|
|
union {const FoldDecisionRule* c; FoldDecisionRule* n;} dr;
|
|
dr.c = &(approx.getFoldDecisionRule());
|
|
FTensorPolynomial dr_ss(model->nstat()+model->npred(), model->nboth()+model->nforw(),
|
|
*(dr.n));
|
|
|
|
@
|
|
@<make |ytmp_star| be a difference of |yplus| from steady@>=
|
|
Vector ytmp_star(ConstVector(*yplus, model->nstat(), model->npred()+model->nboth()));
|
|
ConstVector ysteady_star(dr.c->getSteady(), model->nstat(),
|
|
model->npred()+model->nboth());
|
|
ytmp_star.add(-1.0, ysteady_star);
|
|
|
|
@ Here is the |const| context of |dr_ss|.
|
|
@<make |hss| and add steady to it@>=
|
|
hss = new FTensorPolynomial(dr_ss, ytmp_star);
|
|
ConstVector ysteady_ss(dr.c->getSteady(), model->nstat()+model->npred(),
|
|
model->nboth()+model->nforw());
|
|
if (hss->check(Symmetry(0))) {
|
|
hss->get(Symmetry(0))->getData().add(1.0, ysteady_ss);
|
|
} else {
|
|
FFSTensor* ten = new FFSTensor(hss->nrows(), hss->nvars(), 0);
|
|
ten->getData() = ysteady_ss;
|
|
hss->insert(ten);
|
|
}
|
|
|
|
@ Here we evaluate the residual $F(y^*,u,u')$. We have to evaluate |hss|
|
|
for $u'=$|point| and then we evaluate the system $f$.
|
|
|
|
@<|ResidFunction::eval| code@>=
|
|
void ResidFunction::eval(const Vector& point, const ParameterSignal& sig, Vector& out)
|
|
{
|
|
KORD_RAISE_IF(point.length() != hss->nvars(),
|
|
"Wrong dimension of input vector in ResidFunction::eval");
|
|
KORD_RAISE_IF(out.length() != model->numeq(),
|
|
"Wrong dimension of output vector in ResidFunction::eval");
|
|
Vector yss(hss->nrows());
|
|
hss->evalHorner(yss, point);
|
|
model->evaluateSystem(out, *ystar, *yplus, yss, *u);
|
|
}
|
|
|
|
@ This checks the $E[F(y^*,u,u')]$ for a given $y^*$ and $u$ by
|
|
integrating with a given quadrature. Note that the input |ys| is $y^*$
|
|
not whole $y$.
|
|
|
|
@<|GlobalChecker::check| vector code@>=
|
|
void GlobalChecker::check(const Quadrature& quad, int level,
|
|
const ConstVector& ys, const ConstVector& x, Vector& out)
|
|
{
|
|
for (int ifunc = 0; ifunc < vfs.getNum(); ifunc++)
|
|
((GResidFunction&)(vfs.getFunc(ifunc))).setYU(ys, x);
|
|
quad.integrate(vfs, level, out);
|
|
}
|
|
|
|
@ This method is a bulk version of |@<|GlobalChecker::check| vector
|
|
code@>|. It decides between Smolyak and product quadrature according
|
|
to |max_evals| constraint.
|
|
|
|
Note that |y| can be either full (all endogenous variables including
|
|
static and forward looking), or just $y^*$ (state variables). The
|
|
method is able to recognize it.
|
|
|
|
@<|GlobalChecker::check| matrix code@>=
|
|
void GlobalChecker::check(int max_evals, const ConstTwoDMatrix& y,
|
|
const ConstTwoDMatrix& x, TwoDMatrix& out)
|
|
{
|
|
JournalRecordPair pa(journal);
|
|
pa << "Checking approximation error for " << y.ncols()
|
|
<< " states with at most " << max_evals << " evaluations" << endrec;
|
|
|
|
@<decide about type of quadrature@>;
|
|
Quadrature* quad;
|
|
int lev;
|
|
@<create the quadrature and report the decision@>;
|
|
@<check all column of |y| and |x|@>;
|
|
delete quad;
|
|
}
|
|
|
|
@
|
|
@<decide about type of quadrature@>=
|
|
GaussHermite gh;
|
|
|
|
SmolyakQuadrature dummy_sq(model.nexog(), 1, gh);
|
|
int smol_evals;
|
|
int smol_level;
|
|
dummy_sq.designLevelForEvals(max_evals, smol_level, smol_evals);
|
|
|
|
ProductQuadrature dummy_pq(model.nexog(), gh);
|
|
int prod_evals;
|
|
int prod_level;
|
|
dummy_pq.designLevelForEvals(max_evals, prod_level, prod_evals);
|
|
|
|
bool take_smolyak = (smol_evals < prod_evals) && (smol_level >= prod_level-1);
|
|
|
|
@
|
|
@<create the quadrature and report the decision@>=
|
|
if (take_smolyak) {
|
|
quad = new SmolyakQuadrature(model.nexog(), smol_level, gh);
|
|
lev = smol_level;
|
|
JournalRecord rec(journal);
|
|
rec << "Selected Smolyak (level,evals)=(" << smol_level << ","
|
|
<< smol_evals << ") over product (" << prod_level << ","
|
|
<< prod_evals << ")" << endrec;
|
|
} else {
|
|
quad = new ProductQuadrature(model.nexog(), gh);
|
|
lev = prod_level;
|
|
JournalRecord rec(journal);
|
|
rec << "Selected product (level,evals)=(" << prod_level << ","
|
|
<< prod_evals << ") over Smolyak (" << smol_level << ","
|
|
<< smol_evals << ")" << endrec;
|
|
}
|
|
|
|
@
|
|
@<check all column of |y| and |x|@>=
|
|
int first_row = (y.nrows() == model.numeq())? model.nstat() : 0;
|
|
ConstTwoDMatrix ysmat(y, first_row, 0, model.npred()+model.nboth(), y.ncols());
|
|
for (int j = 0; j < y.ncols(); j++) {
|
|
ConstVector yj(ysmat, j);
|
|
ConstVector xj(x, j);
|
|
Vector outj(out, j);
|
|
check(*quad, lev, yj, xj, outj);
|
|
}
|
|
|
|
|
|
|
|
@ This method checks an error of the approximation by evaluating
|
|
residual $E[F(y^*,u,u')\vert y^*,u]$ for $y^*$ being the steady state, and
|
|
changing $u$. We go through all elements of $u$ and vary them from
|
|
$-mult\cdot\sigma$ to $mult\cdot\sigma$ in |m| steps.
|
|
|
|
@<|GlobalChecker::checkAlongShocksAndSave| code@>=
|
|
void GlobalChecker::checkAlongShocksAndSave(mat_t* fd, const char* prefix,
|
|
int m, double mult, int max_evals)
|
|
{
|
|
JournalRecordPair pa(journal);
|
|
pa << "Calculating errors along shocks +/- "
|
|
<< mult << " std errors, granularity " << m << endrec;
|
|
@<setup |y_mat| of steady states for checking@>;
|
|
@<setup |exo_mat| for checking@>;
|
|
|
|
TwoDMatrix errors(model.numeq(), 2*m*model.nexog()+1);
|
|
check(max_evals, y_mat, exo_mat, errors);
|
|
|
|
@<report errors along shock and save them@>;
|
|
}
|
|
|
|
@
|
|
@<setup |y_mat| of steady states for checking@>=
|
|
TwoDMatrix y_mat(model.numeq(), 2*m*model.nexog()+1);
|
|
for (int j = 0; j < 2*m*model.nexog()+1; j++) {
|
|
Vector yj(y_mat, j);
|
|
yj = (const Vector&)model.getSteady();
|
|
}
|
|
|
|
@
|
|
@<setup |exo_mat| for checking@>=
|
|
TwoDMatrix exo_mat(model.nexog(), 2*m*model.nexog()+1);
|
|
exo_mat.zeros();
|
|
for (int ishock = 0; ishock < model.nexog(); ishock++) {
|
|
double max_sigma = sqrt(model.getVcov().get(ishock,ishock));
|
|
for (int j = 0; j < 2*m; j++) {
|
|
int jmult = (j < m)? j-m: j-m+1;
|
|
exo_mat.get(ishock, 1+2*m*ishock+j) =
|
|
mult*jmult*max_sigma/m;
|
|
}
|
|
}
|
|
|
|
@
|
|
@<report errors along shock and save them@>=
|
|
TwoDMatrix res(model.nexog(), 2*m+1);
|
|
JournalRecord rec(journal);
|
|
rec << "Shock value error" << endrec;
|
|
ConstVector err0(errors,0);
|
|
char shock[9];
|
|
char erbuf[17];
|
|
for (int ishock = 0; ishock < model.nexog(); ishock++) {
|
|
TwoDMatrix err_out(model.numeq(), 2*m+1);
|
|
sprintf(shock, "%-8s", model.getExogNames().getName(ishock));
|
|
for (int j = 0; j < 2*m+1; j++) {
|
|
int jj;
|
|
Vector error(err_out, j);
|
|
if (j != m) {
|
|
if (j < m)
|
|
jj = 1 + 2*m*ishock+j;
|
|
else
|
|
jj = 1 + 2*m*ishock+j-1;
|
|
ConstVector coljj(errors,jj);
|
|
error = coljj;
|
|
} else {
|
|
jj = 0;
|
|
error = err0;
|
|
}
|
|
JournalRecord rec1(journal);
|
|
sprintf(erbuf,"%12.7g ", error.getMax());
|
|
rec1 << shock << " " << exo_mat.get(ishock,jj)
|
|
<< "\t" << erbuf << endrec;
|
|
}
|
|
char tmp[100];
|
|
sprintf(tmp, "%s_shock_%s_errors", prefix, model.getExogNames().getName(ishock));
|
|
err_out.writeMat(fd, tmp);
|
|
}
|
|
|
|
|
|
@ This method checks errors on ellipse of endogenous states
|
|
(predetermined variables). The ellipse is shaped according to
|
|
covariance matrix of endogenous variables based on the first order
|
|
approximation and scaled by |mult|. The points on the
|
|
ellipse are chosen as polar images of the low discrepancy grid in a
|
|
cube.
|
|
|
|
The method works as follows: First we calculate symmetric Schur factor of
|
|
covariance matrix of the states. Second we generate low discrepancy
|
|
points on the unit sphere. Third we transform the sphere with the
|
|
variance-covariance matrix factor and multiplier |mult| and initialize
|
|
matrix of $u_t$ to zeros. Fourth we run the |check| method and save
|
|
the results.
|
|
|
|
@<|GlobalChecker::checkOnEllipseAndSave| code@>=
|
|
void GlobalChecker::checkOnEllipseAndSave(mat_t* fd, const char* prefix,
|
|
int m, double mult, int max_evals)
|
|
{
|
|
JournalRecordPair pa(journal);
|
|
pa << "Calculating errors at " << m
|
|
<< " ellipse points scaled by " << mult << endrec;
|
|
@<make factor of covariance of variables@>;
|
|
@<put low discrepancy sphere points to |ymat|@>;
|
|
@<transform sphere |ymat| and prepare |umat| for checking@>;
|
|
@<check on ellipse and save@>;
|
|
}
|
|
|
|
|
|
@ Here we set |ycovfac| to the symmetric Schur decomposition factor of
|
|
a submatrix of covariances of all endogenous variables. The submatrix
|
|
corresponds to state variables (predetermined plus both).
|
|
|
|
@<make factor of covariance of variables@>=
|
|
TwoDMatrix* ycov = approx.calcYCov();
|
|
TwoDMatrix ycovpred((const TwoDMatrix&)*ycov, model.nstat(), model.nstat(),
|
|
model.npred()+model.nboth(), model.npred()+model.nboth());
|
|
delete ycov;
|
|
SymSchurDecomp ssd(ycovpred);
|
|
ssd.correctDefinitness(1.e-05);
|
|
TwoDMatrix ycovfac(ycovpred.nrows(), ycovpred.ncols());
|
|
KORD_RAISE_IF(! ssd.isPositiveSemidefinite(),
|
|
"Covariance matrix of the states not positive \
|
|
semidefinite in GlobalChecker::checkOnEllipseAndSave");
|
|
ssd.getFactor(ycovfac);
|
|
|
|
|
|
@ Here we first calculate dimension |d| of the sphere, which is a
|
|
number of state variables minus one. We go through the |d|-dimensional
|
|
cube $\langle 0,1\rangle^d$ by |QMCarloCubeQuadrature| and make a
|
|
polar transformation to the sphere. The polar transformation $f^i$ can
|
|
be written recursively wrt. the dimension $i$ as:
|
|
$$\eqalign{
|
|
f^0() &= \left[1\right]\cr
|
|
f^i(x_1,\ldots,x_i) &=
|
|
\left[\matrix{cos(2\pi x_i)\cdot f^{i-1}(x_1,\ldots,x_{i-1})\cr sin(2\pi x_i)}\right]
|
|
}$$
|
|
|
|
@<put low discrepancy sphere points to |ymat|@>=
|
|
int d = model.npred()+model.nboth()-1;
|
|
TwoDMatrix ymat(model.npred()+model.nboth(), (d==0)? 2:m);
|
|
if (d == 0) {
|
|
ymat.get(0,0) = 1;
|
|
ymat.get(0,1) = -1;
|
|
} else {
|
|
int icol = 0;
|
|
ReversePerScheme ps;
|
|
QMCarloCubeQuadrature qmc(d, m, ps);
|
|
qmcpit beg = qmc.start(m);
|
|
qmcpit end = qmc.end(m);
|
|
for (qmcpit run = beg; run != end; ++run, icol++) {
|
|
Vector ycol(ymat, icol);
|
|
Vector x(run.point());
|
|
x.mult(2*M_PI);
|
|
ycol[0] = 1;
|
|
for (int i = 0; i < d; i++) {
|
|
Vector subsphere(ycol, 0, i+1);
|
|
subsphere.mult(cos(x[i]));
|
|
ycol[i+1] = sin(x[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
@ Here we multiply the sphere points in |ymat| with the Cholesky
|
|
factor to obtain the ellipse, scale the ellipse by the given |mult|,
|
|
and initialize matrix of shocks |umat| to zero.
|
|
|
|
@<transform sphere |ymat| and prepare |umat| for checking@>=
|
|
TwoDMatrix umat(model.nexog(), ymat.ncols());
|
|
umat.zeros();
|
|
ymat.mult(mult);
|
|
ymat.multLeft(ycovfac);
|
|
ConstVector ys(model.getSteady(), model.nstat(),
|
|
model.npred()+model.nboth());
|
|
for (int icol = 0; icol < ymat.ncols(); icol++) {
|
|
Vector ycol(ymat, icol);
|
|
ycol.add(1.0, ys);
|
|
}
|
|
|
|
@ Here we check the points and save the results to MAT-4 file.
|
|
@<check on ellipse and save@>=
|
|
TwoDMatrix out(model.numeq(), ymat.ncols());
|
|
check(max_evals, ymat, umat, out);
|
|
|
|
char tmp[100];
|
|
sprintf(tmp, "%s_ellipse_points", prefix);
|
|
ymat.writeMat(fd, tmp);
|
|
sprintf(tmp, "%s_ellipse_errors", prefix);
|
|
out.writeMat(fd, tmp);
|
|
|
|
@ Here we check the errors along a simulation. We simulate, then set
|
|
|x| to zeros, check and save results.
|
|
|
|
@<|GlobalChecker::checkAlongSimulationAndSave| code@>=
|
|
void GlobalChecker::checkAlongSimulationAndSave(mat_t* fd, const char* prefix,
|
|
int m, int max_evals)
|
|
{
|
|
JournalRecordPair pa(journal);
|
|
pa << "Calculating errors at " << m
|
|
<< " simulated points" << endrec;
|
|
RandomShockRealization sr(model.getVcov(), system_random_generator.int_uniform());
|
|
TwoDMatrix* y = approx.getFoldDecisionRule().simulate(DecisionRule::horner,
|
|
m, model.getSteady(), sr);
|
|
TwoDMatrix x(model.nexog(), m);
|
|
x.zeros();
|
|
TwoDMatrix out(model.numeq(), m);
|
|
check(max_evals, *y, x, out);
|
|
|
|
char tmp[100];
|
|
sprintf(tmp, "%s_simul_points", prefix);
|
|
y->writeMat(fd, tmp);
|
|
sprintf(tmp, "%s_simul_errors", prefix);
|
|
out.writeMat(fd, tmp);
|
|
|
|
delete y;
|
|
}
|
|
|
|
|
|
@ End of {\tt global\_check.cpp} file.
|