Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found
Select Git revision
Loading items

Target

Select target project
  • giovanma/dynare
  • giorgiomas/dynare
  • Vermandel/dynare
  • Dynare/dynare
  • normann/dynare
  • MichelJuillard/dynare
  • wmutschl/dynare
  • FerhatMihoubi/dynare
  • sebastien/dynare
  • lnsongxf/dynare
  • rattoma/dynare
  • CIMERS/dynare
  • FredericKarame/dynare
  • SumuduK/dynare
  • MinjeJeon/dynare
  • camilomrch/dynare
  • DoraK/dynare
  • avtishin/dynare
  • selma/dynare
  • claudio_olguin/dynare
  • jeffjiang07/dynare
  • EthanSystem/dynare
  • stepan-a/dynare
  • wjgatt/dynare
  • JohannesPfeifer/dynare
  • gboehl/dynare
  • chskcau/dynare-doc-fixes
27 results
Select Git revision
Loading items
Show changes
Showing
with 0 additions and 2445 deletions
noinst_LIBRARIES = libsylv.a
# For dynblas.h and dynlapack.h
libsylv_a_CPPFLAGS = -I$(top_srcdir)/mex/sources
libsylv_a_SOURCES = \
BlockDiagonal.cc \
BlockDiagonal.hh \
GeneralMatrix.cc \
GeneralMatrix.hh \
GeneralSylvester.cc \
GeneralSylvester.hh \
IterativeSylvester.cc \
IterativeSylvester.hh \
KronUtils.cc \
KronUtils.hh \
KronVector.cc \
KronVector.hh \
QuasiTriangular.cc \
QuasiTriangular.hh \
QuasiTriangularZero.cc \
QuasiTriangularZero.hh \
SchurDecomp.cc \
SchurDecomp.hh \
SchurDecompEig.cc \
SchurDecompEig.hh \
SimilarityDecomp.cc \
SimilarityDecomp.hh \
SylvException.cc \
SylvException.hh \
SylvMatrix.cc \
SylvMatrix.hh \
SylvParams.cc \
SylvParams.hh \
SylvesterSolver.hh \
SymSchurDecomp.cc \
SymSchurDecomp.hh \
TriangularSylvester.cc \
TriangularSylvester.hh \
Vector.cc \
Vector.hh
/* $Header: /var/lib/cvs/dynare_cpp/sylv/cc/QuasiTriangularZero.h,v 1.1.1.1 2004/06/04 13:00:44 kamenik Exp $ */
/* Tag $Name: $ */
#ifndef QUASI_TRIANGULAR_ZERO_H
#define QUASI_TRIANGULAR_ZERO_H
#include "QuasiTriangular.hh"
#include "GeneralMatrix.hh"
#include <memory>
class QuasiTriangularZero : public QuasiTriangular
{
int nz; // number of zero columns
GeneralMatrix ru; // data in right upper part (nz,d_size)
public:
QuasiTriangularZero(int num_zeros, const ConstVector &d, int d_size);
QuasiTriangularZero(double r, const QuasiTriangularZero &t);
QuasiTriangularZero(double r, const QuasiTriangularZero &t,
double rr, const QuasiTriangularZero &tt);
QuasiTriangularZero(int p, const QuasiTriangularZero &t);
QuasiTriangularZero(const QuasiTriangular &t);
QuasiTriangularZero(const SchurDecompZero &decomp);
~QuasiTriangularZero() override = default;
void solvePre(Vector &x, double &eig_min) override;
void solvePreTrans(Vector &x, double &eig_min) override;
void multVec(Vector &x, const ConstVector &b) const override;
void multVecTrans(Vector &x, const ConstVector &b) const override;
void multaVec(Vector &x, const ConstVector &b) const override;
void multaVecTrans(Vector &x, const ConstVector &b) const override;
void multKron(KronVector &x) const override;
void multKronTrans(KronVector &x) const override;
void multLeftOther(GeneralMatrix &a) const override;
/* clone */
std::unique_ptr<QuasiTriangular>
clone() const override
{
return std::make_unique<QuasiTriangularZero>(*this);
}
std::unique_ptr<QuasiTriangular>
clone(int p, const QuasiTriangular &t) const override
{
return std::make_unique<QuasiTriangularZero>(p, (const QuasiTriangularZero &) t);
}
std::unique_ptr<QuasiTriangular>
clone(double r) const override
{
return std::make_unique<QuasiTriangularZero>(r, *this);
}
std::unique_ptr<QuasiTriangular>
clone(double r, double rr, const QuasiTriangular &tt) const override
{
return std::make_unique<QuasiTriangularZero>(r, *this, rr, (const QuasiTriangularZero &) tt);
}
void print() const override;
};
#endif /* QUASI_TRIANGULAR_ZERO_H */
/* $Header: /var/lib/cvs/dynare_cpp/sylv/cc/SchurDecomp.cpp,v 1.1.1.1 2004/06/04 13:00:44 kamenik Exp $ */
/* Tag $Name: $ */
#include "SchurDecomp.hh"
#include <vector>
#include <dynlapack.h>
SchurDecomp::SchurDecomp(const SqSylvMatrix &m)
: q(m.numRows())
{
lapack_int rows = m.numRows();
SqSylvMatrix auxt(m);
lapack_int lda = auxt.getLD(), ldvs = q.getLD();
lapack_int sdim;
std::vector<double> wr(rows), wi(rows);
lapack_int lwork = 6*rows;
std::vector<double> work(lwork);
lapack_int info;
dgees("V", "N", nullptr, &rows, auxt.base(), &lda, &sdim,
wr.data(), wi.data(), q.base(), &ldvs,
work.data(), &lwork, nullptr, &info);
t_storage = std::make_unique<QuasiTriangular>(auxt.getData(), rows);
t = t_storage.get();
}
SchurDecomp::SchurDecomp(const QuasiTriangular &tr)
: q(tr.numRows()), t_storage{std::make_unique<QuasiTriangular>(tr)}, t{t_storage.get()}
{
q.setUnit();
}
SchurDecomp::SchurDecomp(QuasiTriangular &tr)
: q(tr.numRows()), t{&tr}
{
q.setUnit();
}
int
SchurDecomp::getDim() const
{
return t->numRows();
}
SchurDecompZero::SchurDecompZero(const GeneralMatrix &m)
: SchurDecomp(SqSylvMatrix(m, m.numRows()-m.numCols(), 0, m.numCols())),
ru(m, 0, 0, m.numRows()-m.numCols(), m.numCols())
{
ru.multRight(getQ());
}
int
SchurDecompZero::getDim() const
{
return getT().numRows()+ru.numRows();
}
/* $Header: /var/lib/cvs/dynare_cpp/sylv/cc/SchurDecomp.h,v 1.1.1.1 2004/06/04 13:00:44 kamenik Exp $ */
/* Tag $Name: $ */
#ifndef SCHUR_DECOMP_H
#define SCHUR_DECOMP_H
#include "SylvMatrix.hh"
#include "QuasiTriangular.hh"
#include <memory>
class QuasiTriangular;
class SchurDecomp
{
SqSylvMatrix q;
// Stores t if is owned
std::unique_ptr<QuasiTriangular> t_storage;
QuasiTriangular *t;
public:
SchurDecomp(const SqSylvMatrix &m);
SchurDecomp(const QuasiTriangular &tr);
SchurDecomp(QuasiTriangular &tr);
const SqSylvMatrix &
getQ() const
{
return q;
}
const QuasiTriangular &
getT() const
{
return *t;
}
SqSylvMatrix &
getQ()
{
return q;
}
QuasiTriangular &
getT()
{
return *t;
}
virtual int getDim() const;
virtual ~SchurDecomp() = default;
};
class SchurDecompZero : public SchurDecomp
{
GeneralMatrix ru; /* right upper matrix */
public:
SchurDecompZero(const GeneralMatrix &m);
ConstGeneralMatrix
getRU() const
{
return ru;
}
int getDim() const override;
int
getZeroCols() const
{
return ru.numRows();
}
};
#endif /* SCHUR_DECOMP_H */
/* $Header: /var/lib/cvs/dynare_cpp/sylv/cc/SchurDecompEig.h,v 1.1.1.1 2004/06/04 13:00:44 kamenik Exp $ */
/* Tag $Name: $ */
// contains algorithms for eigenvalue reordering
#ifndef SCHUR_DECOMP_EIG_H
#define SCHUR_DECOMP_EIG_H
#include "SchurDecomp.hh"
#include "QuasiTriangular.hh"
class SchurDecompEig : public SchurDecomp
{
public:
using diag_iter = QuasiTriangular::diag_iter;
SchurDecompEig(const SqSylvMatrix &m) : SchurDecomp(m)
{
}
SchurDecompEig(const QuasiTriangular &tr) : SchurDecomp(tr)
{
};
SchurDecompEig(QuasiTriangular &tr) : SchurDecomp(tr)
{
}
diag_iter bubbleEigen(diag_iter from, diag_iter to);
void orderEigen();
protected:
bool tryToSwap(diag_iter &it, diag_iter &itadd);
};
#endif /* SCHUR_DECOMP_EIG_H */
/* $Header: /var/lib/cvs/dynare_cpp/sylv/cc/SylvMatrix.h,v 1.1.1.1 2004/06/04 13:00:44 kamenik Exp $ */
/* Tag $Name: $ */
#ifndef SYLV_MATRIX_H
#define SYLV_MATRIX_H
#include "GeneralMatrix.hh"
#include "KronVector.hh"
#include <utility>
class SqSylvMatrix;
class SylvMatrix : public GeneralMatrix
{
public:
SylvMatrix(int m, int n)
: GeneralMatrix(m, n)
{
}
SylvMatrix(Vector d, int m, int n)
: GeneralMatrix(std::move(d), m, n)
{
}
SylvMatrix(const GeneralMatrix &m)
: GeneralMatrix(m)
{
}
SylvMatrix(const GeneralMatrix &m, int i, int j, int nrows, int ncols)
: GeneralMatrix(m, i, j, nrows, ncols)
{
}
SylvMatrix(GeneralMatrix &m, int i, int j, int nrows, int ncols)
: GeneralMatrix(m, i, j, nrows, ncols)
{
}
SylvMatrix(const GeneralMatrix &a, const GeneralMatrix &b)
: GeneralMatrix(a, b)
{
}
SylvMatrix(const SylvMatrix &m) = default;
SylvMatrix(SylvMatrix &&m) = default;
SylvMatrix &operator=(const SylvMatrix &m) = default;
SylvMatrix &operator=(SylvMatrix &&m) = default;
/* this = |I 0|* this
|0 m| */
void multLeftI(const SqSylvMatrix &m);
/* this = |I 0|* this
|0 m'| */
void multLeftITrans(const SqSylvMatrix &m);
/* this = |0 a|*b, so that |0 a| is square */
void multLeft(int zero_cols, const GeneralMatrix &a, const GeneralMatrix &b);
/* this = this * (m\otimes m..\otimes m) */
void multRightKron(const SqSylvMatrix &m, int order);
/* this = this * (m'\otimes m'..\otimes m') */
void multRightKronTrans(const SqSylvMatrix &m, int order);
/* this = P*this, x = P*x, where P is gauss transformation setting
* a given element to zero */
void eliminateLeft(int row, int col, Vector &x);
/* this = this*P, x = P'*x, where P is gauss transformation setting
* a given element to zero */
void eliminateRight(int row, int col, Vector &x);
};
class SqSylvMatrix : public SylvMatrix
{
public:
SqSylvMatrix(int m) : SylvMatrix(m, m)
{
}
SqSylvMatrix(Vector d, int m) : SylvMatrix(std::move(d), m, m)
{
}
SqSylvMatrix(const SqSylvMatrix &m) = default;
SqSylvMatrix(SqSylvMatrix &&m) = default;
SqSylvMatrix(const GeneralMatrix &m, int i, int j, int nrows)
: SylvMatrix(m, i, j, nrows, nrows)
{
}
SqSylvMatrix(GeneralMatrix &m, int i, int j, int nrows)
: SylvMatrix(m, i, j, nrows, nrows)
{
}
SqSylvMatrix(const GeneralMatrix &a, const GeneralMatrix &b);
SqSylvMatrix &operator=(const SqSylvMatrix &m) = default;
SqSylvMatrix &operator=(SqSylvMatrix &&m) = default;
/* x = (this \otimes this..\otimes this)*d */
void multVecKron(KronVector &x, const ConstKronVector &d) const;
/* x = (this' \otimes this'..\otimes this')*d */
void multVecKronTrans(KronVector &x, const ConstKronVector &d) const;
/* a = inv(this)*a, b=inv(this)*b */
void multInvLeft2(GeneralMatrix &a, GeneralMatrix &b,
double &rcond1, double &rcondinf) const;
/* this = I */
void setUnit();
};
#endif /* SYLV_MATRIX_H */
/* $Header: /var/lib/cvs/dynare_cpp/sylv/cc/SylvesterSolver.h,v 1.1.1.1 2004/06/04 13:00:54 kamenik Exp $ */
/* Tag $Name: $ */
#ifndef SYLVESTER_SOLVER_H
#define SYLVESTER_SOLVER_H
#include "KronVector.hh"
#include "QuasiTriangular.hh"
#include "QuasiTriangularZero.hh"
#include "SimilarityDecomp.hh"
#include "SylvParams.hh"
#include "SchurDecomp.hh"
#include <memory>
class SylvesterSolver
{
protected:
const std::unique_ptr<const QuasiTriangular> matrixK;
const std::unique_ptr<const QuasiTriangular> matrixF;
private:
/* return true when it is more efficient to use QuasiTriangular
* than QuasiTriangularZero */
static bool
zeroPad(const SchurDecompZero &kdecomp)
{
return ((kdecomp.getZeroCols()*3 < kdecomp.getDim()*2)
|| (kdecomp.getZeroCols() < 10));
}
public:
SylvesterSolver(const QuasiTriangular &k, const QuasiTriangular &f)
: matrixK(std::make_unique<QuasiTriangular>(k)),
matrixF(std::make_unique<QuasiTriangular>(f))
{
}
SylvesterSolver(const SchurDecompZero &kdecomp, const SchurDecomp &fdecomp)
: matrixK((zeroPad(kdecomp)) ?
std::make_unique<QuasiTriangular>(kdecomp) :
std::make_unique<QuasiTriangularZero>(kdecomp)),
matrixF(std::make_unique<QuasiTriangular>(fdecomp))
{
}
SylvesterSolver(const SchurDecompZero &kdecomp, const SimilarityDecomp &fdecomp)
: matrixK((zeroPad(kdecomp)) ?
std::make_unique<QuasiTriangular>(kdecomp) :
std::make_unique<QuasiTriangularZero>(kdecomp)),
matrixF(std::make_unique<BlockDiagonal>(fdecomp.getB()))
{
}
virtual ~SylvesterSolver() = default;
virtual void solve(SylvParams &pars, KronVector &x) const = 0;
};
#endif /* SYLVESTER_SOLVER_H */
/* $Header: /var/lib/cvs/dynare_cpp/sylv/cc/SchurDecomp.h,v 1.1.1.1 2004/06/04 13:00:44 kamenik Exp $ */
/* Tag $Name: $ */
#ifndef SYM_SCHUR_DECOMP_H
#define SYM_SCHUR_DECOMP_H
#include "SylvMatrix.hh"
class SymSchurDecomp
{
protected:
Vector lambda;
SqSylvMatrix q;
public:
/** Calculates A = Q*Lambda*Q^T, where A is assummed to be
* symmetric and Lambda real diagonal, hence a vector. */
SymSchurDecomp(const ConstGeneralMatrix &a);
SymSchurDecomp(const SymSchurDecomp &ssd) = default;
virtual ~SymSchurDecomp() = default;
const Vector &
getLambda() const
{
return lambda;
}
const SqSylvMatrix &
getQ() const
{
return q;
}
/** Return factor F*F^T = A, raises and exception if A is not
* positive semidefinite, F must be square. */
void getFactor(GeneralMatrix &f) const;
/** Returns true if A is positive semidefinite. */
bool isPositiveSemidefinite() const;
/** Correct definitness. This sets all eigenvalues between minus
* tolerance and zero to zero. */
void correctDefinitness(double tol);
};
#endif
/* $Header: /var/lib/cvs/dynare_cpp/sylv/cc/TriangularSylvester.h,v 1.1.1.1 2004/06/04 13:01:03 kamenik Exp $ */
/* Tag $Name: $ */
#ifndef TRIANGULAR_SYLVESTER_H
#define TRIANGULAR_SYLVESTER_H
#include "SylvesterSolver.hh"
#include "KronVector.hh"
#include "QuasiTriangular.hh"
#include "QuasiTriangularZero.hh"
#include "SimilarityDecomp.hh"
#include <memory>
class TriangularSylvester : public SylvesterSolver
{
const std::unique_ptr<const QuasiTriangular> matrixKK;
const std::unique_ptr<const QuasiTriangular> matrixFF;
public:
TriangularSylvester(const QuasiTriangular &k, const QuasiTriangular &f);
TriangularSylvester(const SchurDecompZero &kdecomp, const SchurDecomp &fdecomp);
TriangularSylvester(const SchurDecompZero &kdecomp, const SimilarityDecomp &fdecomp);
~TriangularSylvester() override = default;
void print() const;
void solve(SylvParams &pars, KronVector &d) const override;
void solvi(double r, KronVector &d, double &eig_min) const;
void solvii(double alpha, double beta1, double beta2,
KronVector &d1, KronVector &d2,
double &eig_min) const;
void solviip(double alpha, double betas,
KronVector &d, double &eig_min) const;
/* evaluates:
|x1| |d1| |alpha -beta1| |d1|
| | = | |+| |\otimes F'...\otimes K | |
|x2| |d2| |beta2 alpha| |d2|
*/
void linEval(double alpha, double beta1, double beta2,
KronVector &x1, KronVector &x2,
const ConstKronVector &d1, const ConstKronVector &d2) const;
void
linEval(double alpha, double beta1, double beta2,
KronVector &x1, KronVector &x2,
const KronVector &d1, const KronVector &d2) const
{
linEval(alpha, beta1, beta2, x1, x2,
ConstKronVector(d1), ConstKronVector(d2));
}
/* evaluates:
|x1| |d1| |gamma -delta1| |d1|
| | = | | + 2alpha*| |\otimes F'...\otimes K | | +
|x2| |d2| |delta2 gamma| |d2|
|gamma -delta1|^2 |d1|
+ (alpha^2+betas)*| |\otimes F'2...\otimes K2 | |
|delta2 gamma| |d2|
*/
void quaEval(double alpha, double betas,
double gamma, double delta1, double delta2,
KronVector &x1, KronVector &x2,
const ConstKronVector &d1, const ConstKronVector &d2) const;
void
quaEval(double alpha, double betas,
double gamma, double delta1, double delta2,
KronVector &x1, KronVector &x2,
const KronVector &d1, const KronVector &d2) const
{
quaEval(alpha, betas, gamma, delta1, delta2, x1, x2,
ConstKronVector(d1), ConstKronVector(d2));
}
private:
/* returns square of size of minimal eigenvalue of the system solved,
now obsolete */
double getEigSep(int depth) const;
/* recursivelly calculates kronecker product of complex vectors (used in getEigSep) */
static void multEigVector(KronVector &eig, const Vector &feig, const Vector &keig);
/* auxiliary typedefs */
using const_diag_iter = QuasiTriangular::const_diag_iter;
using const_row_iter = QuasiTriangular::const_row_iter;
/* called from solvi */
void solviRealAndEliminate(double r, const_diag_iter di,
KronVector &d, double &eig_min) const;
void solviComplexAndEliminate(double r, const_diag_iter di,
KronVector &d, double &eig_min) const;
/* called from solviip */
void solviipRealAndEliminate(double alpha, double betas,
const_diag_iter di, const_diag_iter dsi,
KronVector &d, double &eig_min) const;
void solviipComplexAndEliminate(double alpha, double betas,
const_diag_iter di, const_diag_iter dsi,
KronVector &d, double &eig_min) const;
/* eliminations */
void solviEliminateReal(const_diag_iter di, KronVector &d,
const KronVector &y, double divisor) const;
void solviEliminateComplex(const_diag_iter di, KronVector &d,
const KronVector &y1, const KronVector &y2,
double divisor) const;
void solviipEliminateReal(const_diag_iter di, const_diag_iter dsi,
KronVector &d,
const KronVector &y1, const KronVector &y2,
double divisor, double divisor2) const;
void solviipEliminateComplex(const_diag_iter di, const_diag_iter dsi,
KronVector &d,
const KronVector &y1, const KronVector &y11,
const KronVector &y2, const KronVector &y22,
double divisor) const;
/* Lemma 2 */
void solviipComplex(double alpha, double betas, double gamma,
double delta1, double delta2,
KronVector &d1, KronVector &d2,
double &eig_min) const;
/* norms for what we consider zero on diagonal of F */
static constexpr double diag_zero = 1.e-15;
static constexpr double diag_zero_sq = 1.e-30; // square of diag_zero
};
#endif /* TRIANGULAR_SYLVESTER_H */
/* $Header: /var/lib/cvs/dynare_cpp/sylv/cc/Vector.h,v 1.1.1.1 2004/06/04 13:01:13 kamenik Exp $ */
/* Tag $Name: $ */
#ifndef VECTOR_H
#define VECTOR_H
/* NOTE! Vector and ConstVector have not common super class in order
* to avoid running virtual method invokation mechanism. Some
* members, and methods are thus duplicated */
#include <memory>
#include <complex>
#if defined(MATLAB_MEX_FILE) || defined(OCTAVE_MEX_FILE)
# include <dynmex.h>
#endif
class GeneralMatrix;
class ConstVector;
class Vector
{
friend class ConstVector;
protected:
int len{0};
int off{0}; // offset to double* pointer
int s{1}; // stride (also called "skip" in some places)
std::shared_ptr<double> data;
public:
Vector() = default;
Vector(int l) : len{l}, data{new double[l], [](double *arr) { delete[] arr; }}
{
}
Vector(Vector &v) = default;
Vector(const Vector &v);
Vector(Vector &&v) = default;
// We don't want implict conversion from ConstVector, since it's expensive
explicit Vector(const ConstVector &v);
Vector(std::shared_ptr<double> d, int l)
: len(l), data{std::move(d)}
{
}
Vector(Vector &v, int off_arg, int l);
Vector(const Vector &v, int off_arg, int l);
Vector(Vector &v, int off_arg, int skip, int l);
Vector(const Vector &v, int off_arg, int skip, int l);
#if defined(MATLAB_MEX_FILE) || defined(OCTAVE_MEX_FILE)
explicit Vector(mxArray *p);
#endif
Vector &operator=(const Vector &v);
Vector &operator=(Vector &&v);
Vector &operator=(const ConstVector &v);
double &
operator[](int i)
{
return data.get()[off+s*i];
}
const double &
operator[](int i) const
{
return data.get()[off+s*i];
}
const double *
base() const
{
return data.get() + off;
}
double *
base()
{
return data.get() + off;
}
int
length() const
{
return len;
}
int
skip() const
{
return s;
}
/** Exact equality. */
bool operator==(const Vector &y) const;
bool operator!=(const Vector &y) const;
/** Lexicographic ordering. */
bool operator<(const Vector &y) const;
bool operator<=(const Vector &y) const;
bool operator>(const Vector &y) const;
bool operator>=(const Vector &y) const;
virtual ~Vector() = default;
void zeros();
void nans();
void infs();
void rotatePair(double alpha, double beta1, double beta2, int i);
// Computes this += r*v
void add(double r, const Vector &v);
// Computes this += r*v
void add(double r, const ConstVector &v);
// Computes this += z*v (where this and v are intepreted as complex vectors)
void addComplex(const std::complex<double> &z, const Vector &v);
// Computes this += z*v (where this and v are intepreted as complex vectors)
void addComplex(const std::complex<double> &z, const ConstVector &v);
void mult(double r);
double getNorm() const;
double getMax() const;
double getNorm1() const;
double dot(const Vector &y) const;
bool isFinite() const;
void print() const;
/* multiplies | alpha -beta1| |b1| |x1|
| |\otimes I .| | = | |
| -beta2 alpha| |b2| |x2|
*/
static void mult2(double alpha, double beta1, double beta2,
Vector &x1, Vector &x2,
const Vector &b1, const Vector &b2);
/* same, but adds instead of set */
static void mult2a(double alpha, double beta1, double beta2,
Vector &x1, Vector &x2,
const Vector &b1, const Vector &b2);
/* same, but subtracts instead of add */
static void
mult2s(double alpha, double beta1, double beta2,
Vector &x1, Vector &x2,
const Vector &b1, const Vector &b2)
{
mult2a(-alpha, -beta1, -beta2, x1, x2, b1, b2);
}
private:
void copy(const double *d, int inc);
};
class ConstGeneralMatrix;
class ConstVector
{
friend class Vector;
protected:
int len;
int off{0}; // offset to double* pointer
int s{1}; // stride (also called "skip" in some places)
std::shared_ptr<const double> data;
public:
// Implicit conversion from Vector is ok, since it's cheap
ConstVector(const Vector &v);
ConstVector(const ConstVector &v) = default;
ConstVector(ConstVector &&v) = default;
ConstVector(std::shared_ptr<const double> d, int l) : len{l}, data{std::move(d)}
{
}
ConstVector(const ConstVector &v, int off_arg, int l);
ConstVector(const ConstVector &v, int off_arg, int skip, int l);
ConstVector(std::shared_ptr<const double> d, int skip, int l);
#if defined(MATLAB_MEX_FILE) || defined(OCTAVE_MEX_FILE)
explicit ConstVector(const mxArray *p);
#endif
virtual ~ConstVector() = default;
ConstVector &operator=(const ConstVector &v) = delete;
ConstVector &operator=(ConstVector &&v) = delete;
const double &
operator[](int i) const
{
return data.get()[off+s*i];
}
const double *
base() const
{
return data.get() + off;
}
int
length() const
{
return len;
}
int
skip() const
{
return s;
}
/** Exact equality. */
bool operator==(const ConstVector &y) const;
bool
operator!=(const ConstVector &y) const
{
return !operator==(y);
}
/** Lexicographic ordering. */
bool operator<(const ConstVector &y) const;
bool
operator<=(const ConstVector &y) const
{
return operator<(y) || operator==(y);
}
bool
operator>(const ConstVector &y) const
{
return !operator<=(y);
}
bool
operator>=(const ConstVector &y) const
{
return !operator<(y);
}
double getNorm() const;
double getMax() const;
double getNorm1() const;
double dot(const ConstVector &y) const;
bool isFinite() const;
void print() const;
};
#endif /* VECTOR_H */
<HTML>
<!-- $Header: /var/lib/cvs/dynare_cpp/sylv/change_log.html,v 1.1.1.1 2004/06/04 13:00:05 kamenik Exp $ -->
<!-- Tag $Name: $ -->
<TITLE>
Sylvester Solver Change Log
</TITLE>
<BODY>
<TABLE CELLSPACING=2 ALIGN="CENTER" BORDER=1>
<TR>
<TD BGCOLOR="#d0d0d0" WIDTH="85"> Tag </TD>
<TD BGCOLOR="#d0d0d0" WIDTH="80"> Date </TD>
<TD BGCOLOR="#d0d0d0" WIDTH="600"> Description/Changes</TD>
</TR>
<TR>
<TD></TD>
<TD>2003/09/10</TD>
<TD>Initial version solving triangular system put to repository</TD>
</TR>
<TR>
<TD></TD>
<TD></TD>
<TD>Implemented solution of general case.</TD>
</TR>
<TR>
<TD></TD>
<TD></TD>
<TD>Implemented a memory pool (Paris).</TD>
</TR>
<TR>
<TD></TD>
<TD></TD>
<TD>Implemented MEX interface to the routine (Paris).</TD>
</TR>
<TR>
<TD></TD>
<TD></TD>
<TD>Implemented QuasiTriangularZero (Paris) (not fully used yet).</TD>
</TR>
<TR>
<TD>rel-1</TD>
<TD>2003/10-02</TD>
<TD>Version sent to Michel.</TD>
</TR>
<TR>
<TD></TD>
<TD></TD>
<TD>Inheritance streamlined, QuasiTriangular inherits from GeneralMatrix.</TD>
</TR>
<TR>
<TD></TD>
<TD></TD>
<TD>Implemented block diagonalization algorithm.</TD>
</TR>
<TR>
<TD></TD>
<TD></TD>
<TD>Solution routines rewritten so that the output rewrites input,
considerable memory improvement.</TD>
</TR>
<TR>
<TD></TD>
<TD></TD>
<TD>MEX interface now links with LAPACK library from Matlab.</TD>
</TR>
<TR>
<TD></TD>
<TD></TD>
<TD>Added a hack to MEX library loading in order to avoid Matlab crash in Wins.</TD>
</TR>
<TR>
<TD>rel-2</TD>
<TD>2003/10/15</TD>
<TD>Version sent to Michel.</TD>
</TR>
<TR>
<TD></TD>
<TD></TD>
<TD>KronUtils now rewrite input by output using less memory.</TD>
</TR>
<TR>
<TD></TD>
<TD></TD>
<TD>Added iterative solution algorithm (doubling).</TD>
</TR>
<TR>
<TD></TD>
<TD></TD>
<TD>Introduced abstraction for set of parameters (SylvParams).</TD>
</TR>
<TR>
<TD></TD>
<TD></TD>
<TD>Algorithm enabled to solve problems with singular C.</TD>
</TR>
<TR>
<TD></TD>
<TD></TD>
<TD>Implemented a class chooser chossing between QuasiTriangularZero,
and QuasiTriangular (padded with zero) depending on size of the
problem. Full use of QuasiTriangularZero.</TD>
</TR>
<TR>
<TD></TD>
<TD></TD>
<TD>Reimplemented QuasiTriangular::solve, offdiagonal elements are
eleiminated by gauss with partial pivoting, not by transformation of
complex eigenvalues. More stable for ill conditioned eigenvalues.</TD>
</TR>
<TR>
<TD></TD>
<TD></TD>
<TD>Reimplemented calculation of eliminating vectors, much more
numerically stable now.</TD>
</TR>
<TR>
<TD></TD>
<TD></TD>
<TD>Implemented algorithm for ordering of eigenvalues (not used now,
no numerical improvements).</TD>
</TR>
<TR>
<TD>rel-3</TD>
<TD>2003/12/4</TD>
<TD>Version sent to Michel.</TD>
</TR>
<TR>
<TD></TD>
<TD></TD>
<TD>GeneralMatrix separated for use outside, in sylv module we use
its subclass SylvMatrix. Implemented ConstGeneralMatrix (useful outside).
</TD>
</TR>
<TR>
<TD>rel-4</TD>
<TD>2004/6/4</TD>
<TD>Version, which was moved to pythie.cepremap.cnrs.fr repository.</TD>
</TR>
</TABLE>
</BODY>
</HTML>
// Copyright (C) 2005-2011, Ondra Kamenik
#include "dynmex.h"
#include "mex.h"
#include "GeneralSylvester.hh"
#include "SylvException.hh"
void
gen_sylv_solve(int order, int n, int m, int zero_cols,
const ConstVector &A, const ConstVector &B,
const ConstVector &C, Vector &X)
{
GeneralSylvester s(order, n, m, zero_cols, A, B, C, X, false);
s.solve();
}
mxArray *
gen_sylv_solve_and_check(int order, int n, int m, int zero_cols,
const ConstVector &A, const ConstVector &B,
const ConstVector &C, const ConstVector &D,
Vector &X)
{
GeneralSylvester s(order, n, m, zero_cols, A, B, C, X, true);
s.solve();
s.check(D);
return s.getParams().createStructArray();
}
extern "C" {
void
mexFunction(int nlhs, mxArray *plhs[],
int nhrs, const mxArray *prhs[])
{
if (nhrs != 5 || nlhs > 3 || nlhs < 2)
DYN_MEX_FUNC_ERR_MSG_TXT("Gensylv: Must have exactly 5 input args and either 2 or 3 output args.");
auto order = static_cast<int>(mxGetScalar(prhs[0]));
const mxArray *const A = prhs[1];
const mxArray *const B = prhs[2];
const mxArray *const C = prhs[3];
const mxArray *const D = prhs[4];
const mwSize *const Adims = mxGetDimensions(A);
const mwSize *const Bdims = mxGetDimensions(B);
const mwSize *const Cdims = mxGetDimensions(C);
const mwSize *const Ddims = mxGetDimensions(D);
if (Adims[0] != Adims[1])
DYN_MEX_FUNC_ERR_MSG_TXT("Matrix A must be a square matrix.");
if (Adims[0] != Bdims[0])
DYN_MEX_FUNC_ERR_MSG_TXT("Matrix A and matrix B must have the same number of rows.");
if (Adims[0] != Ddims[0])
DYN_MEX_FUNC_ERR_MSG_TXT("Matrix A and matrix B must have the same number of rows.");
if (Cdims[0] != Cdims[1])
DYN_MEX_FUNC_ERR_MSG_TXT("Matrix C must be square.");
if (Bdims[0] < Bdims[1])
DYN_MEX_FUNC_ERR_MSG_TXT("Matrix B must not have more columns than rows.");
if (Ddims[1] != static_cast<mwSize>(power(Cdims[0], order)))
DYN_MEX_FUNC_ERR_MSG_TXT("Matrix D has wrong number of columns.");
auto n = static_cast<int>(Adims[0]);
auto m = static_cast<int>(Cdims[0]);
auto zero_cols = static_cast<int>(Bdims[0] - Bdims[1]);
mxArray *X = mxCreateDoubleMatrix(Ddims[0], Ddims[1], mxREAL);
// copy D to X
ConstVector Avec{A}, Bvec{B}, Cvec{C}, Dvec{D};
Vector Xvec{X};
Xvec = Dvec;
// solve (or solve and check)
try
{
if (nlhs == 2)
gen_sylv_solve(order, n, m, zero_cols, Avec, Bvec, Cvec, Xvec);
else if (nlhs == 3)
plhs[2] = gen_sylv_solve_and_check(order, n, m, zero_cols, Avec, Bvec, Cvec, Dvec, Xvec);
}
catch (const SylvException &e)
{
DYN_MEX_FUNC_ERR_MSG_TXT(e.getMessage().c_str());
}
plhs[1] = X;
plhs[0] = mxCreateDoubleScalar(0);
}
};
%
% GENSYLV solves the following matrix equation:
% A*X + [0 B]*X*kron(C,..,C) = D,
% where
% A ...... regular (n,n) matrix,
% [0 B] .. (n,n) matrix with a few first
% columns equal to zeros
% B ...... rectangular (n, nz) matrix with nz<=n
% C ...... regular (m,m) matrix, whose spectrum is
% within (-1, 1)
% kron(C,..,C)
% ...... Kronecker power of C of order 'order'
% D ..... rectangular (n, m^order) matrix.
%
% [err, X] = gensylv(order, A, B, C, D)
% returns err a scalar where 1 indicates failure, 0 indicates success
% and X as the solution, doesn't perform any checks
%
% [err, X, par] = gensylv(order, A, B, C, D)
% solves the system, and performs checks. 'par' is struct
% containing information about solution and error norms
% returned by the check. This is a list of the struct
% members, some of them may be missing in actual returned
% value:
% method = method used for solution recursive/iterative
% convergence_tol = convergence tolerance for iter. method
% max_num_iter = max number of steps for iter. method
% bs_norm = Bavely Stewart log10 norm for diagonalization
% converged = convergence status for iterative method
% iter_last_norm = residual norm of the last step of iterations
% num_iter = number of iterations performed
% f_err1 = norm 1 of abs. error C-V*F*inv(V)
% f_errI = norm Inf of abs. error C-V*F*inv(V)
% viv_err1 = norm 1 of abs. error I-V*inv(V)
% viv_errI = norm Inf of abs. error I-V*inv(V)
% ivv_err1 = norm 1 of abs. error I-inv(V)*V
% ivv_errI = norm Inf of abs. error I-inv(V)*V
% f_blocks = number of diagonal blocks of F
% f_largest = size of largest diagonal block in F
% f_zeros = number of off diagonal zeros in F
% f_offdiag = number of all offdiagonal elements in F
% rcondA1 = reciprocal cond 1 number of A
% rcondAI = reciprocal cond Inf number of A
% eig_min = minimum eigenvalue of vectorized system
% mat_err1 = rel. matrix 1 norm of A*X-[0 B]*X*kron(C,..,C)-D
% mat_errI = rel. matrix Inf norm of --"--
% mat_errF = rel. matrix Frobenius norm of --"--
% vec_err1 = rel. vector 1 norm of --"--
% vec_errI = rel. vector Inf norm of --"--
% cpu_time = CPU time needed for solution in CPU seconds
%
% $Header: /var/lib/cvs/dynare_cpp/sylv/matlab/gensylv.m,v 1.1.1.1 2004/06/04 13:01:13 kamenik Exp $
% Tag $Name: $
function [err, X, varargout] = gensylv(order, A, B, C, D)
% in Windows, ensure that aa_gensylv.dll is loaded, this prevents
% clearing the function and a successive Matlab crash
if strcmp('PCWIN', computer)
if ~ libisloaded('aa_gensylv')
loadlibrary('aa_gensylv', 'dummy');
end
end
% launch aa_gensylv
if nargout == 2
X = aa_gensylv(order, A, B, C, D);
elseif nargout == 3
[X, par] = aa_gensylv(order, A, B, C, D);
varargout(1) = {par};
else
error('Must have 2 or 3 output arguments.');
end
err = 0;
\ No newline at end of file
/* $Header: /var/lib/cvs/dynare_cpp/sylv/testing/MMMatrix.h,v 1.1.1.1 2004/06/04 13:01:13 kamenik Exp $ */
/* Tag $Name: $ */
#ifndef MM_MATRIX_H
#define MM_MATRIX_H
#include "GeneralMatrix.hh"
#include <string>
#include <utility>
#include <memory>
class MMException
{
std::string message;
public:
MMException(std::string mes) : message(std::move(mes))
{
}
std::string
getMessage() const
{
return message;
}
};
class MMMatrixIn
{
std::shared_ptr<double> data;
int rows;
int cols;
public:
MMMatrixIn(const std::string &fname);
~MMMatrixIn() = default;
Vector
getData() const
{
return Vector{data, size()};
}
int
size() const
{
return rows*cols;
}
int
row() const
{
return rows;
}
int
col() const
{
return cols;
}
};
class MMMatrixOut
{
public:
static void write(const std::string &fname, const GeneralMatrix &m);
};
#endif /* MM_MATRIX_H */
check_PROGRAMS = tests
tests_SOURCES = MMMatrix.cc MMMatrix.hh tests.cc
tests_LDADD = ../cc/libsylv.a $(LAPACK_LIBS) $(BLAS_LIBS) $(LIBS) $(FLIBS)
tests_CPPFLAGS = -I../cc
EXTRA_DIST = tdata.tgz
check-local: tdata.tgz
tar xzf tdata.tgz
./tests
CLEANFILES = *.mm
File deleted
var y, x;
varexo e;
parameters theta, rho, bet, xbar;
xbar = 0.0179;
rho = -0.139;
theta = -10;
bet = 0.95;
model;
y = bet*exp(theta*x(+1))*(1+y(+1));
x = (1-rho)*xbar + rho*x(-1) + e;
end;
initval;
x = 0.0179;
y = 0.3;
e = 0;
end;
vcov = [ 0.0012110];
order = 6;
var C10_PIE C10_RR C10_RS C10_Y C11_PIE C11_RR C11_RS C11_Y C12_PIE C12_RR C12_RS C12_Y C13_PIE C13_RR C13_RS C13_Y C14_PIE C14_RR C14_RS C14_Y C15_PIE C15_RR C15_RS C15_Y C16_PIE C16_RR C16_RS C16_Y C17_PIE C17_RR C17_RS C17_Y C18_PIE C18_RR C18_RS C18_Y C19_PIE C19_RR C19_RS C19_Y C1_PIE C1_RR C1_RS C1_Y C20_PIE C20_RR C20_RS C20_Y C2_PIE C2_RR C2_RS C2_Y C3_PIE C3_RR C3_RS C3_Y C4_PIE C4_RR C4_RS C4_Y C5_PIE C5_RR C5_RS C5_Y C6_PIE C6_RR C6_RS C6_Y C7_PIE C7_RR C7_RS C7_Y C8_PIE C8_RR C8_RS C8_Y C9_PIE C9_RR C9_RS C9_Y;
varexo C1_EPIE C1_EY C1_ERS C2_EPIE C2_EY C2_ERS C3_EPIE C3_EY C3_ERS C4_EPIE C4_EY C4_ERS C5_EPIE C5_EY C5_ERS C6_EPIE C6_EY C6_ERS C7_EPIE C7_EY C7_ERS C8_EPIE C8_EY C8_ERS C9_EPIE C9_EY C9_ERS C10_EPIE C10_EY C10_ERS C11_EPIE C11_EY C11_ERS C12_EPIE C12_EY C12_ERS C13_EPIE C13_EY C13_ERS C14_EPIE C14_EY C14_ERS C15_EPIE C15_EY C15_ERS C16_EPIE C16_EY C16_ERS C17_EPIE C17_EY C17_ERS C18_EPIE C18_EY C18_ERS C19_EPIE C19_EY C19_ERS C20_EPIE C20_EY C20_ERS;
parameters C10_CALFA1 C10_CALFA2 C10_CALFA3 C10_CALFA4 C10_CALFA5 C10_CALFA6 C10_CALFA7 C10_CALFA8 C10_CALFA9 C11_CALFA1 C11_CALFA2 C11_CALFA3 C11_CALFA4 C11_CALFA5 C11_CALFA6 C11_CALFA7 C11_CALFA8 C11_CALFA9 C12_CALFA1 C12_CALFA2 C12_CALFA3 C12_CALFA4 C12_CALFA5 C12_CALFA6 C12_CALFA7 C12_CALFA8 C12_CALFA9 C13_CALFA1 C13_CALFA2 C13_CALFA3 C13_CALFA4 C13_CALFA5 C13_CALFA6 C13_CALFA7 C13_CALFA8 C13_CALFA9 C14_CALFA1 C14_CALFA2 C14_CALFA3 C14_CALFA4 C14_CALFA5 C14_CALFA6 C14_CALFA7 C14_CALFA8 C14_CALFA9 C15_CALFA1 C15_CALFA2 C15_CALFA3 C15_CALFA4 C15_CALFA5 C15_CALFA6 C15_CALFA7 C15_CALFA8 C15_CALFA9 C16_CALFA1 C16_CALFA2 C16_CALFA3 C16_CALFA4 C16_CALFA5 C16_CALFA6 C16_CALFA7 C16_CALFA8 C16_CALFA9 C17_CALFA1 C17_CALFA2 C17_CALFA3 C17_CALFA4 C17_CALFA5 C17_CALFA6 C17_CALFA7 C17_CALFA8 C17_CALFA9 C18_CALFA1 C18_CALFA2 C18_CALFA3 C18_CALFA4 C18_CALFA5 C18_CALFA6 C18_CALFA7 C18_CALFA8 C18_CALFA9 C19_CALFA1 C19_CALFA2 C19_CALFA3 C19_CALFA4 C19_CALFA5 C19_CALFA6 C19_CALFA7 C19_CALFA8 C19_CALFA9 C1_CALFA1 C1_CALFA2 C1_CALFA3 C1_CALFA4 C1_CALFA5 C1_CALFA6 C1_CALFA7 C1_CALFA8 C1_CALFA9 C20_CALFA1 C20_CALFA2 C20_CALFA3 C20_CALFA4 C20_CALFA5 C20_CALFA6 C20_CALFA7 C20_CALFA8 C20_CALFA9 C2_CALFA1 C2_CALFA2 C2_CALFA3 C2_CALFA4 C2_CALFA5 C2_CALFA6 C2_CALFA7 C2_CALFA8 C2_CALFA9 C3_CALFA1 C3_CALFA2 C3_CALFA3 C3_CALFA4 C3_CALFA5 C3_CALFA6 C3_CALFA7 C3_CALFA8 C3_CALFA9 C4_CALFA1 C4_CALFA2 C4_CALFA3 C4_CALFA4 C4_CALFA5 C4_CALFA6 C4_CALFA7 C4_CALFA8 C4_CALFA9 C5_CALFA1 C5_CALFA2 C5_CALFA3 C5_CALFA4 C5_CALFA5 C5_CALFA6 C5_CALFA7 C5_CALFA8 C5_CALFA9 C6_CALFA1 C6_CALFA2 C6_CALFA3 C6_CALFA4 C6_CALFA5 C6_CALFA6 C6_CALFA7 C6_CALFA8 C6_CALFA9 C7_CALFA1 C7_CALFA2 C7_CALFA3 C7_CALFA4 C7_CALFA5 C7_CALFA6 C7_CALFA7 C7_CALFA8 C7_CALFA9 C8_CALFA1 C8_CALFA2 C8_CALFA3 C8_CALFA4 C8_CALFA5 C8_CALFA6 C8_CALFA7 C8_CALFA8 C8_CALFA9 C9_CALFA1 C9_CALFA2 C9_CALFA3 C9_CALFA4 C9_CALFA5 C9_CALFA6 C9_CALFA7 C9_CALFA8 C9_CALFA9 C10_PIESTAR C11_PIESTAR C12_PIESTAR C13_PIESTAR C14_PIESTAR C15_PIESTAR C16_PIESTAR C17_PIESTAR C18_PIESTAR C19_PIESTAR C1_PIESTAR C20_PIESTAR C2_PIESTAR C3_PIESTAR C4_PIESTAR C5_PIESTAR C6_PIESTAR C7_PIESTAR C8_PIESTAR C9_PIESTAR;
C10_CALFA1=0.5;
C10_CALFA2=0.5;
C10_CALFA3=0.5;
C10_CALFA4=0;
C10_CALFA5=0.75;
C10_CALFA6=-0.25;
C10_CALFA7=0.1;
C10_CALFA8=0.5;
C10_CALFA9=0.5;
C11_CALFA1=0.5;
C11_CALFA2=0.5;
C11_CALFA3=0.5;
C11_CALFA4=0;
C11_CALFA5=0.75;
C11_CALFA6=-0.25;
C11_CALFA7=0.1;
C11_CALFA8=0.5;
C11_CALFA9=0.5;
C12_CALFA1=0.5;
C12_CALFA2=0.5;
C12_CALFA3=0.5;
C12_CALFA4=0;
C12_CALFA5=0.75;
C12_CALFA6=-0.25;
C12_CALFA7=0.1;
C12_CALFA8=0.5;
C12_CALFA9=0.5;
C13_CALFA1=0.5;
C13_CALFA2=0.5;
C13_CALFA3=0.5;
C13_CALFA4=0;
C13_CALFA5=0.75;
C13_CALFA6=-0.25;
C13_CALFA7=0.1;
C13_CALFA8=0.5;
C13_CALFA9=0.5;
C14_CALFA1=0.5;
C14_CALFA2=0.5;
C14_CALFA3=0.5;
C14_CALFA4=0;
C14_CALFA5=0.75;
C14_CALFA6=-0.25;
C14_CALFA7=0.1;
C14_CALFA8=0.5;
C14_CALFA9=0.5;
C15_CALFA1=0.5;
C15_CALFA2=0.5;
C15_CALFA3=0.5;
C15_CALFA4=0;
C15_CALFA5=0.75;
C15_CALFA6=-0.25;
C15_CALFA7=0.1;
C15_CALFA8=0.5;
C15_CALFA9=0.5;
C16_CALFA1=0.5;
C16_CALFA2=0.5;
C16_CALFA3=0.5;
C16_CALFA4=0;
C16_CALFA5=0.75;
C16_CALFA6=-0.25;
C16_CALFA7=0.1;
C16_CALFA8=0.5;
C16_CALFA9=0.5;
C17_CALFA1=0.5;
C17_CALFA2=0.5;
C17_CALFA3=0.5;
C17_CALFA4=0;
C17_CALFA5=0.75;
C17_CALFA6=-0.25;
C17_CALFA7=0.1;
C17_CALFA8=0.5;
C17_CALFA9=0.5;
C18_CALFA1=0.5;
C18_CALFA2=0.5;
C18_CALFA3=0.5;
C18_CALFA4=0;
C18_CALFA5=0.75;
C18_CALFA6=-0.25;
C18_CALFA7=0.1;
C18_CALFA8=0.5;
C18_CALFA9=0.5;
C19_CALFA1=0.5;
C19_CALFA2=0.5;
C19_CALFA3=0.5;
C19_CALFA4=0;
C19_CALFA5=0.75;
C19_CALFA6=-0.25;
C19_CALFA7=0.1;
C19_CALFA8=0.5;
C19_CALFA9=0.5;
C1_CALFA1=0.5;
C1_CALFA2=0.5;
C1_CALFA3=0.5;
C1_CALFA4=0;
C1_CALFA5=0.75;
C1_CALFA6=-0.25;
C1_CALFA7=0.1;
C1_CALFA8=0.5;
C1_CALFA9=0.5;
C20_CALFA1=0.5;
C20_CALFA2=0.5;
C20_CALFA3=0.5;
C20_CALFA4=0;
C20_CALFA5=0.75;
C20_CALFA6=-0.25;
C20_CALFA7=0.1;
C20_CALFA8=0.5;
C20_CALFA9=0.5;
C2_CALFA1=0.5;
C2_CALFA2=0.5;
C2_CALFA3=0.5;
C2_CALFA4=0;
C2_CALFA5=0.75;
C2_CALFA6=-0.25;
C2_CALFA7=0.1;
C2_CALFA8=0.5;
C2_CALFA9=0.5;
C3_CALFA1=0.5;
C3_CALFA2=0.5;
C3_CALFA3=0.5;
C3_CALFA4=0;
C3_CALFA5=0.75;
C3_CALFA6=-0.25;
C3_CALFA7=0.1;
C3_CALFA8=0.5;
C3_CALFA9=0.5;
C4_CALFA1=0.5;
C4_CALFA2=0.5;
C4_CALFA3=0.5;
C4_CALFA4=0;
C4_CALFA5=0.75;
C4_CALFA6=-0.25;
C4_CALFA7=0.1;
C4_CALFA8=0.5;
C4_CALFA9=0.5;
C5_CALFA1=0.5;
C5_CALFA2=0.5;
C5_CALFA3=0.5;
C5_CALFA4=0;
C5_CALFA5=0.75;
C5_CALFA6=-0.25;
C5_CALFA7=0.1;
C5_CALFA8=0.5;
C5_CALFA9=0.5;
C6_CALFA1=0.5;
C6_CALFA2=0.5;
C6_CALFA3=0.5;
C6_CALFA4=0;
C6_CALFA5=0.75;
C6_CALFA6=-0.25;
C6_CALFA7=0.1;
C6_CALFA8=0.5;
C6_CALFA9=0.5;
C7_CALFA1=0.5;
C7_CALFA2=0.5;
C7_CALFA3=0.5;
C7_CALFA4=0;
C7_CALFA5=0.75;
C7_CALFA6=-0.25;
C7_CALFA7=0.1;
C7_CALFA8=0.5;
C7_CALFA9=0.5;
C8_CALFA1=0.5;
C8_CALFA2=0.5;
C8_CALFA3=0.5;
C8_CALFA4=0;
C8_CALFA5=0.75;
C8_CALFA6=-0.25;
C8_CALFA7=0.1;
C8_CALFA8=0.5;
C8_CALFA9=0.5;
C9_CALFA1=0.5;
C9_CALFA2=0.5;
C9_CALFA3=0.5;
C9_CALFA4=0;
C9_CALFA5=0.75;
C9_CALFA6=-0.25;
C9_CALFA7=0.1;
C9_CALFA8=0.5;
C9_CALFA9=0.5;
C10_PIESTAR=2.5;
C11_PIESTAR=2.5;
C12_PIESTAR=2.5;
C13_PIESTAR=2.5;
C14_PIESTAR=2.5;
C15_PIESTAR=2.5;
C16_PIESTAR=2.5;
C17_PIESTAR=2.5;
C18_PIESTAR=2.5;
C19_PIESTAR=2.5;
C1_PIESTAR=2.5;
C20_PIESTAR=2.5;
C2_PIESTAR=2.5;
C3_PIESTAR=2.5;
C4_PIESTAR=2.5;
C5_PIESTAR=2.5;
C6_PIESTAR=2.5;
C7_PIESTAR=2.5;
C8_PIESTAR=2.5;
C9_PIESTAR=2.5;
model;
C1_PIE = C1_CALFA1*C1_PIE(1)+(1-C1_CALFA1)*C1_PIE(-1)+C1_CALFA2*(C1_Y+0.1)+C1_CALFA3*(C1_Y+0.1)^2/2+C1_EPIE ;
C1_Y = C1_CALFA4*C1_Y(1)+C1_CALFA5*C1_Y(-1)+C1_CALFA6*C1_RR+C1_EY+C1_CALFA7*(0+C2_Y+C3_Y+C4_Y+C5_Y+C6_Y+C7_Y+C8_Y+C9_Y+C10_Y+C11_Y+C12_Y+C13_Y+C14_Y+C15_Y+C16_Y+C17_Y+C18_Y+C19_Y+C20_Y)/19 ;
C1_RR = C1_RS-C1_PIE(1) ;
C1_RS = C1_PIE(1)+C1_CALFA8*(C1_PIE-C1_PIESTAR)+C1_CALFA9*C1_Y+C1_ERS ;
C2_PIE = C2_CALFA1*C2_PIE(1)+(1-C2_CALFA1)*C2_PIE(-1)+C2_CALFA2*(C2_Y+0.1)+C2_CALFA3*(C2_Y+0.1)^2/2+C2_EPIE ;
C2_Y = C2_CALFA4*C2_Y(1)+C2_CALFA5*C2_Y(-1)+C2_CALFA6*C2_RR+C2_EY+C2_CALFA7*(0+C1_Y+C3_Y+C4_Y+C5_Y+C6_Y+C7_Y+C8_Y+C9_Y+C10_Y+C11_Y+C12_Y+C13_Y+C14_Y+C15_Y+C16_Y+C17_Y+C18_Y+C19_Y+C20_Y)/19 ;
C2_RR = C2_RS-C2_PIE(1) ;
C2_RS = C2_PIE(1)+C2_CALFA8*(C2_PIE-C2_PIESTAR)+C2_CALFA9*C2_Y+C2_ERS ;
C3_PIE = C3_CALFA1*C3_PIE(1)+(1-C3_CALFA1)*C3_PIE(-1)+C3_CALFA2*(C3_Y+0.1)+C3_CALFA3*(C3_Y+0.1)^2/2+C3_EPIE ;
C3_Y = C3_CALFA4*C3_Y(1)+C3_CALFA5*C3_Y(-1)+C3_CALFA6*C3_RR+C3_EY+C3_CALFA7*(0+C1_Y+C2_Y+C4_Y+C5_Y+C6_Y+C7_Y+C8_Y+C9_Y+C10_Y+C11_Y+C12_Y+C13_Y+C14_Y+C15_Y+C16_Y+C17_Y+C18_Y+C19_Y+C20_Y)/19 ;
C3_RR = C3_RS-C3_PIE(1) ;
C3_RS = C3_PIE(1)+C3_CALFA8*(C3_PIE-C3_PIESTAR)+C3_CALFA9*C3_Y+C3_ERS ;
C4_PIE = C4_CALFA1*C4_PIE(1)+(1-C4_CALFA1)*C4_PIE(-1)+C4_CALFA2*(C4_Y+0.1)+C4_CALFA3*(C4_Y+0.1)^2/2+C4_EPIE ;
C4_Y = C4_CALFA4*C4_Y(1)+C4_CALFA5*C4_Y(-1)+C4_CALFA6*C4_RR+C4_EY+C4_CALFA7*(0+C1_Y+C2_Y+C3_Y+C5_Y+C6_Y+C7_Y+C8_Y+C9_Y+C10_Y+C11_Y+C12_Y+C13_Y+C14_Y+C15_Y+C16_Y+C17_Y+C18_Y+C19_Y+C20_Y)/19 ;
C4_RR = C4_RS-C4_PIE(1) ;
C4_RS = C4_PIE(1)+C4_CALFA8*(C4_PIE-C4_PIESTAR)+C4_CALFA9*C4_Y+C4_ERS ;
C5_PIE = C5_CALFA1*C5_PIE(1)+(1-C5_CALFA1)*C5_PIE(-1)+C5_CALFA2*(C5_Y+0.1)+C5_CALFA3*(C5_Y+0.1)^2/2+C5_EPIE ;
C5_Y = C5_CALFA4*C5_Y(1)+C5_CALFA5*C5_Y(-1)+C5_CALFA6*C5_RR+C5_EY+C5_CALFA7*(0+C1_Y+C2_Y+C3_Y+C4_Y+C6_Y+C7_Y+C8_Y+C9_Y+C10_Y+C11_Y+C12_Y+C13_Y+C14_Y+C15_Y+C16_Y+C17_Y+C18_Y+C19_Y+C20_Y)/19 ;
C5_RR = C5_RS-C5_PIE(1) ;
C5_RS = C5_PIE(1)+C5_CALFA8*(C5_PIE-C5_PIESTAR)+C5_CALFA9*C5_Y+C5_ERS ;
C6_PIE = C6_CALFA1*C6_PIE(1)+(1-C6_CALFA1)*C6_PIE(-1)+C6_CALFA2*(C6_Y+0.1)+C6_CALFA3*(C6_Y+0.1)^2/2+C6_EPIE ;
C6_Y = C6_CALFA4*C6_Y(1)+C6_CALFA5*C6_Y(-1)+C6_CALFA6*C6_RR+C6_EY+C6_CALFA7*(0+C1_Y+C2_Y+C3_Y+C4_Y+C5_Y+C7_Y+C8_Y+C9_Y+C10_Y+C11_Y+C12_Y+C13_Y+C14_Y+C15_Y+C16_Y+C17_Y+C18_Y+C19_Y+C20_Y)/19 ;
C6_RR = C6_RS-C6_PIE(1) ;
C6_RS = C6_PIE(1)+C6_CALFA8*(C6_PIE-C6_PIESTAR)+C6_CALFA9*C6_Y+C6_ERS ;
C7_PIE = C7_CALFA1*C7_PIE(1)+(1-C7_CALFA1)*C7_PIE(-1)+C7_CALFA2*(C7_Y+0.1)+C7_CALFA3*(C7_Y+0.1)^2/2+C7_EPIE ;
C7_Y = C7_CALFA4*C7_Y(1)+C7_CALFA5*C7_Y(-1)+C7_CALFA6*C7_RR+C7_EY+C7_CALFA7*(0+C1_Y+C2_Y+C3_Y+C4_Y+C5_Y+C6_Y+C8_Y+C9_Y+C10_Y+C11_Y+C12_Y+C13_Y+C14_Y+C15_Y+C16_Y+C17_Y+C18_Y+C19_Y+C20_Y)/19 ;
C7_RR = C7_RS-C7_PIE(1) ;
C7_RS = C7_PIE(1)+C7_CALFA8*(C7_PIE-C7_PIESTAR)+C7_CALFA9*C7_Y+C7_ERS ;
C8_PIE = C8_CALFA1*C8_PIE(1)+(1-C8_CALFA1)*C8_PIE(-1)+C8_CALFA2*(C8_Y+0.1)+C8_CALFA3*(C8_Y+0.1)^2/2+C8_EPIE ;
C8_Y = C8_CALFA4*C8_Y(1)+C8_CALFA5*C8_Y(-1)+C8_CALFA6*C8_RR+C8_EY+C8_CALFA7*(0+C1_Y+C2_Y+C3_Y+C4_Y+C5_Y+C6_Y+C7_Y+C9_Y+C10_Y+C11_Y+C12_Y+C13_Y+C14_Y+C15_Y+C16_Y+C17_Y+C18_Y+C19_Y+C20_Y)/19 ;
C8_RR = C8_RS-C8_PIE(1) ;
C8_RS = C8_PIE(1)+C8_CALFA8*(C8_PIE-C8_PIESTAR)+C8_CALFA9*C8_Y+C8_ERS ;
C9_PIE = C9_CALFA1*C9_PIE(1)+(1-C9_CALFA1)*C9_PIE(-1)+C9_CALFA2*(C9_Y+0.1)+C9_CALFA3*(C9_Y+0.1)^2/2+C9_EPIE ;
C9_Y = C9_CALFA4*C9_Y(1)+C9_CALFA5*C9_Y(-1)+C9_CALFA6*C9_RR+C9_EY+C9_CALFA7*(0+C1_Y+C2_Y+C3_Y+C4_Y+C5_Y+C6_Y+C7_Y+C8_Y+C10_Y+C11_Y+C12_Y+C13_Y+C14_Y+C15_Y+C16_Y+C17_Y+C18_Y+C19_Y+C20_Y)/19 ;
C9_RR = C9_RS-C9_PIE(1) ;
C9_RS = C9_PIE(1)+C9_CALFA8*(C9_PIE-C9_PIESTAR)+C9_CALFA9*C9_Y+C9_ERS ;
C10_PIE = C10_CALFA1*C10_PIE(1)+(1-C10_CALFA1)*C10_PIE(-1)+C10_CALFA2*(C10_Y+0.1)+C10_CALFA3*(C10_Y+0.1)^2/2+C10_EPIE ;
C10_Y = C10_CALFA4*C10_Y(1)+C10_CALFA5*C10_Y(-1)+C10_CALFA6*C10_RR+C10_EY+C10_CALFA7*(0+C1_Y+C2_Y+C3_Y+C4_Y+C5_Y+C6_Y+C7_Y+C8_Y+C9_Y+C11_Y+C12_Y+C13_Y+C14_Y+C15_Y+C16_Y+C17_Y+C18_Y+C19_Y+C20_Y)/19 ;
C10_RR = C10_RS-C10_PIE(1) ;
C10_RS = C10_PIE(1)+C10_CALFA8*(C10_PIE-C10_PIESTAR)+C10_CALFA9*C10_Y+C10_ERS ;
C11_PIE = C11_CALFA1*C11_PIE(1)+(1-C11_CALFA1)*C11_PIE(-1)+C11_CALFA2*(C11_Y+0.1)+C11_CALFA3*(C11_Y+0.1)^2/2+C11_EPIE ;
C11_Y = C11_CALFA4*C11_Y(1)+C11_CALFA5*C11_Y(-1)+C11_CALFA6*C11_RR+C11_EY+C11_CALFA7*(0+C1_Y+C2_Y+C3_Y+C4_Y+C5_Y+C6_Y+C7_Y+C8_Y+C9_Y+C10_Y+C12_Y+C13_Y+C14_Y+C15_Y+C16_Y+C17_Y+C18_Y+C19_Y+C20_Y)/19 ;
C11_RR = C11_RS-C11_PIE(1) ;
C11_RS = C11_PIE(1)+C11_CALFA8*(C11_PIE-C11_PIESTAR)+C11_CALFA9*C11_Y+C11_ERS ;
C12_PIE = C12_CALFA1*C12_PIE(1)+(1-C12_CALFA1)*C12_PIE(-1)+C12_CALFA2*(C12_Y+0.1)+C12_CALFA3*(C12_Y+0.1)^2/2+C12_EPIE ;
C12_Y = C12_CALFA4*C12_Y(1)+C12_CALFA5*C12_Y(-1)+C12_CALFA6*C12_RR+C12_EY+C12_CALFA7*(0+C1_Y+C2_Y+C3_Y+C4_Y+C5_Y+C6_Y+C7_Y+C8_Y+C9_Y+C10_Y+C11_Y+C13_Y+C14_Y+C15_Y+C16_Y+C17_Y+C18_Y+C19_Y+C20_Y)/19 ;
C12_RR = C12_RS-C12_PIE(1) ;
C12_RS = C12_PIE(1)+C12_CALFA8*(C12_PIE-C12_PIESTAR)+C12_CALFA9*C12_Y+C12_ERS ;
C13_PIE = C13_CALFA1*C13_PIE(1)+(1-C13_CALFA1)*C13_PIE(-1)+C13_CALFA2*(C13_Y+0.1)+C13_CALFA3*(C13_Y+0.1)^2/2+C13_EPIE ;
C13_Y = C13_CALFA4*C13_Y(1)+C13_CALFA5*C13_Y(-1)+C13_CALFA6*C13_RR+C13_EY+C13_CALFA7*(0+C1_Y+C2_Y+C3_Y+C4_Y+C5_Y+C6_Y+C7_Y+C8_Y+C9_Y+C10_Y+C11_Y+C12_Y+C14_Y+C15_Y+C16_Y+C17_Y+C18_Y+C19_Y+C20_Y)/19 ;
C13_RR = C13_RS-C13_PIE(1) ;
C13_RS = C13_PIE(1)+C13_CALFA8*(C13_PIE-C13_PIESTAR)+C13_CALFA9*C13_Y+C13_ERS ;
C14_PIE = C14_CALFA1*C14_PIE(1)+(1-C14_CALFA1)*C14_PIE(-1)+C14_CALFA2*(C14_Y+0.1)+C14_CALFA3*(C14_Y+0.1)^2/2+C14_EPIE ;
C14_Y = C14_CALFA4*C14_Y(1)+C14_CALFA5*C14_Y(-1)+C14_CALFA6*C14_RR+C14_EY+C14_CALFA7*(0+C1_Y+C2_Y+C3_Y+C4_Y+C5_Y+C6_Y+C7_Y+C8_Y+C9_Y+C10_Y+C11_Y+C12_Y+C13_Y+C15_Y+C16_Y+C17_Y+C18_Y+C19_Y+C20_Y)/19 ;
C14_RR = C14_RS-C14_PIE(1) ;
C14_RS = C14_PIE(1)+C14_CALFA8*(C14_PIE-C14_PIESTAR)+C14_CALFA9*C14_Y+C14_ERS ;
C15_PIE = C15_CALFA1*C15_PIE(1)+(1-C15_CALFA1)*C15_PIE(-1)+C15_CALFA2*(C15_Y+0.1)+C15_CALFA3*(C15_Y+0.1)^2/2+C15_EPIE ;
C15_Y = C15_CALFA4*C15_Y(1)+C15_CALFA5*C15_Y(-1)+C15_CALFA6*C15_RR+C15_EY+C15_CALFA7*(0+C1_Y+C2_Y+C3_Y+C4_Y+C5_Y+C6_Y+C7_Y+C8_Y+C9_Y+C10_Y+C11_Y+C12_Y+C13_Y+C14_Y+C16_Y+C17_Y+C18_Y+C19_Y+C20_Y)/19 ;
C15_RR = C15_RS-C15_PIE(1) ;
C15_RS = C15_PIE(1)+C15_CALFA8*(C15_PIE-C15_PIESTAR)+C15_CALFA9*C15_Y+C15_ERS ;
C16_PIE = C16_CALFA1*C16_PIE(1)+(1-C16_CALFA1)*C16_PIE(-1)+C16_CALFA2*(C16_Y+0.1)+C16_CALFA3*(C16_Y+0.1)^2/2+C16_EPIE ;
C16_Y = C16_CALFA4*C16_Y(1)+C16_CALFA5*C16_Y(-1)+C16_CALFA6*C16_RR+C16_EY+C16_CALFA7*(0+C1_Y+C2_Y+C3_Y+C4_Y+C5_Y+C6_Y+C7_Y+C8_Y+C9_Y+C10_Y+C11_Y+C12_Y+C13_Y+C14_Y+C15_Y+C17_Y+C18_Y+C19_Y+C20_Y)/19 ;
C16_RR = C16_RS-C16_PIE(1) ;
C16_RS = C16_PIE(1)+C16_CALFA8*(C16_PIE-C16_PIESTAR)+C16_CALFA9*C16_Y+C16_ERS ;
C17_PIE = C17_CALFA1*C17_PIE(1)+(1-C17_CALFA1)*C17_PIE(-1)+C17_CALFA2*(C17_Y+0.1)+C17_CALFA3*(C17_Y+0.1)^2/2+C17_EPIE ;
C17_Y = C17_CALFA4*C17_Y(1)+C17_CALFA5*C17_Y(-1)+C17_CALFA6*C17_RR+C17_EY+C17_CALFA7*(0+C1_Y+C2_Y+C3_Y+C4_Y+C5_Y+C6_Y+C7_Y+C8_Y+C9_Y+C10_Y+C11_Y+C12_Y+C13_Y+C14_Y+C15_Y+C16_Y+C18_Y+C19_Y+C20_Y)/19 ;
C17_RR = C17_RS-C17_PIE(1) ;
C17_RS = C17_PIE(1)+C17_CALFA8*(C17_PIE-C17_PIESTAR)+C17_CALFA9*C17_Y+C17_ERS ;
C18_PIE = C18_CALFA1*C18_PIE(1)+(1-C18_CALFA1)*C18_PIE(-1)+C18_CALFA2*(C18_Y+0.1)+C18_CALFA3*(C18_Y+0.1)^2/2+C18_EPIE ;
C18_Y = C18_CALFA4*C18_Y(1)+C18_CALFA5*C18_Y(-1)+C18_CALFA6*C18_RR+C18_EY+C18_CALFA7*(0+C1_Y+C2_Y+C3_Y+C4_Y+C5_Y+C6_Y+C7_Y+C8_Y+C9_Y+C10_Y+C11_Y+C12_Y+C13_Y+C14_Y+C15_Y+C16_Y+C17_Y+C19_Y+C20_Y)/19 ;
C18_RR = C18_RS-C18_PIE(1) ;
C18_RS = C18_PIE(1)+C18_CALFA8*(C18_PIE-C18_PIESTAR)+C18_CALFA9*C18_Y+C18_ERS ;
C19_PIE = C19_CALFA1*C19_PIE(1)+(1-C19_CALFA1)*C19_PIE(-1)+C19_CALFA2*(C19_Y+0.1)+C19_CALFA3*(C19_Y+0.1)^2/2+C19_EPIE ;
C19_Y = C19_CALFA4*C19_Y(1)+C19_CALFA5*C19_Y(-1)+C19_CALFA6*C19_RR+C19_EY+C19_CALFA7*(0+C1_Y+C2_Y+C3_Y+C4_Y+C5_Y+C6_Y+C7_Y+C8_Y+C9_Y+C10_Y+C11_Y+C12_Y+C13_Y+C14_Y+C15_Y+C16_Y+C17_Y+C18_Y+C20_Y)/19 ;
C19_RR = C19_RS-C19_PIE(1) ;
C19_RS = C19_PIE(1)+C19_CALFA8*(C19_PIE-C19_PIESTAR)+C19_CALFA9*C19_Y+C19_ERS ;
C20_PIE = C20_CALFA1*C20_PIE(1)+(1-C20_CALFA1)*C20_PIE(-1)+C20_CALFA2*(C20_Y+0.1)+C20_CALFA3*(C20_Y+0.1)^2/2+C20_EPIE ;
C20_Y = C20_CALFA4*C20_Y(1)+C20_CALFA5*C20_Y(-1)+C20_CALFA6*C20_RR+C20_EY+C20_CALFA7*(0+C1_Y+C2_Y+C3_Y+C4_Y+C5_Y+C6_Y+C7_Y+C8_Y+C9_Y+C10_Y+C11_Y+C12_Y+C13_Y+C14_Y+C15_Y+C16_Y+C17_Y+C18_Y+C19_Y)/19 ;
C20_RR = C20_RS-C20_PIE(1) ;
C20_RS = C20_PIE(1)+C20_CALFA8*(C20_PIE-C20_PIESTAR)+C20_CALFA9*C20_Y+C20_ERS ;
end;
initval;
C10_PIE=2.5;
C10_RR=0;
C10_RS=2.5;
C10_Y=0;
C11_PIE=2.5;
C11_RR=0;
C11_RS=2.5;
C11_Y=0;
C12_PIE=2.5;
C12_RR=0;
C12_RS=2.5;
C12_Y=0;
C13_PIE=2.5;
C13_RR=0;
C13_RS=2.5;
C13_Y=0;
C14_PIE=2.5;
C14_RR=0;
C14_RS=2.5;
C14_Y=0;
C15_PIE=2.5;
C15_RR=0;
C15_RS=2.5;
C15_Y=0;
C16_PIE=2.5;
C16_RR=0;
C16_RS=2.5;
C16_Y=0;
C17_PIE=2.5;
C17_RR=0;
C17_RS=2.5;
C17_Y=0;
C18_PIE=2.5;
C18_RR=0;
C18_RS=2.5;
C18_Y=0;
C19_PIE=2.5;
C19_RR=0;
C19_RS=2.5;
C19_Y=0;
C1_PIE=2.5;
C1_RR=0;
C1_RS=2.5;
C1_Y=0;
C20_PIE=2.5;
C20_RR=0;
C20_RS=2.5;
C20_Y=0;
C2_PIE=2.5;
C2_RR=0;
C2_RS=2.5;
C2_Y=0;
C3_PIE=2.5;
C3_RR=0;
C3_RS=2.5;
C3_Y=0;
C4_PIE=2.5;
C4_RR=0;
C4_RS=2.5;
C4_Y=0;
C5_PIE=2.5;
C5_RR=0;
C5_RS=2.5;
C5_Y=0;
C6_PIE=2.5;
C6_RR=0;
C6_RS=2.5;
C6_Y=0;
C7_PIE=2.5;
C7_RR=0;
C7_RS=2.5;
C7_Y=0;
C8_PIE=2.5;
C8_RR=0;
C8_RS=2.5;
C8_Y=0;
C9_PIE=2.5;
C9_RR=0;
C9_RS=2.5;
C9_Y=0;
C1_EPIE=0;
C1_EY=0;
C1_ERS=0;
C2_EPIE=0;
C2_EY=0;
C2_ERS=0;
C3_EPIE=0;
C3_EY=0;
C3_ERS=0;
C4_EPIE=0;
C4_EY=0;
C4_ERS=0;
C5_EPIE=0;
C5_EY=0;
C5_ERS=0;
C6_EPIE=0;
C6_EY=0;
C6_ERS=0;
C7_EPIE=0;
C7_EY=0;
C7_ERS=0;
C8_EPIE=0;
C8_EY=0;
C8_ERS=0;
C9_EPIE=0;
C9_EY=0;
C9_ERS=0;
C10_EPIE=0;
C10_EY=0;
C10_ERS=0;
C11_EPIE=0;
C11_EY=0;
C11_ERS=0;
C12_EPIE=0;
C12_EY=0;
C12_ERS=0;
C13_EPIE=0;
C13_EY=0;
C13_ERS=0;
C14_EPIE=0;
C14_EY=0;
C14_ERS=0;
C15_EPIE=0;
C15_EY=0;
C15_ERS=0;
C16_EPIE=0;
C16_EY=0;
C16_ERS=0;
C17_EPIE=0;
C17_EY=0;
C17_ERS=0;
C18_EPIE=0;
C18_EY=0;
C18_ERS=0;
C19_EPIE=0;
C19_EY=0;
C19_ERS=0;
C20_EPIE=0;
C20_EY=0;
C20_ERS=0;
end;
vcov = [
1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0;
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
];
order = 1;
var PIE4EU ZZ_PIE4EU ZZ_RNOMEU GDPGAPEU ZZ_DRNOMEU AF AH BIGGAMF BIGGAMH BIGGAMIMPF BIGGAMIMPH BIGGAMMF BIGGAMMH BIGGAMNF BIGGAMNH BIGGAMQF BIGGAMQH BIGGAM_MONF BIGGAM_MONH BIGGAM_MOTF BIGGAM_MOTH BIGGAM_O_NF BIGGAM_O_NH BIGGAM_O_TF BIGGAM_O_TH CAPAF CAPAH CF CF_NAT CH CH_NAT CURBALF_RAT CURBALH_RAT DEEF DEEH DEPEX EXPORTSF EXPORTSF_NAT EXPORTSH EXPORTSH_NAT EYEF EYEH GAF GAH GAMMAF GAMMAH GDPF GDPF_NAT GDPGAPF GDPGAPH GDPH GDPH_NAT GF_NAT GH_NAT GNF GNH HF HH IMPORTSF IMPORTSF_NAT IMPORTSH IMPORTSH_NAT KF KH KNF KNF_RAT KNH KNH_RAT KTF KTF_RAT KTH KTH_RAT K_OF K_OF_RAT K_OH K_OH_RAT LANDF LANDH LF LH LNF LNH LTF LTH L_OF L_OH MARGUTF MARGUTH MF MF_NAT MH MH_NAT M_ONF M_ONH M_OTF M_OTH NF NH NNF NNH O_NF O_NH O_TF O_TH PIE4F PIE4H PIE4TARF PIE4TARH PIEBARMF PIEBARMH PIEBARQF PIEBARQH PIEF PIEH PIENF PIENH PIEWF PIEWH PSIF PSIH PSIPRIMEF PSIPRIMEH QF QH Q_ONF Q_ONH Q_OTF Q_OTH REALBF REALBH REALEX REALEXF REALEXH REALFINH REALMCNF REALMCNH REALMCTF REALMCTH REALMONEYF REALMONEYH REALPBARMF REALPBARMH REALPBARQF REALPBARQH REALPLANDF REALPLANDH REALPMF REALPMH REALPNF REALPNH REALPQF REALPQH REALPXF REALPXH REALP_MOF REALP_MOH REALP_ONF REALP_ONH REALP_OTF REALP_OTH REALP_QOF REALP_QOH REALRF REALRH REALTBALF REALTBALH REALWF REALWH RNOMF RNOMH SHOPF SHOPH SHOPPRIMEF SHOPPRIMEH TF TH T_OF T_OH VELOF VELOH VPRIMEF VPRIMEH XF_NAT XH_NAT XI ZBF ZBH ZEYEF ZEYEH ZNF ZNH ZTF ZTH ZUF ZUH ZZ_CF ZZ_CH ZZ_CURBALF_RAT ZZ_CURBALH_RAT ZZ_C_SHARF ZZ_C_SHARH ZZ_DPIE4F ZZ_DPIE4H ZZ_DRNOMF ZZ_DRNOMH ZZ_EXPORTSF ZZ_EXPORTSH ZZ_EYEF ZZ_EYEH ZZ_EYE_SHARF ZZ_EYE_SHARH ZZ_GDPF ZZ_GDPH ZZ_GDP_PPP_RATH ZZ_GF ZZ_GH ZZ_IMPORTSF ZZ_IMPORTSH ZZ_M_ON_SHARF ZZ_M_ON_SHARH ZZ_M_OT_SHARF ZZ_M_OT_SHARH ZZ_M_O_SHARF ZZ_M_O_SHARH ZZ_M_SHARF ZZ_M_SHARH ZZ_N_SHARF ZZ_N_SHARH ZZ_PIE4F ZZ_PIE4H ZZ_REALEX ZZ_RNOMF ZZ_RNOMH ZZ_UTILITYF ZZ_UTILITYH ZZ_XBALF_TOT_RAT ZZ_XBALH_TOT_RAT Z_OF Z_OH PIEH_1 PIEH_2 PIEF_1 PIEF_2 REALBH_1 VALUE VALUE2;
varexo E_ZBH E_ZUH E_ZUF E_ZEYEH E_ZEYEF E_GAMMAH E_GAMMAF E_LANDH E_LANDF E_GAH E_GAF E_CAPAH E_CAPAF;
parameters COSTLF COSTLH EPSF EPSH EPSQMF EPSQMH GLAMBDAF GLAMBDAH SIGMAF SIGMAH SSF SSH XR1F XR1H XR2F XR2H XR3F XR3H XR4F XR4H ALPHANF ALPHANH ALPHATF ALPHATH ALPHA_OF ALPHA_OH A_ONEF A_ONEH A_ZEROF A_ZEROH B0F B0H B1F B1H B2F B2H BET CAPAF_SS CAPAH_SS CHI0 CHI1 CHI2 CHI3 COSTF COSTH COST_MONF COST_MONH COST_MOTF COST_MOTH COST_O_NF COST_O_NH COST_O_TF COST_O_TH DELTAF DELTAH EPS_ONF EPS_ONH EPS_OTF EPS_OTH ETAF ETAH E_PIE4TARF E_PIE4TARH E_ZBF GAMA_NF GAMA_NH GAMA_TF GAMA_TH GAMMAF_SS GAMMAH_SS GAMMA_LANDF GAMMA_LANDH GA_RATF GA_RATH GDPF_EXOG GDPH_EXOG GN_RATF GN_RATH LANDF_SS LANDH_SS LILCAPPA1F LILCAPPA1H LILCAPPA2F LILCAPPA2H LILCAPPA3F LILCAPPA3H LILCAPPA4F LILCAPPA4H LILCAPPA5F LILCAPPA5H LILCAPPA6F LILCAPPA6H LILCAPPA7F LILCAPPA7H LILCAPPA8F LILCAPPA8H NYF NYH NY_NF NY_NH NY_TF NY_TH OMEGA0F OMEGA0H OMEGAF OMEGAH PHIF PHIH PIE4TARF_SS PIE4TARH_SS REALEX_EXOG REALPBARMF_EXOG REALPBARMH_EXOG REALPNF_EXOG REALPNH_EXOG REALP_MOF_EXOG REALP_MOH_EXOG RNOM_EXOGF RNOM_EXOGH THETAF THETAH XDUMF XDUMH XIXI_NF XIXI_NH XIXI_OF XIXI_OH XIXI_TF XIXI_TH ZBF_SS ZBH_SS ZEDF ZEDH ZEYEF_SS ZEYEH_SS ZNF_SS ZNH_SS ZTF_SS ZTH_SS ZUF_SS ZUH_SS Z_OF_SS Z_OH_SS;
COSTLF=5;
COSTLH=5;
EPSF=1.1;
EPSH=1.1;
EPSQMF=4;
EPSQMH=1.1;
GLAMBDAF=0;
GLAMBDAH=0;
SIGMAF=0.333333333333333;
SIGMAH=0.333333333333333;
SSF=0.95;
SSH=0.05;
XR1F=1;
XR1H=1;
XR2F=0;
XR2H=0;
XR3F=0.5;
XR3H=0.5;
XR4F=0;
XR4H=0;
ALPHANF=0.33;
ALPHANH=0.4;
ALPHATF=0.33;
ALPHATH=0.4;
ALPHA_OF=0.2;
ALPHA_OH=0.2;
A_ONEF=0.075;
A_ONEH=0.075;
A_ZEROF=0.011;
A_ZEROH=0.011;
B0F=1;
B0H=1;
B1F=0.95;
B1H=0.95;
B2F=1;
B2H=1;
BET=0.99263753614514;
CAPAF_SS=11;
CAPAH_SS=11;
CHI0=0.05;
CHI1=.1;
CHI2=0;
CHI3=0;
COSTF=5;
COSTH=5;
COST_MONF=5;
COST_MONH=5;
COST_MOTF=5;
COST_MOTH=5;
COST_O_NF=5;
COST_O_NH=5;
COST_O_TF=5;
COST_O_TH=5;
DELTAF=0.025;
DELTAH=0.025;
EPS_ONF=3;
EPS_ONH=3;
EPS_OTF=3;
EPS_OTH=3;
ETAF=0.35;
ETAH=0.2;
E_PIE4TARF=0;
E_PIE4TARH=0;
E_ZBF=0;
GAMA_NF=0.3;
GAMA_NH=0.1;
GAMA_TF=0.3;
GAMA_TH=0.5;
GAMMAF_SS=0.5;
GAMMAH_SS=0.25;
GAMMA_LANDF=0.1;
GAMMA_LANDH=0.1;
GA_RATF=0.05;
GA_RATH=0.05;
GDPF_EXOG=2.41500497257461;
GDPH_EXOG=2.90512477822209;
GN_RATF=0.1;
GN_RATH=0.1;
LANDF_SS=0.1;
LANDH_SS=0.1;
LILCAPPA1F=0;
LILCAPPA1H=0;
LILCAPPA2F=800;
LILCAPPA2H=400;
LILCAPPA3F=0;
LILCAPPA3H=0;
LILCAPPA4F=800;
LILCAPPA4H=400;
LILCAPPA5F=0;
LILCAPPA5H=0;
LILCAPPA6F=800;
LILCAPPA6H=400;
LILCAPPA7F=0;
LILCAPPA7H=0;
LILCAPPA8F=0;
LILCAPPA8H=0;
NYF=0.98;
NYH=0.0499999999999999;
NY_NF=0.98;
NY_NH=0.0499999999999999;
NY_TF=0.98;
NY_TH=0.02;
OMEGA0F=60;
OMEGA0H=60;
OMEGAF=5;
OMEGAH=5;
PHIF=3;
PHIH=3;
PIE4TARF_SS=1.125;
PIE4TARH_SS=1.125;
REALEX_EXOG=1.3734519289908;
REALPBARMF_EXOG=0.87146958398196;
REALPBARMH_EXOG=1.19072687148694;
REALPNF_EXOG=0.840675522925242;
REALPNH_EXOG=0.902486321747893;
REALP_MOF_EXOG=0.966533486000563;
REALP_MOH_EXOG=1.63690883121281;
RNOM_EXOGF=1.00741707177773;
RNOM_EXOGH=1.00741707177773;
THETAF=6;
THETAH=6;
XDUMF=1;
XDUMH=1;
XIXI_NF=0.75;
XIXI_NH=0.75;
XIXI_OF=0.75;
XIXI_OH=0.75;
XIXI_TF=0.75;
XIXI_TH=0.75;
ZBF_SS=0;
ZBH_SS=0;
ZEDF=2.5;
ZEDH=2.5;
ZEYEF_SS=0;
ZEYEH_SS=0;
ZNF_SS=1;
ZNH_SS=1;
ZTF_SS=1;
ZTH_SS=0.6;
ZUF_SS=1;
ZUH_SS=1;
Z_OF_SS=1;
Z_OH_SS=1;
model;
PIE4EU = SSH*PIE4H+(1-SSH)*PIE4F;
ZZ_PIE4EU = SSH*ZZ_PIE4H+(1-SSH)*ZZ_PIE4F;
ZZ_RNOMEU = SSH*ZZ_RNOMH+(1-SSH)*ZZ_RNOMF;
ZZ_DRNOMEU = SSH*ZZ_DRNOMH+(1-SSH)*ZZ_DRNOMF;
GDPGAPEU = SSH*GDPGAPH+(1-SSH)*GDPGAPF;
ZZ_UTILITYH = (ZUH*(CH-HH)^(1-SIGMAH)-1)/(1-SIGMAH)-CAPAH*LH^(1+ZEDH)/(1+ZEDH) ;
ZZ_GH = 100*log(GH_NAT) ;
ZZ_CURBALH_RAT = CURBALH_RAT*100 ;
ZZ_M_SHARH = REALPBARMH*MH/AH ;
ZZ_M_O_SHARH = (REALP_MOH*M_ONH+REALP_MOH*M_OTH)/AH ;
ZZ_M_ON_SHARH = REALP_MOH*M_ONH/AH ;
ZZ_M_OT_SHARH = REALP_MOH*M_OTH/AH ;
ZZ_N_SHARH = NH*REALPNH/AH ;
ZZ_EYE_SHARH = EYEH/GDPH ;
ZZ_C_SHARH = CH/GDPH ;
ZZ_GDPH = 100*log(GDPH_NAT) ;
ZZ_CH = 100*log(CH_NAT) ;
ZZ_EYEH = 100*log(EYEH) ;
ZZ_EXPORTSH = 100*log(EXPORTSH_NAT) ;
ZZ_IMPORTSH = 100*log(IMPORTSH_NAT) ;
ZZ_XBALH_TOT_RAT = 100*(EXPORTSH_NAT-IMPORTSH_NAT)/GDPH_NAT ;
ZZ_PIE4H = 100*(PIE4H-1) ;
ZZ_DPIE4H = ZZ_PIE4H-ZZ_PIE4H(-1) ;
ZZ_RNOMH = 100*(RNOMH^4-1) ;
ZZ_DRNOMH = ZZ_RNOMH-ZZ_RNOMH(-1) ;
100*(PIE4TARH-1) = 1*100*(PIE4TARH_SS-1)+(1-1)*100*(PIE4TARH(-1)-1)+E_PIE4TARH ;
log(ZUH) = 0.3*log(ZUH_SS)+0.7*log(ZUH(-1))+E_ZUH ;
ZBH = 0.3*ZBH_SS+0.7*ZBH(-1)+E_ZBH ;
log(LANDH) = 0.05*log(LANDH_SS)+0.95*log(LANDH(-1))+E_LANDH ;
log(ZTH) = 0.05*log(ZTH_SS)+0.95*log(ZTH(-1))+E_LANDH ;
log(ZNH) = 0.05*log(ZNH_SS)+0.95*log(ZNH(-1))+E_LANDH ;
log(Z_OH) = 0.05*log(Z_OH_SS)+0.95*log(Z_OH(-1))+E_LANDH ;
ZEYEH = 0.05*ZEYEH_SS+0.95*ZEYEH(-1)+E_ZEYEH ;
CAPAH = 0.05*CAPAH_SS+0.95*CAPAH(-1)+E_CAPAH ;
log(GAMMAH) = 0.05*log(GAMMAH_SS)+0.95*log(GAMMAH(-1))+E_GAMMAH ;
BIGGAM_O_NH = 1-COST_O_NH/2*(O_NH/NH/(O_NH(-1)/NH(-1))-1)^2 ;
BIGGAM_O_TH = 1-COST_O_TH/2*(O_TH/TH/(O_TH(-1)/TH(-1))-1)^2 ;
O_NH = GAMA_NH*NH/ZNH*(REALP_ONH/(REALMCNH*ZNH))^(-XIXI_NH)*(BIGGAM_O_NH-COST_O_NH*(O_NH/NH/(O_NH(-1)/NH(-1))-1)*O_NH/NH/(O_NH(-1)/NH(-1)))^XIXI_NH/BIGGAM_O_NH ;
O_TH = GAMA_TH*TH/ZTH*(REALP_OTH/(REALMCTH*ZTH))^(-XIXI_TH)*(BIGGAM_O_TH-COST_O_TH*(O_TH/TH/(O_TH(-1)/TH(-1))-1)*O_TH/TH/(O_TH(-1)/TH(-1)))^XIXI_NH/BIGGAM_O_TH ;
NH = ZNH*((1-ALPHANH-GAMA_NH)^(1/XIXI_NH)*LNH^(1-1/XIXI_NH)+ALPHANH^(1/XIXI_NH)*KNH^(1-1/XIXI_NH)+GAMA_NH^(1/XIXI_NH)*(BIGGAM_O_NH*O_NH)^(1-1/XIXI_NH))^(XIXI_NH/(XIXI_NH-1)) ;
TH = ZTH*((1-ALPHATH-GAMA_TH)^(1/XIXI_TH)*LTH^(1-1/XIXI_TH)+ALPHATH^(1/XIXI_TH)*KTH^(1-1/XIXI_TH)+GAMA_TH^(1/XIXI_TH)*(BIGGAM_O_TH*O_TH)^(1-1/XIXI_TH))^(XIXI_TH/(XIXI_TH-1)) ;
REALMCNH = 1/ZNH*((1-ALPHANH-GAMA_NH)*REALWH^(1-XIXI_NH)+ALPHANH*REALRH^(1-XIXI_NH)+GAMA_NH*REALP_ONH^(1-XIXI_NH)*(BIGGAM_O_NH-COST_O_NH*(O_NH/NH/(O_NH(-1)/NH(-1))-1)*O_NH/NH/(O_NH(-1)/NH(-1)))^(XIXI_NH-1))^(1/(1-XIXI_NH)) ;
REALMCTH = 1/ZTH*((1-ALPHATH-GAMA_TH)*REALWH^(1-XIXI_TH)+ALPHATH*REALRH^(1-XIXI_TH)+GAMA_TH*REALP_OTH^(1-XIXI_TH)*(BIGGAM_O_TH-COST_O_TH*(O_TH/TH/(O_TH(-1)/TH(-1))-1)*O_TH/TH/(O_TH(-1)/TH(-1)))^(XIXI_TH-1))^(1/(1-XIXI_TH)) ;
MARGUTH = (CH-B2H*HH)^(-SIGMAH)*ZUH ;
HH = (1-B0H)*HH(-1)+B0H*B1H*CH(-1) ;
VPRIMEH = CAPAH*LH^ZEDH ;
AH^(1-1/EPSH) = GAMMAH^(1/EPSH)*(NYH^(1/EPSQMH)*QH^(1-1/EPSQMH)+(1-NYH)^(1/EPSQMH)*(MH*BIGGAMIMPH)^(1-1/EPSQMH))^(EPSQMH/(EPSQMH-1)*(1-1/EPSH))+(1-GAMMAH)^(1/EPSH)*NNH^(1-1/EPSH) ;
QH = GAMMAH*NYH*REALPQH^(-EPSQMH)*AH*REALPXH^(EPSQMH-EPSH) ;
MH = GAMMAH*(1-NYH)*REALPMH^(-EPSQMH)*AH*REALPXH^(EPSQMH-EPSH)*1/BIGGAMIMPH*(BIGGAMIMPH-COSTH*(MH/AH/(MH(-1)/AH(-1))-1)*MH/AH/(MH(-1)/AH(-1)))^EPSQMH ;
REALPXH = (NYH*REALPQH^(1-EPSQMH)+(1-NYH)*REALPMH^(1-EPSQMH)*(BIGGAMIMPH-COSTH*(MH/AH/(MH(-1)/AH(-1))-1)*MH/AH/(MH(-1)/AH(-1)))^(EPSQMH-1))^(1/(1-EPSQMH)) ;
BIGGAMIMPH = 1-COSTH/2*(MH/AH/(MH(-1)/AH(-1))-1)^2 ;
NNH = (1-GAMMAH)*REALPNH^(-EPSH)*AH ;
NH = NNH+ETAH*MH+ETAH*QH+GNH ;
PIENH = REALPNH/REALPNH(-1)*PIEH ;
BIGGAMNH = LILCAPPA3H/2*(PIENH/PIE4TARH^0.25-1)^2+LILCAPPA4H/2*(PIENH/PIENH(-1)-1)^2 ;
-(1-BIGGAMNH)*(REALPNH*(1-THETAH)+THETAH*REALMCNH) = -(REALPNH-REALMCNH)*(LILCAPPA3H*PIENH/PIE4TARH^0.25*(PIENH/PIE4TARH^0.25-1)+LILCAPPA4H*PIENH/PIENH(-1)*(PIENH/PIENH(-1)-1))+DEEH*PIEH(+1)*(REALPNH(+1)-REALMCNH(+1))*NH(+1)/NH*(LILCAPPA3H*PIENH(+1)/PIE4TARH^0.25*(PIENH(+1)/PIE4TARH^0.25-1)+LILCAPPA4H*PIENH(+1)/PIENH*(PIENH(+1)/PIENH-1)) ;
PIEBARQH = PIEH*REALPBARQH/REALPBARQH(-1) ;
BIGGAMQH = LILCAPPA5H/2*(PIEBARQH/PIE4TARH^0.25-1)^2+LILCAPPA6H/2*(PIEBARQH/PIEBARQH(-1)-1)^2 ;
-(1-BIGGAMQH)*REALPBARQH/REALPQH*(REALPBARQH*(1-THETAH)+ETAH*REALPNH+THETAH*REALMCTH) = -(REALPBARQH-REALMCTH)*(LILCAPPA5H*PIEBARQH/PIE4TARH^0.25*(PIEBARQH/PIE4TARH^0.25-1)+LILCAPPA6H*PIEBARQH/PIEBARQH(-1)*(PIEBARQH/PIEBARQH(-1)-1))+DEEH*PIEH(+1)*(REALPBARQH(+1)-REALMCTH(+1))*QH(+1)/QH*(LILCAPPA5H*PIEBARQH(+1)/PIE4TARH^0.25*(PIEBARQH(+1)/PIE4TARH^0.25-1)+LILCAPPA6H*PIEBARQH(+1)/PIEBARQH*(PIEBARQH(+1)/PIEBARQH-1)) ;
REALPQH = REALPBARQH+ETAH*REALPNH ;
KH = KH(-1)*(1-DELTAH)+PSIH(-1)*KH(-1) ;
PSIH = EYEH/KH-OMEGAH/2*(EYEH/KH-DELTAH*(1+ZEYEH))^2-OMEGA0H/2*(EYEH/KH-EYEH(-1)/KH(-1))^2 ;
PSIPRIMEH = 1-OMEGAH*(EYEH/KH-DELTAH*(1+ZEYEH))-OMEGA0H*(EYEH/KH-EYEH(-1)/KH(-1)) ;
1/PSIPRIMEH = DEEH*PIEH(+1)*(REALRH(+1)+1/PSIPRIMEH(+1)*(1-DELTAH+PSIH(+1)*(1-PSIPRIMEH(+1)*EYEH(+1)/(PSIH(+1)*KH(+1))))) ;
BIGGAMH = LILCAPPA1H/2*(PIEWH/PIE4TARH^0.25-1)^2+LILCAPPA2H/2*(PIEWH/PIEWH(-1)-1)^2 ;
PIEH*REALWH/REALWH(-1) = PIEWH ;
REALWH = PHIH*VPRIMEH/MARGUTH*((PHIH-1)*(1-BIGGAMH)+PIEWH*LILCAPPA1H/PIE4TARH^0.25*(PIEWH/PIE4TARH^0.25-1)+PIEWH/PIEWH(-1)*LILCAPPA2H*(PIEWH/PIEWH(-1)-1)-DEEH*PIEWH(+1)*LH(+1)/LH*LILCAPPA1H*PIEWH(+1)/PIE4TARH^0.25*(PIEWH(+1)/PIE4TARH^0.25-1)-DEEH*PIEWH(+1)*LH(+1)/LH*LILCAPPA2H*PIEWH(+1)/(REALWH/REALWH(-1))*(PIEWH(+1)/PIEWH-1))^(-1) ;
DEEH = BET*MARGUTH(+1)/PIEH(+1)/MARGUTH*(1+SHOPH+SHOPPRIMEH*VELOH)/(1+SHOPH(+1)+SHOPPRIMEH(+1)*VELOH(+1)) ;
SHOPH = A_ZEROH*VELOH+A_ONEH/VELOH-2*(A_ZEROH*A_ONEH)^0.5 ;
SHOPPRIMEH = A_ZEROH-A_ONEH*VELOH^(-2) ;
VELOH = CH/REALMONEYH ;
DEEH = 1-SHOPPRIMEH*VELOH^2 ;
1 = RNOMH*DEEH ;
/*
100*(RNOMH^4-1) = (1-XDUMH)*100*(RNOM_EXOGH^4-1)+XDUMH*(XR3H*100*(RNOMH(-1)^4-1)+(1-XR3H)*(100*((1/BET*PIE4H^0.25)^4-1))+XR1H*(100*(PIE4H-1)-100*(PIE4TARH-1))+XR4H*100*(DEPEX^4-1)+XR2H*GDPGAPH) ;
*/
100*(RNOMH^4-1) = 100*(RNOMH(-1)^4-1)+1000*100*(DEPEX^4-1);
GDPGAPH = 100*(GDPH_NAT-GDPH_EXOG)/GDPH_EXOG ;
PIE4H = PIEH*PIEH(-1)*PIEH_1(-1)*PIEH_2(-1) ;
AH = CH*(1+SHOPH)+EYEH+GAH ;
GAH = .05*(GA_RATH*(GLAMBDAH*GDPH_NAT+(1-GLAMBDAH)*GDPH_EXOG))+.95*GAH(-1)+E_GAH;
GNH = GN_RATH*(GLAMBDAH*GDPH_NAT+(1-GLAMBDAH)*GDPH_EXOG)/REALPNH_EXOG ;
PIEBARMH = PIEH*REALPBARMH/REALPBARMH(-1) ;
BIGGAMMH = LILCAPPA7H/2*(PIEBARMH/PIE4TARH^0.25-1)^2+LILCAPPA8H/2*(PIEBARMH/PIEBARMH(-1)-1)^2 ;
REALPMH = REALPBARMH+ETAH*REALPNH ;
KNH_RAT = ALPHANH/(1-ALPHANH-GAMA_NH)*(REALWH/REALRH)^XIXI_NH ;
KTH_RAT = ALPHATH/(1-ALPHATH-GAMA_TH)*(REALWH/REALRH)^XIXI_TH ;
KNH_RAT = KNH/LNH ;
KTH_RAT = KTH/LTH ;
KH = KTH+KNH+K_OH ;
LH = (LNH+LTH+L_OH)*(1-COSTLH/2*(LNH/(LTH+L_OH)/(LNH(-1)/(LTH(-1)+L_OH(-1)))-1)^2) ;
T_OH = Z_OH*((1-ALPHA_OH-GAMMA_LANDH)^(1/XIXI_OH)*L_OH^(1-1/XIXI_OH)+ALPHA_OH^(1/XIXI_OH)*K_OH^(1-1/XIXI_OH)+GAMMA_LANDH^(1/XIXI_OH)*LANDH^(1-1/XIXI_OH))^(XIXI_OH/(XIXI_OH-1)) ;
Q_ONH = NY_NH*(REALP_QOH/REALP_ONH)^(-EPS_ONH)*O_NH ;
Q_OTH = NY_TH*(REALP_QOH/REALP_OTH)^(-EPS_OTH)*O_TH ;
M_ONH = (1-NY_NH)*(REALP_MOH/REALP_ONH)^(-EPS_ONH)*O_NH*(BIGGAM_MONH-COST_MONH*(M_ONH/O_NH/(M_ONH(-1)/O_NH(-1))-1)*M_ONH/O_NH/(M_ONH(-1)/O_NH(-1)))^EPS_ONH/BIGGAM_MONH ;
M_OTH = (1-NY_TH)*(REALP_MOH/REALP_OTH)^(-EPS_OTH)*O_TH*(BIGGAM_MOTH-COST_MOTH*(M_OTH/O_TH/(M_OTH(-1)/O_TH(-1))-1)*M_OTH/O_TH/(M_OTH(-1)/O_TH(-1)))^EPS_OTH/BIGGAM_MOTH ;
BIGGAM_MONH = 1-COST_MONH/2*(M_ONH/O_NH/(M_ONH(-1)/O_NH(-1))-1)^2 ;
BIGGAM_MOTH = 1-COST_MOTH/2*(M_OTH/O_TH/(M_OTH(-1)/O_TH(-1))-1)^2 ;
K_OH_RAT = ALPHA_OH/(1-ALPHA_OH-GAMMA_LANDH)*(REALWH/REALRH)^XIXI_OH ;
K_OH_RAT = K_OH/L_OH ;
REALP_QOH = 1/Z_OH*((1-ALPHA_OH-GAMMA_LANDH)*REALWH^(1-XIXI_OH)+ALPHA_OH*REALRH^(1-XIXI_OH)+GAMMA_LANDH*REALPLANDH^(1-XIXI_OH))^(1/(1-XIXI_OH)) ;
LANDH = GAMMA_LANDH*(REALPLANDH/(REALP_QOH*Z_OH))^(-XIXI_OH)*T_OH/Z_OH ;
REALP_ONH = (NY_NH*REALP_QOH^(1-EPS_ONH)+(1-NY_NH)*REALP_MOH^(1-EPS_ONH)*(BIGGAM_MONH-COST_MONH*(M_ONH/O_NH/(M_ONH(-1)/O_NH(-1))-1)*M_ONH/O_NH/(M_ONH(-1)/O_NH(-1)))^(EPS_ONH-1))^(1/(1-EPS_ONH)) ;
REALP_OTH = (NY_TH*REALP_QOH^(1-EPS_OTH)+(1-NY_TH)*REALP_MOH^(1-EPS_OTH)*(BIGGAM_MOTH-COST_MOTH*(M_OTH/O_TH/(M_OTH(-1)/O_TH(-1))-1)*M_OTH/O_TH/(M_OTH(-1)/O_TH(-1)))^(EPS_OTH-1))^(1/(1-EPS_OTH)) ;
SSH*TH = SSH*QH+SSF*MF ;
SSH*T_OH = SSH*Q_ONH+SSH*Q_OTH+SSF*M_ONF+SSF*M_OTF ;
REALP_MOH = REALP_QOF*REALEXH ;
ZZ_GDP_PPP_RATH = GDPH/REALEX/GDPF ;
XI = CHI0*(exp(CHI1*REALEX*REALBH)+CHI2*(REALEX*(REALBH-REALBH(-1)/PIEF)/GDPH)^2+CHI3*(REALEX*(REALBH-REALBH(-1)/PIEF)/GDPH-REALEX(-1)*(REALBH(-1)-REALBH_1(-1)/PIEF(-1))/GDPH(-1))^2-1)/(exp(CHI1*REALEX*REALBH)+CHI2*(REALEX*(REALBH-REALBH(-1)/PIEF)/GDPH)^2+CHI3*(REALEX*(REALBH-REALBH(-1)/PIEF)/GDPH-REALEX(-1)*(REALBH(-1)-REALBH_1(-1)/PIEF(-1))/GDPH(-1))^2+1)+ZBH ;
1 = RNOMF*(1-XI)*DEEH*DEPEX(+1) ;
DEPEX = PIEH/PIEF*REALEX/REALEX(-1) ;
REALFINH = RNOMF(-1)*(1-XI(-1))*REALEX*REALBH(-1)/PIEF ;
SSH*DEEH*PIEH(+1)*REALFINH(+1) = SSH*REALFINH+SSH*RNOMF(-1)*XI(-1)*REALEX*REALBH(-1)/PIEF+REALTBALH ;
REALEXH = REALEX ;
REALEXF = 1/REALEXH ;
ZZ_REALEX = 100*log(REALEX) ;
-(1-BIGGAMMH)*REALPBARMH/REALPMH*(REALPBARMH/REALEX*(1-THETAF)+ETAH*REALPNH/REALEX+THETAF*REALMCTF) = -(REALPBARMH/REALEX-REALMCTF)*(LILCAPPA7H*PIEBARMH/PIE4TARH^0.25*(PIEBARMH/PIE4TARH^0.25-1)+LILCAPPA8H*PIEBARMH/PIEBARMH(-1)*(PIEBARMH/PIEBARMH(-1)-1))+DEEF*PIEF(+1)*(REALPBARMH(+1)/REALEX(+1)-REALMCTF(+1))*MH(+1)/MH*(LILCAPPA7H*PIEBARMH(+1)/PIE4TARH^0.25*(PIEBARMH(+1)/PIE4TARH^0.25-1)+LILCAPPA8H*PIEBARMH(+1)/PIEBARMH*(PIEBARMH(+1)/PIEBARMH-1)) ;
GDPH = AH+REALPNH*GNH+EXPORTSH-IMPORTSH+(RNOMF(-1)-1)*REALEX*REALBH(-1)/PIEF ;
GDPH_NAT = AH+REALPNH_EXOG*GNH+EXPORTSH_NAT-IMPORTSH_NAT ;
CH_NAT = CH*(1+SHOPH) ;
GH_NAT = GAH+REALPNH_EXOG*GNH ;
XH_NAT = SSF/SSH*REALEX_EXOG*REALPBARMF_EXOG*MF ;
MH_NAT = REALPBARMH_EXOG*MH ;
CURBALH_RAT = REALEX*(REALBH-REALBH(-1)/PIEF)/GDPH ;
REALTBALH = SSF*(REALPBARMF*MF+REALP_MOF*M_ONF+REALP_MOF*M_OTF)*REALEX-SSH*(REALPBARMH*MH+REALP_MOH*M_ONH+REALP_MOH*M_OTH) ;
EXPORTSH = SSF/SSH*(REALPBARMF*MF+REALP_MOF*M_ONF+REALP_MOF*M_OTF)*REALEX ;
IMPORTSH = REALPBARMH*MH+REALP_MOH*M_ONH+REALP_MOH*M_OTH ;
EXPORTSH_NAT = SSF/SSH*(REALPBARMF_EXOG*MF+REALP_MOF_EXOG*M_ONF+REALP_MOF_EXOG*M_OTF)*REALEX_EXOG ;
IMPORTSH_NAT = REALPBARMH_EXOG*MH+REALP_MOH_EXOG*M_ONH+REALP_MOH_EXOG*M_OTH ;
ZZ_UTILITYF = (ZUF*(CF-HF)^(1-SIGMAF)-1)/(1-SIGMAF)-CAPAF*LF^(1+ZEDF)/(1+ZEDF) ;
ZZ_GF = 100*log(GF_NAT) ;
ZZ_CURBALF_RAT = CURBALF_RAT*100 ;
ZZ_M_SHARF = REALPBARMF*MF/AF ;
ZZ_M_O_SHARF = (REALP_MOF*M_ONF+REALP_MOF*M_OTF)/AF ;
ZZ_M_ON_SHARF = REALP_MOF*M_ONF/AF ;
ZZ_M_OT_SHARF = REALP_MOF*M_OTF/AF ;
ZZ_N_SHARF = NF*REALPNF/AF ;
ZZ_EYE_SHARF = EYEF/GDPF ;
ZZ_C_SHARF = CF/GDPF ;
ZZ_GDPF = 100*log(GDPF_NAT) ;
ZZ_CF = 100*log(CF_NAT) ;
ZZ_EYEF = 100*log(EYEF) ;
ZZ_EXPORTSF = 100*log(EXPORTSF_NAT) ;
ZZ_IMPORTSF = 100*log(IMPORTSF_NAT) ;
ZZ_XBALF_TOT_RAT = 100*(EXPORTSF_NAT-IMPORTSF_NAT)/GDPF_NAT ;
ZZ_PIE4F = 100*(PIE4F-1) ;
ZZ_DPIE4F = ZZ_PIE4F-ZZ_PIE4F(-1) ;
ZZ_RNOMF = 100*(RNOMF^4-1) ;
ZZ_DRNOMF = ZZ_RNOMF-ZZ_RNOMF(-1) ;
100*(PIE4TARF-1) = 1*100*(PIE4TARF_SS-1)+(1-1)*100*(PIE4TARF(-1)-1)+E_PIE4TARF ;
log(ZUF) = 0.3*log(ZUF_SS)+0.7*log(ZUF(-1))+E_ZUF ;
ZBF = 0.3*ZBF_SS+0.7*ZBF(-1)+E_ZBF ;
log(LANDF) = 0.05*log(LANDF_SS)+0.95*log(LANDF(-1))+E_LANDF ;
log(ZTF) = 0.05*log(ZTF_SS)+0.95*log(ZTF(-1))+E_LANDF ;
log(ZNF) = 0.05*log(ZNF_SS)+0.95*log(ZNF(-1))+E_LANDF ;
log(Z_OF) = 0.05*log(Z_OF_SS)+0.95*log(Z_OF(-1))+E_LANDF ;
ZEYEF = 0.05*ZEYEF_SS+0.95*ZEYEF(-1)+E_ZEYEF ;
CAPAF = 0.05*CAPAF_SS+0.95*CAPAF(-1)+E_CAPAF ;
log(GAMMAF) = 0.05*log(GAMMAF_SS)+0.95*log(GAMMAF(-1))+E_GAMMAF ;
BIGGAM_O_NF = 1-COST_O_NF/2*(O_NF/NF/(O_NF(-1)/NF(-1))-1)^2 ;
BIGGAM_O_TF = 1-COST_O_TF/2*(O_TF/TF/(O_TF(-1)/TF(-1))-1)^2 ;
O_NF = GAMA_NF*NF/ZNF*(REALP_ONF/(REALMCNF*ZNF))^(-XIXI_NF)*(BIGGAM_O_NF-COST_O_NF*(O_NF/NF/(O_NF(-1)/NF(-1))-1)*O_NF/NF/(O_NF(-1)/NF(-1)))^XIXI_NF/BIGGAM_O_NF ;
O_TF = GAMA_TF*TF/ZTF*(REALP_OTF/(REALMCTF*ZTF))^(-XIXI_TF)*(BIGGAM_O_TF-COST_O_TF*(O_TF/TF/(O_TF(-1)/TF(-1))-1)*O_TF/TF/(O_TF(-1)/TF(-1)))^XIXI_NF/BIGGAM_O_TF ;
NF = ZNF*((1-ALPHANF-GAMA_NF)^(1/XIXI_NF)*LNF^(1-1/XIXI_NF)+ALPHANF^(1/XIXI_NF)*KNF^(1-1/XIXI_NF)+GAMA_NF^(1/XIXI_NF)*(BIGGAM_O_NF*O_NF)^(1-1/XIXI_NF))^(XIXI_NF/(XIXI_NF-1)) ;
TF = ZTF*((1-ALPHATF-GAMA_TF)^(1/XIXI_TF)*LTF^(1-1/XIXI_TF)+ALPHATF^(1/XIXI_TF)*KTF^(1-1/XIXI_TF)+GAMA_TF^(1/XIXI_TF)*(BIGGAM_O_TF*O_TF)^(1-1/XIXI_TF))^(XIXI_TF/(XIXI_TF-1)) ;
REALMCNF = 1/ZNF*((1-ALPHANF-GAMA_NF)*REALWF^(1-XIXI_NF)+ALPHANF*REALRF^(1-XIXI_NF)+GAMA_NF*REALP_ONF^(1-XIXI_NF)*(BIGGAM_O_NF-COST_O_NF*(O_NF/NF/(O_NF(-1)/NF(-1))-1)*O_NF/NF/(O_NF(-1)/NF(-1)))^(XIXI_NF-1))^(1/(1-XIXI_NF)) ;
REALMCTF = 1/ZTF*((1-ALPHATF-GAMA_TF)*REALWF^(1-XIXI_TF)+ALPHATF*REALRF^(1-XIXI_TF)+GAMA_TF*REALP_OTF^(1-XIXI_TF)*(BIGGAM_O_TF-COST_O_TF*(O_TF/TF/(O_TF(-1)/TF(-1))-1)*O_TF/TF/(O_TF(-1)/TF(-1)))^(XIXI_TF-1))^(1/(1-XIXI_TF)) ;
MARGUTF = (CF-B2F*HF)^(-SIGMAF)*ZUF ;
HF = (1-B0F)*HF(-1)+B0F*B1F*CF(-1) ;
VPRIMEF = CAPAF*LF^ZEDF ;
AF^(1-1/EPSF) = GAMMAF^(1/EPSF)*(NYF^(1/EPSQMF)*QF^(1-1/EPSQMF)+(1-NYF)^(1/EPSQMF)*(MF*BIGGAMIMPF)^(1-1/EPSQMF))^(EPSQMF/(EPSQMF-1)*(1-1/EPSF))+(1-GAMMAF)^(1/EPSF)*NNF^(1-1/EPSF) ;
QF = GAMMAF*NYF*REALPQF^(-EPSQMF)*AF*REALPXF^(EPSQMF-EPSF) ;
MF = GAMMAF*(1-NYF)*REALPMF^(-EPSQMF)*AF*REALPXF^(EPSQMF-EPSF)*1/BIGGAMIMPF*(BIGGAMIMPF-COSTF*(MF/AF/(MF(-1)/AF(-1))-1)*MF/AF/(MF(-1)/AF(-1)))^EPSQMF ;
REALPXF = (NYF*REALPQF^(1-EPSQMF)+(1-NYF)*REALPMF^(1-EPSQMF)*(BIGGAMIMPF-COSTF*(MF/AF/(MF(-1)/AF(-1))-1)*MF/AF/(MF(-1)/AF(-1)))^(EPSQMF-1))^(1/(1-EPSQMF)) ;
BIGGAMIMPF = 1-COSTF/2*(MF/AF/(MF(-1)/AF(-1))-1)^2 ;
NNF = (1-GAMMAF)*REALPNF^(-EPSF)*AF ;
NF = NNF+ETAF*MF+ETAF*QF+GNF ;
PIENF = REALPNF/REALPNF(-1)*PIEF ;
BIGGAMNF = LILCAPPA3F/2*(PIENF/PIE4TARF^0.25-1)^2+LILCAPPA4F/2*(PIENF/PIENF(-1)-1)^2 ;
-(1-BIGGAMNF)*(REALPNF*(1-THETAF)+THETAF*REALMCNF) = -(REALPNF-REALMCNF)*(LILCAPPA3F*PIENF/PIE4TARF^0.25*(PIENF/PIE4TARF^0.25-1)+LILCAPPA4F*PIENF/PIENF(-1)*(PIENF/PIENF(-1)-1))+DEEF*PIEF(+1)*(REALPNF(+1)-REALMCNF(+1))*NF(+1)/NF*(LILCAPPA3F*PIENF(+1)/PIE4TARF^0.25*(PIENF(+1)/PIE4TARF^0.25-1)+LILCAPPA4F*PIENF(+1)/PIENF*(PIENF(+1)/PIENF-1)) ;
PIEBARQF = PIEF*REALPBARQF/REALPBARQF(-1) ;
BIGGAMQF = LILCAPPA5F/2*(PIEBARQF/PIE4TARF^0.25-1)^2+LILCAPPA6F/2*(PIEBARQF/PIEBARQF(-1)-1)^2 ;
-(1-BIGGAMQF)*REALPBARQF/REALPQF*(REALPBARQF*(1-THETAF)+ETAF*REALPNF+THETAF*REALMCTF) = -(REALPBARQF-REALMCTF)*(LILCAPPA5F*PIEBARQF/PIE4TARF^0.25*(PIEBARQF/PIE4TARF^0.25-1)+LILCAPPA6F*PIEBARQF/PIEBARQF(-1)*(PIEBARQF/PIEBARQF(-1)-1))+DEEF*PIEF(+1)*(REALPBARQF(+1)-REALMCTF(+1))*QF(+1)/QF*(LILCAPPA5F*PIEBARQF(+1)/PIE4TARF^0.25*(PIEBARQF(+1)/PIE4TARF^0.25-1)+LILCAPPA6F*PIEBARQF(+1)/PIEBARQF*(PIEBARQF(+1)/PIEBARQF-1)) ;
REALPQF = REALPBARQF+ETAF*REALPNF ;
KF = KF(-1)*(1-DELTAF)+PSIF(-1)*KF(-1) ;
PSIF = EYEF/KF-OMEGAF/2*(EYEF/KF-DELTAF*(1+ZEYEF))^2-OMEGA0F/2*(EYEF/KF-EYEF(-1)/KF(-1))^2 ;
PSIPRIMEF = 1-OMEGAF*(EYEF/KF-DELTAF*(1+ZEYEF))-OMEGA0F*(EYEF/KF-EYEF(-1)/KF(-1)) ;
1/PSIPRIMEF = DEEF*PIEF(+1)*(REALRF(+1)+1/PSIPRIMEF(+1)*(1-DELTAF+PSIF(+1)*(1-PSIPRIMEF(+1)*EYEF(+1)/(PSIF(+1)*KF(+1))))) ;
BIGGAMF = LILCAPPA1F/2*(PIEWF/PIE4TARF^0.25-1)^2+LILCAPPA2F/2*(PIEWF/PIEWF(-1)-1)^2 ;
PIEF*REALWF/REALWF(-1) = PIEWF ;
REALWF = PHIF*VPRIMEF/MARGUTF*((PHIF-1)*(1-BIGGAMF)+PIEWF*LILCAPPA1F/PIE4TARF^0.25*(PIEWF/PIE4TARF^0.25-1)+PIEWF/PIEWF(-1)*LILCAPPA2F*(PIEWF/PIEWF(-1)-1)-DEEF*PIEWF(+1)*LF(+1)/LF*LILCAPPA1F*PIEWF(+1)/PIE4TARF^0.25*(PIEWF(+1)/PIE4TARF^0.25-1)-DEEF*PIEWF(+1)*LF(+1)/LF*LILCAPPA2F*PIEWF(+1)/(REALWF/REALWF(-1))*(PIEWF(+1)/PIEWF-1))^(-1) ;
DEEF = BET*MARGUTF(+1)/PIEF(+1)/MARGUTF*(1+SHOPF+SHOPPRIMEF*VELOF)/(1+SHOPF(+1)+SHOPPRIMEF(+1)*VELOF(+1)) ;
SHOPF = A_ZEROF*VELOF+A_ONEF/VELOF-2*(A_ZEROF*A_ONEF)^0.5 ;
SHOPPRIMEF = A_ZEROF-A_ONEF*VELOF^(-2) ;
VELOF = CF/REALMONEYF ;
DEEF = 1-SHOPPRIMEF*VELOF^2 ;
1 = RNOMF*DEEF ;
100*(RNOMF^4-1) = (1-XDUMF)*100*(RNOM_EXOGF^4-1)
+XDUMF*(XR3F*100*(RNOMF(-1)^4-1)+
(1-XR3F)*(100*((1/BET*PIE4EU^0.25)^4-1))
+XR1F*(100*(PIE4EU-1)-100*(PIE4TARF-1))+XR4F*100*(DEPEX^4-1)+XR2F*GDPGAPEU) ;
GDPGAPF = 100*(GDPF_NAT-GDPF_EXOG)/GDPF_EXOG ;
PIE4F = PIEF*PIEF(-1)*PIEF_1(-1)*PIEF_2(-1) ;
AF = CF*(1+SHOPF)+EYEF+GAF ;
GAF = .05*(GA_RATF*(GLAMBDAF*GDPF_NAT+(1-GLAMBDAF)*GDPF_EXOG))+.95*GAF(-1)+E_GAF;
GNF = GN_RATF*(GLAMBDAF*GDPF_NAT+(1-GLAMBDAF)*GDPF_EXOG)/REALPNF_EXOG ;
PIEBARMF = PIEF*REALPBARMF/REALPBARMF(-1) ;
BIGGAMMF = LILCAPPA7F/2*(PIEBARMF/PIE4TARF^0.25-1)^2+LILCAPPA8F/2*(PIEBARMF/PIEBARMF(-1)-1)^2 ;
REALPMF = REALPBARMF+ETAF*REALPNF ;
KNF_RAT = ALPHANF/(1-ALPHANF-GAMA_NF)*(REALWF/REALRF)^XIXI_NF ;
KTF_RAT = ALPHATF/(1-ALPHATF-GAMA_TF)*(REALWF/REALRF)^XIXI_TF ;
KNF_RAT = KNF/LNF ;
KTF_RAT = KTF/LTF ;
KF = KTF+KNF+K_OF ;
LF = (LNF+LTF+L_OF)*(1-COSTLF/2*(LNF/(LTF+L_OF)/(LNF(-1)/(LTF(-1)+L_OF(-1)))-1)^2) ;
T_OF = Z_OF*((1-ALPHA_OF-GAMMA_LANDF)^(1/XIXI_OF)*L_OF^(1-1/XIXI_OF)+ALPHA_OF^(1/XIXI_OF)*K_OF^(1-1/XIXI_OF)+GAMMA_LANDF^(1/XIXI_OF)*LANDF^(1-1/XIXI_OF))^(XIXI_OF/(XIXI_OF-1)) ;
Q_ONF = NY_NF*(REALP_QOF/REALP_ONF)^(-EPS_ONF)*O_NF ;
Q_OTF = NY_TF*(REALP_QOF/REALP_OTF)^(-EPS_OTF)*O_TF ;
M_ONF = (1-NY_NF)*(REALP_MOF/REALP_ONF)^(-EPS_ONF)*O_NF*(BIGGAM_MONF-COST_MONF*(M_ONF/O_NF/(M_ONF(-1)/O_NF(-1))-1)*M_ONF/O_NF/(M_ONF(-1)/O_NF(-1)))^EPS_ONF/BIGGAM_MONF ;
M_OTF = (1-NY_TF)*(REALP_MOF/REALP_OTF)^(-EPS_OTF)*O_TF*(BIGGAM_MOTF-COST_MOTF*(M_OTF/O_TF/(M_OTF(-1)/O_TF(-1))-1)*M_OTF/O_TF/(M_OTF(-1)/O_TF(-1)))^EPS_OTF/BIGGAM_MOTF ;
BIGGAM_MONF = 1-COST_MONF/2*(M_ONF/O_NF/(M_ONF(-1)/O_NF(-1))-1)^2 ;
BIGGAM_MOTF = 1-COST_MOTF/2*(M_OTF/O_TF/(M_OTF(-1)/O_TF(-1))-1)^2 ;
K_OF_RAT = ALPHA_OF/(1-ALPHA_OF-GAMMA_LANDF)*(REALWF/REALRF)^XIXI_OF ;
K_OF_RAT = K_OF/L_OF ;
REALP_QOF = 1/Z_OF*((1-ALPHA_OF-GAMMA_LANDF)*REALWF^(1-XIXI_OF)+ALPHA_OF*REALRF^(1-XIXI_OF)+GAMMA_LANDF*REALPLANDF^(1-XIXI_OF))^(1/(1-XIXI_OF)) ;
LANDF = GAMMA_LANDF*(REALPLANDF/(REALP_QOF*Z_OF))^(-XIXI_OF)*T_OF/Z_OF ;
REALP_ONF = (NY_NF*REALP_QOF^(1-EPS_ONF)+(1-NY_NF)*REALP_MOF^(1-EPS_ONF)*(BIGGAM_MONF-COST_MONF*(M_ONF/O_NF/(M_ONF(-1)/O_NF(-1))-1)*M_ONF/O_NF/(M_ONF(-1)/O_NF(-1)))^(EPS_ONF-1))^(1/(1-EPS_ONF)) ;
REALP_OTF = (NY_TF*REALP_QOF^(1-EPS_OTF)+(1-NY_TF)*REALP_MOF^(1-EPS_OTF)*(BIGGAM_MOTF-COST_MOTF*(M_OTF/O_TF/(M_OTF(-1)/O_TF(-1))-1)*M_OTF/O_TF/(M_OTF(-1)/O_TF(-1)))^(EPS_OTF-1))^(1/(1-EPS_OTF)) ;
SSF*TF = SSF*QF+SSH*MH ;
SSF*T_OF = SSF*Q_ONF+SSF*Q_OTF+SSH*M_ONH+SSH*M_OTH ;
REALP_MOF = REALP_QOH*REALEXF ;
SSH*REALBH+SSF*REALBF = 0 ;
REALTBALF = SSF*(REALPBARMF*MF+REALP_MOF*M_ONF+REALP_MOF*M_OTF)-SSH*(REALPBARMH*MH+REALP_MOH*M_ONH+REALP_MOH*M_OTH)*1/REALEX ;
EXPORTSF = SSH/SSF*(REALPBARMH*MH+REALP_MOH*M_ONH+REALP_MOH*M_OTH)*1/REALEX ;
IMPORTSF = REALPBARMF*MF+REALP_MOF*M_ONF+REALP_MOF*M_OTF ;
EXPORTSF_NAT = SSH/SSF*(REALPBARMH_EXOG*MH+REALP_MOH_EXOG*M_ONH+REALP_MOH_EXOG*M_OTH)*1/REALEX_EXOG ;
IMPORTSF_NAT = REALPBARMF_EXOG*MF+REALP_MOF_EXOG*M_ONF+REALP_MOF_EXOG*M_OTF ;
-(1-BIGGAMMF)*REALPBARMF/REALPMF*(REALPBARMF*REALEX*(1-THETAH)+ETAF*REALPNF*REALEX+THETAH*REALMCTH) = -(REALPBARMF*REALEX-REALMCTH)*(LILCAPPA7F*PIEBARMF/PIE4TARF^0.25*(PIEBARMF/PIE4TARF^0.25-1)+LILCAPPA8F*PIEBARMF/PIEBARMF(-1)*(PIEBARMF/PIEBARMF(-1)-1))+DEEH*PIEH(+1)*(REALPBARMF(+1)*REALEX(+1)-REALMCTH(+1))*MF(+1)/MF*(LILCAPPA7F*PIEBARMF(+1)/PIE4TARF^0.25*(PIEBARMF(+1)/PIE4TARF^0.25-1)+LILCAPPA8F*PIEBARMF(+1)/PIEBARMF*(PIEBARMF(+1)/PIEBARMF-1)) ;
GDPF = AF+REALPNF*GNF+EXPORTSF-IMPORTSF+(RNOMF(-1)-1)*REALBF(-1)/PIEF ;
GDPF_NAT = AF+REALPNF_EXOG*GNF+EXPORTSF_NAT-IMPORTSF_NAT ;
CF_NAT = CF*(1+SHOPF) ;
GF_NAT = GAF+REALPNF_EXOG*GNF ;
XF_NAT = SSH/SSF*1/REALEX_EXOG*REALPBARMH_EXOG*MH ;
MF_NAT = REALPBARMF_EXOG*MF ;
CURBALF_RAT = -(REALTBALH/REALEX/SSF/GDPF)+(RNOMF(-1)-1)*REALBF(-1)/PIEF/GDPF ;
PIEH_1 = PIEH(-1);
PIEH_2 = PIEH_1(-1);
PIEF_1 = PIEF(-1);
PIEF_2 = PIEF_1(-1);
REALBH_1 = REALBH(-1);
VALUE = ZZ_UTILITYH + BET*VALUE(+1);
VALUE2 = ZUH*CH^(1-SIGMAH)/(1-SIGMAH)-CAPAH*LH^(1+ZEDH)/(1+ZEDH) + BET*VALUE2(+1);
end;
initval;
AF=2.17350447531715;
AH=2.61461230039988;
BIGGAMF=0;
BIGGAMH=0;
BIGGAMIMPF=1;
BIGGAMIMPH=1;
BIGGAMMF=0;
BIGGAMMH=0;
BIGGAMNF=0;
BIGGAMNH=0;
BIGGAMQF=0;
BIGGAMQH=0;
BIGGAM_MONF=1;
BIGGAM_MONH=1;
BIGGAM_MOTF=1;
BIGGAM_MOTH=1;
BIGGAM_O_NF=1;
BIGGAM_O_NH=1;
BIGGAM_O_TF=1;
BIGGAM_O_TH=1;
CAPAF=11;
CAPAH=11;
CF=1.77599320017707;
CF_NAT=1.77797456682707;
CH=2.10139281352027;
CH_NAT=2.10373720855446;
CURBALF_RAT=2.20209042676066e-018;
CURBALH_RAT=0;
DEEF=0.963834712172592;
DEEH=0.963834712172592;
DEPEX=1;
EXPORTSF=0.0374229290542059;
EXPORTSF_NAT=0.0374229290542059;
EXPORTSH=0.976573287861717;
EXPORTSH_NAT=0.976573287861717;
EYEF=0.27477965986135;
EYEH=0.365618852934316;
GAF=0.12075024862873;
GAH=0.145256238911104;
GAMMAF=0.5;
GAMMAH=0.25;
GDPF=2.41500497257461;
GDPF_NAT=2.41500497257461;
GDPGAPF=0;
GDPGAPH=0;
GDPH=2.90512477822209;
GDPH_NAT=2.90512477822209;
GF_NAT=0.362250745886191;
GH_NAT=0.435768716733313;
GNF=0.287269571519256;
GNH=0.321902361090147;
HF=1.68719354016822;
HH=1.99632317284426;
IMPORTSF=0.0374229290542059;
IMPORTSF_NAT=0.0374229290542059;
IMPORTSH=0.976573287861718;
IMPORTSH_NAT=0.976573287861718;
KF=10.991186394454;
KH=14.6247541173726;
KNF=6.33686501417153;
KNF_RAT=22.6981730731029;
KNH=11.034700665508;
KNH_RAT=22.8755992006951;
KTF=2.97137434524903;
KTF_RAT=22.6981730731029;
KTH=2.23720856941572;
KTH_RAT=114.377996003476;
K_OF=1.68294703503345;
K_OF_RAT=7.27127622255245;
K_OH=1.35284488244891;
K_OH_RAT=8.16985685739111;
LANDF=0.1;
LANDH=0.1;
LF=0.64153899810027;
LH=0.667528221502678;
LNF=0.279179517830034;
LNH=0.482378650224502;
LTF=0.130908083909629;
LTH=0.019559781143112;
L_OF=0.231451396360608;
L_OH=0.165589790135064;
MARGUTF=2.24145263303312;
MARGUTH=2.11921125101343;
MF=0.0196445696804563;
MF_NAT=0.0171196449669319;
MH=0.438784845846124;
MH_NAT=0.522472906750236;
M_ONF=0.0143006671963624;
M_ONH=0.134410532365428;
M_OTF=0.00670562423725087;
M_OTH=0.143002828997546;
NF=1.91582345366461;
NH=2.609674642079;
NNF=1.31534385473198;
NNH=2.19524942542191;
O_NF=0.387338325509274;
O_NH=0.147043832240678;
O_TF=0.18162406186278;
O_TH=0.148205762233076;
PIE4F=1.125;
PIE4H=1.125;
PIE4TARF=1.125;
PIE4TARH=1.125;
PIEBARMF=1.02988357195356;
PIEBARMH=1.02988357195356;
PIEBARQF=1.02988357195356;
PIEBARQH=1.02988357195356;
PIEF=1.02988357195356;
PIEF_1=1.02988357195356;
PIEF_2=1.02988357195356;
PIEH=1.02988357195356;
PIEH_1=1.02988357195356;
PIEH_2=1.02988357195356;
PIENF=1.02988357195356;
PIENH=1.02988357195356;
PIEWF=1.02988357195356;
PIEWH=1.02988357195356;
PSIF=0.025;
PSIH=0.025;
PSIPRIMEF=1;
PSIPRIMEH=1;
QF=0.875241222929181;
QH=0.0238294319885835;
Q_ONF=0.373740369418894;
Q_ONH=0.0132636199615755;
Q_OTF=0.175247940896905;
Q_OTH=0.00547180886242481;
REALBF=0;
REALBH=0;
REALBH_1=0;
REALEX=1.3734519289908;
REALEXF=0.728092464608345;
REALEXH=1.3734519289908;
REALFINH=0;
REALMCNF=0.700562935771035;
REALMCNH=0.752071934789911;
REALMCTF=0.700562935771035;
REALMCTH=0.930081384894704;
REALMONEYF=0.558667031035572;
REALMONEYH=0.661026677383566;
REALPBARMF=0.87146958398196;
REALPBARMH=1.19072687148694;
REALPBARQF=0.899522809530009;
REALPBARQH=1.15219711474356;
REALPLANDF=0.554831427212494;
REALPLANDH=0.414697221827051;
REALPMF=1.16570601700579;
REALPMH=1.37122413583652;
REALPNF=0.840675522925242;
REALPNH=0.902486321747893;
REALPQF=1.19375924255384;
REALPQH=1.33269437909314;
REALPXF=1.19317131724075;
REALPXH=1.36926881180313;
REALP_MOF=0.966533486000563;
REALP_MOH=1.63690883121281;
REALP_ONF=1.18566549908199;
REALP_ONH=1.61601524261254;
REALP_OTF=1.18566549908199;
REALP_OTH=1.62845456685201;
REALP_QOF=1.1918209852569;
REALP_QOH=1.32748728078168;
REALRF=0.0324170717777328;
REALRH=0.0324170717777329;
REALTBALF=-6.93889390390723e-018;
REALTBALH=-6.93889390390723e-018;
REALWF=2.42667732699502;
REALWH=2.83454771236558;
RNOMF=1.03752229232945;
RNOMH=1.03752229232945;
SHOPF=0.00111563864647424;
SHOPH=0.00111563864647424;
SHOPPRIMEF=0.00357861859467432;
SHOPPRIMEH=0.00357861859467432;
TF=0.89833516218424;
TH=0.397076255917254;
T_OF=0.563589013545429;
T_OH=0.417854966062653;
VALUE=-2.621110285550203e+02;
VALUE2=2.305114066037580e+02;
VELOF=3.17898336847443;
VELOH=3.17898336847443;
VPRIMEF=3.62618818940983;
VPRIMEH=4.00467026905301;
XF_NAT=0.0200215045456245;
XH_NAT=0.446747178665936;
XI=0;
ZBF=0;
ZBH=0;
ZEYEF=0;
ZEYEH=0;
ZNF=1;
ZNH=1;
ZTF=1;
ZTH=0.6;
ZUF=1;
ZUH=1;
ZZ_CF=57.5474832617676;
ZZ_CH=74.3715386197541;
ZZ_CURBALF_RAT=2.20209042676066e-016;
ZZ_CURBALH_RAT=0;
ZZ_C_SHARF=0.735399396831762;
ZZ_C_SHARH=0.723339950584259;
ZZ_DPIE4F=0;
ZZ_DPIE4H=0;
ZZ_DRNOMF=0;
ZZ_DRNOMH=0;
ZZ_EXPORTSF=-328.547168610049;
ZZ_EXPORTSH=-2.37054799079326;
ZZ_EYEF=-129.17857393452;
ZZ_EYEH=-100.616387362469;
ZZ_EYE_SHARF=0.113780163180538;
ZZ_EYE_SHARH=0.12585306341233;
ZZ_GDPF=88.1701346139521;
ZZ_GDPH=106.647634229781;
ZZ_GDP_PPP_RATH=0.875857186130553;
ZZ_GF=-101.541863874636;
ZZ_GH=-83.0643642588075;
ZZ_IMPORTSF=-328.547168610049;
ZZ_IMPORTSH=-2.37054799079323;
ZZ_M_ON_SHARF=0.0063593490946998;
ZZ_M_ON_SHARH=0.084149297164759;
ZZ_M_OT_SHARF=0.00298191719568198;
ZZ_M_OT_SHARH=0.0895286056899133;
ZZ_M_O_SHARF=0.00934126629038178;
ZZ_M_O_SHARH=0.173677902854672;
ZZ_M_SHARF=0.00787651700806085;
ZZ_M_SHARH=0.19982806118916;
ZZ_N_SHARF=0.741008772713445;
ZZ_N_SHARH=0.90078198910348;
ZZ_PIE4F=12.5;
ZZ_PIE4H=12.5;
ZZ_REALEX=31.7327227026121;
ZZ_RNOMF=15.8749999999999;
ZZ_RNOMH=15.8749999999999;
ZZ_UTILITYF=-1.86610854895021;
ZZ_UTILITYH=-1.9297829736965;
ZZ_XBALF_TOT_RAT=0;
ZZ_XBALH_TOT_RAT=-7.6432037132987e-015;
Z_OF=1;
Z_OH=1;
E_ZBH=0;
E_ZUH=0;
E_ZUF=0;
E_ZEYEH=0;
E_ZEYEF=0;
E_GAMMAH=0;
E_GAMMAF=0;
E_LANDH=0;
E_LANDF=0;
E_GAH = 0;
E_GAF = 0;
E_CAPAH=0;
E_CAPAF=0;
ZZ_PIE4EU= 12.5;
ZZ_RNOMEU=15.8749999999999;
GDPGAPEU= 0;
ZZ_DRNOMEU=0;
PIE4EU = 1.125;
end;
vcov = [
/* E_ZBH 0.000289 */
0.000289 0 0 0 0 0 0 0 0 0 0 0 0;
/* E_ZUH */
0 0.000016 0 0 0 0 0 0 0 0 0 0 0;
/* E_ZUF */
0 0 0.000001 0 0 0 0 0 0 0 0 0 0;
/* E_ZEYEH */
0 0 0 0.0049 0 0 0 0 0 0 0 0 0;
/* E_ZEYEF */
0 0 0 0 0.000025 0 0 0 0 0 0 0 0;
/* E_GAMMAH */
0 0 0 0 0 0.0004 0 0 0 0 0 0 0;
/* E_GAMMAF */
0 0 0 0 0 0 0.000324 0 0 0 0 0 0;
/* E_LANDH */
0 0 0 0 0 0 0 0.000004 0 0 0 0 0;
/* E_LANDF */
0 0 0 0 0 0 0 0 0.00000001 0 0 0 0;
/* E_GAH */
0 0 0 0 0 0 0 0 0 0.00001225 0 0 0;
/* E_GAF */
0 0 0 0 0 0 0 0 0 0 0.0000005625 0 0;
/* E_CAPAH */
0 0 0 0 0 0 0 0 0 0 0 0.1 0;
/* E_CAPAF */
0 0 0 0 0 0 0 0 0 0 0 0 0.0001
];
order = 2;
\ No newline at end of file
var C K r w N tau I;
varexo e;
parameters alph bet delt thet tau_m rho;
alph = 0.3;
bet = 0.96;
thet = 0.3;
delt = 0.05;
tau_m = 0.35;
rho = 0.8;
model;
C = C(+1)/(bet*(r(+1)+1-delt));
I = K(-1)^alph*N^(1-alph)-C;
K = I+(1-delt)*K(-1);
N = 1-(1-thet)*C/(thet*w);
r = (1-tau)*alph*(K(-1)/N)^(alph-1);
w = (1-tau)*(1-alph)*(K(-1)/N)^alph;
tau = (1-rho)*tau_m + rho*tau(-1)+e;
end;
initval;
C=0.2;
I=0.02;
K=0.5;
N=0.18;
r=0.09;
w=0.6;
tau=0.35;
e=0;
end;
vcov = [0.007208];
order=7;