/* * Copyright © 2008-2025 Dynare Team * * This file is part of Dynare. * * Dynare is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Dynare is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Dynare. If not, see . */ // GP, based on work by O.Kamenik #include "k_ord_dynare.hh" #include "dynamic_abstract_class.hh" #include "dynare_exception.hh" #include #include KordpDynare::KordpDynare(const std::vector& endo, const std::vector& exo, int nexog, int npar, Vector& ysteady, TwoDMatrix& vcov, Vector& inParams, int nstat, int npred, int nforw, int nboth, int nsteps, int norder, Journal& jr, std::unique_ptr dynamicModelFile_arg, const std::vector& dr_order) : nStat {nstat}, nBoth {nboth}, nPred {npred}, nForw {nforw}, nExog {nexog}, nPar {npar}, nYs {npred + nboth}, nYss {nboth + nforw}, nY {nstat + npred + nboth + nforw}, nJcols {nExog + nY + nYs + nYss}, nSteps {nsteps}, nOrder {norder}, journal {jr}, ySteady {ysteady}, params {inParams}, vCov {vcov}, md {1}, dnl {endo}, denl {exo}, dsnl {*this, dnl, denl}, dynamicModelFile {std::move(dynamicModelFile_arg)} { computeJacobianPermutation(dr_order); } void KordpDynare::solveDeterministicSteady() { JournalRecordPair pa(journal); pa << "Non-linear solver for deterministic steady state skipped" << endrec; } void KordpDynare::evaluateSystem(Vector& out, [[maybe_unused]] const ConstVector& yy, [[maybe_unused]] const Vector& xx) { // This method is only called when checking the residuals at steady state (Approximation::check), // so return zero residuals out.zeros(); } void KordpDynare::evaluateSystem(Vector& out, [[maybe_unused]] const ConstVector& yym, [[maybe_unused]] const ConstVector& yy, [[maybe_unused]] const ConstVector& yyp, [[maybe_unused]] const Vector& xx) { // This method is only called when checking the residuals at steady state (Approximation::check), // so return zero residuals out.zeros(); } void KordpDynare::calcDerivativesAtSteady() { assert(md.begin() == md.end()); Vector xx(nexog()); xx.zeros(); Vector out(nY); out.zeros(); Vector llxSteady(3 * nY); std::ranges::copy_n(ySteady.base(), nY, llxSteady.base()); std::ranges::copy_n(ySteady.base(), nY, llxSteady.base() + nY); std::ranges::copy_n(ySteady.base(), nY, llxSteady.base() + 2 * nY); dynamicModelFile->eval(llxSteady, xx, params, ySteady, out, dynToDynpp, md); } /* Computes mapping between Dynare and Dynare++ orderings of the (dynamic) variable indices in derivatives. If one defines: – y (resp. x) as the vector of all endogenous (size nY), in DR-order (resp. declaration order) – y⁻ as the vector of endogenous that appear at previous period (size nYs), in DR-order – y⁺ as the vector of endogenous that appear at future period (size nYss) in DR-order – u as the vector of exogenous (size nExog) In Dynare++, the vector is of size nY+nYs+nYss+nExog and the ordering is (y⁺, y, y⁻, u). In Dynare, the vector is of size 3*nY+nExog and the ordering is (x, x, x, u). */ void KordpDynare::computeJacobianPermutation(const std::vector& dr_order) { // Compute Dynare++ → Dynare ordering std::vector dynppToDyn(nJcols); int j {0}; for (; j < nYss; j++) dynppToDyn[j] = dr_order[j + nStat + nPred] + 2 * nY; // Forward variables for (; j < nYss + nY; j++) dynppToDyn[j] = dr_order[j - nYss] + nY; // Variables in current period for (; j < nYss + nY + nYs; j++) dynppToDyn[j] = dr_order[j - (nY + nYss) + nStat]; // Predetermined variables for (; j < nJcols; j++) dynppToDyn[j] = j - (nY + nYss + nYs) + 3 * nY; // Exogenous // Compute Dynare → Dynare++ ordering for (int i {0}; i < nJcols; i++) dynToDynpp.emplace(dynppToDyn[i], i); } DynareNameList::DynareNameList(std::vector names_arg) : names(std::move(names_arg)) { } DynareStateNameList::DynareStateNameList(const KordpDynare& dynare, const DynareNameList& dnl, const DynareNameList& denl) { for (int i = 0; i < dynare.nYs; i++) names.emplace_back(dnl.getName(i + dynare.nStat)); for (int i = 0; i < dynare.nExog; i++) names.emplace_back(denl.getName(i)); }