stepan
/
dynare
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Bytecode MEX: split out code for dealing with variable names into a dedicated BasicSymbolTable class

mr#2067
Sébastien Villemot 2022-07-28 16:56:40 +02:00
parent 5df3fde95e
commit 6e1635658f
No known key found for this signature in database
GPG Key ID: 2CECE9350ECEBE4A
13 changed files with 200 additions and 150 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
mex/build/bytecode.am
View File

@ -9,7 +9,8 @@ nodist_bytecode_SOURCES = \
Interpreter.cc \
Mem_Mngr.cc \
SparseMatrix.cc \
Evaluate.cc
Evaluate.cc \
BasicSymbolTable.cc
BUILT_SOURCES = $(nodist_bytecode_SOURCES)
CLEANFILES = $(nodist_bytecode_SOURCES)

106
mex/sources/bytecode/BasicSymbolTable.cc Normal file
View File

@ -0,0 +1,106 @@
/*
* Copyright © 2007-2022 Dynare Team
*
* This file is part of Dynare.
*
* Dynare is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Dynare is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Dynare. If not, see <https://www.gnu.org/licenses/>.
*/
#include "BasicSymbolTable.hh"
#include "dynmex.h"
BasicSymbolTable::BasicSymbolTable()
{
mxArray *M_ = mexGetVariable("global", "M_");
if (!M_)
mexErrMsgTxt("Can't find global variable M_");
auto get_field_names = [&](const char *field_name, SymbolType type)
{
vector<string> r;
if (mxGetFieldNumber(M_, field_name) != -1)
{
auto M_field = mxGetFieldByNumber(M_, 0, mxGetFieldNumber(M_, field_name));
if (!mxIsCell(M_field))
mexErrMsgTxt(("M_."s + field_name + " is not a cell array").c_str());
for (size_t i {0}; i < mxGetNumberOfElements(M_field); i++)
{
const mxArray *cell_mx = mxGetCell(M_field, i);
if (!(cell_mx && mxIsChar(cell_mx)))
mexErrMsgTxt(("M_."s + field_name + " contains a cell which is not a character array").c_str());
r.emplace_back(mxArrayToString(cell_mx));
}
}
// Fill the reverse map
for (size_t i {0}; i < r.size(); i++)
name_to_id_and_type.emplace(r[i], pair{type, i});
return r;
};
endo_names = get_field_names("endo_names", SymbolType::endogenous);
param_names = get_field_names("param_names", SymbolType::parameter);
exo_names = get_field_names("exo_names", SymbolType::exogenous);
exo_det_names = get_field_names("exo_det_names", SymbolType::exogenousDet);
}
string
BasicSymbolTable::getName(SymbolType type, int tsid) const
{
try
{
switch (type)
{
case SymbolType::endogenous:
return endo_names.at(tsid);
case SymbolType::exogenous:
return exo_names.at(tsid);
case SymbolType::exogenousDet:
return exo_det_names.at(tsid);
case SymbolType::parameter:
return param_names.at(tsid);
default:
mexErrMsgTxt(("Unsupported symbol type: " + to_string(static_cast<int>(type)) + "\n").c_str());
}
}
catch (out_of_range &)
{
mexErrMsgTxt(("Unknown symbol with ID " + to_string(tsid) + " and type " + to_string(static_cast<int>(type)) + "\n").c_str());
}
exit(EXIT_FAILURE); // Silence GCC warning
}
pair<SymbolType, int>
BasicSymbolTable::getIDAndType(const string &name) const
{
try
{
return name_to_id_and_type.at(name);
}
catch (out_of_range &)
{
mexErrMsgTxt(("Unknown symbol: " + name + "\n").c_str());
}
exit(EXIT_FAILURE); // Silence GCC warning
}
size_t
BasicSymbolTable::maxEndoNameLength() const
{
size_t r {0};
for (const auto &n : endo_names)
r = max(r, n.size());
return r;
}

44
mex/sources/bytecode/BasicSymbolTable.hh Normal file
View File

@ -0,0 +1,44 @@
/*
* Copyright © 2007-2022 Dynare Team
*
* This file is part of Dynare.
*
* Dynare is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Dynare is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Dynare. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef _BASIC_SYMBOL_TABLE_HH
#define _BASIC_SYMBOL_TABLE_HH
#include <string>
#include <vector>
#include <map>
#include <utility>
#include "Bytecode.hh"
using namespace std;
class BasicSymbolTable
{
public:
BasicSymbolTable();
string getName(SymbolType type, int tsid) const;
pair<SymbolType, int> getIDAndType(const string &name) const;
size_t maxEndoNameLength() const;
private:
vector<string> endo_names, param_names, exo_names, exo_det_names;
map<string, pair<SymbolType, int>> name_to_id_and_type;
};
#endif // _BASIC_SYMBOL_TABLE_HH

129
mex/sources/bytecode/ErrorHandling.hh
View File

@ -38,6 +38,8 @@
#define BYTECODE_MEX
#include "Bytecode.hh"
#include "BasicSymbolTable.hh"
using namespace std;
constexpr int NO_ERROR_ON_EXIT = 0, ERROR_ON_EXIT = 1;
@ -166,48 +168,12 @@ extern "C" bool utIsInterruptPending();
class ErrorMsg
{
protected:
ErrorMsg(BasicSymbolTable &symbol_table_arg) : symbol_table {symbol_table_arg}
{
}
BasicSymbolTable &symbol_table;
ExpressionType EQN_type;
int EQN_equation, EQN_block, EQN_block_number, EQN_dvar1;
size_t endo_name_length; // Maximum length of endogenous names
vector<string> P_endo_names;
private:
bool is_load_variable_list;
vector<string> P_exo_names, P_param_names;
vector<tuple<string, SymbolType, unsigned int>> Variable_list;
public:
ErrorMsg() : is_load_variable_list {false}
{
mxArray *M_ = mexGetVariable("global", "M_");
if (!M_)
mexErrMsgTxt("Can't find global variable M_");
auto get_field_names = [&](const char *symbol_type)
{
vector<string> r;
if (mxGetFieldNumber(M_, symbol_type) != -1)
{
auto M_field = mxGetFieldByNumber(M_, 0, mxGetFieldNumber(M_, symbol_type));
if (!mxIsCell(M_field))
mexErrMsgTxt(("M_."s + symbol_type + " is not a cell array").c_str());
for (size_t i = 0; i < mxGetNumberOfElements(M_field); i++)
{
const mxArray *cell_mx = mxGetCell(M_field, i);
if (!(cell_mx && mxIsChar(cell_mx)))
mexErrMsgTxt(("M_."s + symbol_type + " contains a cell which is not a character array").c_str());
r.emplace_back(mxArrayToString(cell_mx));
}
}
return r;
};
P_endo_names = get_field_names("endo_names");
P_exo_names = get_field_names("exo_names");
P_param_names = get_field_names("param_names");
endo_name_length = 0;
for (const auto &n : P_endo_names)
endo_name_length = max(endo_name_length, n.size());
}
private:
/* Given a string which possibly contains a floating-point exception
@ -241,72 +207,7 @@ private:
return line1 + "\n" + line2;
}
void
load_variable_list()
{
if (exchange(is_load_variable_list, true))
return;
for (size_t variable_num {0}; variable_num < P_endo_names.size(); variable_num++)
Variable_list.emplace_back(P_endo_names[variable_num], SymbolType::endogenous, variable_num);
for (size_t variable_num {0}; variable_num < P_exo_names.size(); variable_num++)
Variable_list.emplace_back(P_exo_names[variable_num], SymbolType::exogenous, variable_num);
}
public:
int
get_ID(const string &variable_name, SymbolType *variable_type)
{
load_variable_list();
size_t n = Variable_list.size();
int i = 0;
bool notfound = true;
while (notfound && i < static_cast<int>(n))
{
if (variable_name == get<0>(Variable_list[i]))
{
notfound = false;
*variable_type = get<1>(Variable_list[i]);
return get<2>(Variable_list[i]);
}
i++;
}
return -1;
}
protected:
string
get_variable(SymbolType variable_type, unsigned int variable_num) const
{
switch (variable_type)
{
case SymbolType::endogenous:
if (variable_num < P_endo_names.size())
return P_endo_names[variable_num];
else
mexPrintf("=> Unknown endogenous variable # %d", variable_num);
break;
case SymbolType::exogenous:
if (variable_num < P_exo_names.size())
return P_exo_names[variable_num];
else
mexPrintf("=> Unknown exogenous variable # %d", variable_num);
break;
case SymbolType::exogenousDet:
mexErrMsgTxt("get_variable: exogenous deterministic not supported");
break;
case SymbolType::parameter:
if (variable_num < P_param_names.size())
return P_param_names[variable_num];
else
mexPrintf("=> Unknown parameter # %d", variable_num);
break;
default:
break;
}
cerr << "ErrorHandling::get_variable: Internal error";
exit(EXIT_FAILURE); // Silence GCC warning
}
string
error_location(it_code_type expr_begin, it_code_type faulty_op, bool steady_state, int it_)
{
@ -335,16 +236,16 @@ protected:
case ExpressionType::ModelEquation:
break;
case ExpressionType::FirstEndoDerivative:
Error_loc << " with respect to endogenous variable " << get_variable(SymbolType::endogenous, EQN_dvar1);
Error_loc << " with respect to endogenous variable " << symbol_table.getName(SymbolType::endogenous, EQN_dvar1);
break;
case ExpressionType::FirstOtherEndoDerivative:
Error_loc << " with respect to other endogenous variable " << get_variable(SymbolType::endogenous, EQN_dvar1);
Error_loc << " with respect to other endogenous variable " << symbol_table.getName(SymbolType::endogenous, EQN_dvar1);
break;
case ExpressionType::FirstExoDerivative:
Error_loc << " with respect to exogenous variable " << get_variable(SymbolType::exogenous, EQN_dvar1);
Error_loc << " with respect to exogenous variable " << symbol_table.getName(SymbolType::exogenous, EQN_dvar1);
break;
case ExpressionType::FirstExodetDerivative:
Error_loc << " with respect to deterministic exogenous variable " << get_variable(SymbolType::exogenousDet, EQN_dvar1);
Error_loc << " with respect to deterministic exogenous variable " << symbol_table.getName(SymbolType::exogenousDet, EQN_dvar1);
break;
}
if (!steady_state)
@ -447,7 +348,7 @@ protected:
case SymbolType::endogenous:
case SymbolType::exogenous:
case SymbolType::exogenousDet:
Stack.emplace(get_variable(type, var) + lag_to_string(lag), 100, nullopt);
Stack.emplace(symbol_table.getName(type, var) + lag_to_string(lag), 100, nullopt);
break;
default:
throw FatalExceptionHandling{"FLDV: Unknown variable type\n"};
@ -464,7 +365,7 @@ protected:
case SymbolType::endogenous:
case SymbolType::exogenous:
case SymbolType::exogenousDet:
Stack.emplace(get_variable(type, var), 100, nullopt);
Stack.emplace(symbol_table.getName(type, var), 100, nullopt);
break;
default:
throw FatalExceptionHandling{"FLDSV: Unknown variable type\n"};
@ -481,7 +382,7 @@ protected:
case SymbolType::endogenous:
case SymbolType::exogenous:
case SymbolType::exogenousDet:
Stack.emplace(get_variable(type, var), 100, nullopt);
Stack.emplace(symbol_table.getName(type, var), 100, nullopt);
break;
default:
throw FatalExceptionHandling{"FLDVS: Unknown variable type\n"};
@ -520,7 +421,7 @@ protected:
case SymbolType::endogenous:
case SymbolType::exogenous:
case SymbolType::exogenousDet:
assign_lhs(get_variable(type, var) + lag_to_string(lag));
assign_lhs(symbol_table.getName(type, var) + lag_to_string(lag));
break;
default:
throw FatalExceptionHandling{"FSTPV: Unknown variable type\n"};
@ -537,7 +438,7 @@ protected:
case SymbolType::endogenous:
case SymbolType::exogenous:
case SymbolType::exogenousDet:
assign_lhs(get_variable(type, var));
assign_lhs(symbol_table.getName(type, var));
break;
default:
throw FatalExceptionHandling{"FSTPSV: Unknown variable type\n"};

3
mex/sources/bytecode/Evaluate.cc
View File

@ -28,7 +28,8 @@
extern "C" bool utIsInterruptPending();
#endif
Evaluate::Evaluate(int y_size_arg, int y_kmin_arg, int y_kmax_arg, bool print_it_arg, bool steady_state_arg, int periods_arg, int minimal_solving_periods_arg) :
Evaluate::Evaluate(int y_size_arg, int y_kmin_arg, int y_kmax_arg, bool print_it_arg, bool steady_state_arg, int periods_arg, int minimal_solving_periods_arg, BasicSymbolTable &symbol_table_arg) :
ErrorMsg {symbol_table_arg},
print_it(print_it_arg), minimal_solving_periods(minimal_solving_periods_arg)
{
symbol_table_endo_nbr = 0;

2
mex/sources/bytecode/Evaluate.hh
View File

@ -86,7 +86,7 @@ protected:
bool Gaussian_Elimination, is_linear;
public:
bool steady_state;
Evaluate(int y_size_arg, int y_kmin_arg, int y_kmax_arg, bool print_it_arg, bool steady_state_arg, int periods_arg, int minimal_solving_periods_arg);
Evaluate(int y_size_arg, int y_kmin_arg, int y_kmax_arg, bool print_it_arg, bool steady_state_arg, int periods_arg, int minimal_solving_periods_arg, BasicSymbolTable &symbol_table_arg);
void set_block(int size_arg, BlockSimulationType type_arg, string file_name_arg, string bin_base_name_arg, int block_num_arg,
bool is_linear_arg, int symbol_table_endo_nbr_arg, int Block_List_Max_Lag_arg, int Block_List_Max_Lead_arg, int u_count_int_arg, int block_arg);
void evaluate_complete(bool no_derivatives);

18
mex/sources/bytecode/Interpreter.cc
View File

@ -31,8 +31,8 @@ Interpreter::Interpreter(double *params_arg, double *y_arg, double *ya_arg, doub
int maxit_arg_, double solve_tolf_arg, size_t size_of_direction_arg, int y_decal_arg, double markowitz_c_arg,
string &filename_arg, int minimal_solving_periods_arg, int stack_solve_algo_arg, int solve_algo_arg,
bool global_temporary_terms_arg, bool print_arg, bool print_error_arg, mxArray *GlobalTemporaryTerms_arg,
bool steady_state_arg, bool print_it_arg, int col_x_arg, int col_y_arg)
: dynSparseMatrix(y_size_arg, y_kmin_arg, y_kmax_arg, print_it_arg, steady_state_arg, periods_arg, minimal_solving_periods_arg)
bool steady_state_arg, bool print_it_arg, int col_x_arg, int col_y_arg, BasicSymbolTable &symbol_table_arg)
: dynSparseMatrix {y_size_arg, y_kmin_arg, y_kmax_arg, print_it_arg, steady_state_arg, periods_arg, minimal_solving_periods_arg, symbol_table_arg}
{
params = params_arg;
y = y_arg;
@ -456,7 +456,7 @@ Interpreter::simulate_a_block(const vector_table_conditional_local_type &vector_
copy_n(y_save, y_size*(periods+y_kmax+y_kmin), y);
u_count = u_count_saved;
int prev_iter = iter;
Simulate_Newton_Two_Boundaries(block_num, symbol_table_endo_nbr, y_kmin, y_kmax, size, periods, cvg, minimal_solving_periods, stack_solve_algo, P_endo_names, vector_table_conditional_local);
Simulate_Newton_Two_Boundaries(block_num, symbol_table_endo_nbr, y_kmin, y_kmax, size, periods, cvg, minimal_solving_periods, stack_solve_algo, vector_table_conditional_local);
iter++;
if (iter > prev_iter)
{
@ -481,7 +481,7 @@ Interpreter::simulate_a_block(const vector_table_conditional_local_type &vector_
end_code = it_code;
cvg = false;
Simulate_Newton_Two_Boundaries(block_num, symbol_table_endo_nbr, y_kmin, y_kmax, size, periods, cvg, minimal_solving_periods, stack_solve_algo, P_endo_names, vector_table_conditional_local);
Simulate_Newton_Two_Boundaries(block_num, symbol_table_endo_nbr, y_kmin, y_kmax, size, periods, cvg, minimal_solving_periods, stack_solve_algo, vector_table_conditional_local);
max_res = 0; max_res_idx = 0;
}
slowc = 1; // slowc is modified when stack_solve_algo=4, so restore it
@ -579,8 +579,8 @@ Interpreter::check_for_controlled_exo_validity(FBEGINBLOCK_ *fb, const vector<s_
if (find(endogenous.begin(), endogenous.end(), it.exo_num) != endogenous.end()
&& find(exogenous.begin(), exogenous.end(), it.var_num) == exogenous.end())
throw FatalExceptionHandling("\n the conditional forecast involving as constrained variable "
+ get_variable(SymbolType::endogenous, it.exo_num)
+ " and as endogenized exogenous " + get_variable(SymbolType::exogenous, it.var_num)
+ symbol_table.getName(SymbolType::endogenous, it.exo_num)
+ " and as endogenized exogenous " + symbol_table.getName(SymbolType::exogenous, it.var_num)
+ " that do not appear in block=" + to_string(Block_Count+1)
+ ")\n You should not use block in model options\n");
else if (find(endogenous.begin(), endogenous.end(), it.exo_num) != endogenous.end()
@ -593,7 +593,7 @@ Interpreter::check_for_controlled_exo_validity(FBEGINBLOCK_ *fb, const vector<s_
!= previous_block_exogenous.end())
throw FatalExceptionHandling("\n the conditional forecast involves in the block "
+ to_string(Block_Count+1) + " the endogenized exogenous "
+ get_variable(SymbolType::exogenous, it.var_num)
+ symbol_table.getName(SymbolType::exogenous, it.var_num)
+ " that appear also in a previous block\n You should not use block in model options\n");
}
for (auto it : exogenous)
@ -830,7 +830,7 @@ Interpreter::extended_path(const string &file_name, const string &bin_basename,
vector_table_conditional_local_type vector_table_conditional_local;
vector_table_conditional_local.clear();
int endo_name_length_l = endo_name_length;
int endo_name_length_l = static_cast<int>(symbol_table.maxEndoNameLength());
for (int j = 0; j < col_x* nb_row_x; j++)
{
x_save[j] = x[j];
@ -898,7 +898,7 @@ Interpreter::extended_path(const string &file_name, const string &bin_basename,
{
ostringstream res1;
res1 << std::scientific << max_res;
mexPrintf("%s|%s| %4d | x |\n", elastic(P_endo_names[max_res_idx], endo_name_length_l+2, true).c_str(), elastic(res1.str(), real_max_length+2, false).c_str(), iter);
mexPrintf("%s|%s| %4d | x |\n", elastic(symbol_table.getName(SymbolType::endogenous, max_res_idx), endo_name_length_l+2, true).c_str(), elastic(res1.str(), real_max_length+2, false).c_str(), iter);
mexPrintf(line.c_str());
mexEvalString("drawnow;");
}

2
mex/sources/bytecode/Interpreter.hh
View File

@ -49,7 +49,7 @@ public:
int maxit_arg_, double solve_tolf_arg, size_t size_of_direction_arg, int y_decal_arg, double markowitz_c_arg,
string &filename_arg, int minimal_solving_periods_arg, int stack_solve_algo_arg, int solve_algo_arg,
bool global_temporary_terms_arg, bool print_arg, bool print_error_arg, mxArray *GlobalTemporaryTerms_arg,
bool steady_state_arg, bool print_it_arg, int col_x_arg, int col_y_arg);
bool steady_state_arg, bool print_it_arg, int col_x_arg, int col_y_arg, BasicSymbolTable &symbol_table_arg);
bool extended_path(const string &file_name, const string &bin_basename, bool evaluate, int block, int &nb_blocks, int nb_periods, const vector<s_plan> &sextended_path, const vector<s_plan> &sconstrained_extended_path, const vector<string> &dates, const table_conditional_global_type &table_conditional_global);
bool compute_blocks(const string &file_name, const string &bin_basename, bool evaluate, int block, int &nb_blocks);
void check_for_controlled_exo_validity(FBEGINBLOCK_ *fb, const vector<s_plan> &sconstrained_extended_path);

6
mex/sources/bytecode/Mem_Mngr.cc
View File

@ -71,19 +71,19 @@ Mem_Mngr::mxMalloc_NZE()
CHUNK_SIZE += CHUNK_BLCK_SIZE;
Nb_CHUNK++;
NZE_Mem = static_cast<NonZeroElem *>(mxMalloc(CHUNK_BLCK_SIZE*sizeof(NonZeroElem))); /*The block of memory allocated*/
error_msg.test_mxMalloc(NZE_Mem, __LINE__, __FILE__, __func__, CHUNK_BLCK_SIZE*sizeof(NonZeroElem));
ErrorMsg::test_mxMalloc(NZE_Mem, __LINE__, __FILE__, __func__, CHUNK_BLCK_SIZE*sizeof(NonZeroElem));
NZE_Mem_Allocated.push_back(NZE_Mem);
if (!NZE_Mem)
mexPrintf("Not enough memory available\n");
if (NZE_Mem_add)
{
NZE_Mem_add = static_cast<NonZeroElem **>(mxRealloc(NZE_Mem_add, CHUNK_SIZE*sizeof(NonZeroElem *))); /*We have to redefine the size of pointer on the memory*/
error_msg.test_mxMalloc(NZE_Mem_add, __LINE__, __FILE__, __func__, CHUNK_SIZE*sizeof(NonZeroElem *));
ErrorMsg::test_mxMalloc(NZE_Mem_add, __LINE__, __FILE__, __func__, CHUNK_SIZE*sizeof(NonZeroElem *));
}
else
{
NZE_Mem_add = static_cast<NonZeroElem **>(mxMalloc(CHUNK_SIZE*sizeof(NonZeroElem *))); /*We have to define the size of pointer on the memory*/
error_msg.test_mxMalloc(NZE_Mem_add, __LINE__, __FILE__, __func__, CHUNK_SIZE*sizeof(NonZeroElem *));
ErrorMsg::test_mxMalloc(NZE_Mem_add, __LINE__, __FILE__, __func__, CHUNK_SIZE*sizeof(NonZeroElem *));
}
if (!NZE_Mem_add)

1
mex/sources/bytecode/Mem_Mngr.hh
View File

@ -48,7 +48,6 @@ public:
Mem_Mngr();
void fixe_file_name(string filename_arg);
bool swp_f;
ErrorMsg error_msg;
private:
v_NonZeroElem Chunk_Stack;
unsigned int CHUNK_SIZE, CHUNK_BLCK_SIZE, Nb_CHUNK;

10
mex/sources/bytecode/SparseMatrix.cc
View File

@ -23,8 +23,8 @@
#include "SparseMatrix.hh"
dynSparseMatrix::dynSparseMatrix(int y_size_arg, int y_kmin_arg, int y_kmax_arg, bool print_it_arg, bool steady_state_arg, int periods_arg,
int minimal_solving_periods_arg) :
Evaluate(y_size_arg, y_kmin_arg, y_kmax_arg, print_it_arg, steady_state_arg, periods_arg, minimal_solving_periods_arg)
int minimal_solving_periods_arg, BasicSymbolTable &symbol_table_arg) :
Evaluate {y_size_arg, y_kmin_arg, y_kmax_arg, print_it_arg, steady_state_arg, periods_arg, minimal_solving_periods_arg, symbol_table_arg}
{
pivotva = nullptr;
g_save_op = nullptr;
@ -3917,7 +3917,7 @@ dynSparseMatrix::preconditioner_print_out(string s, int preconditioner, bool ss)
}
void
dynSparseMatrix::Simulate_Newton_Two_Boundaries(int blck, int y_size, int y_kmin, int y_kmax,int Size, int periods, bool cvg, int minimal_solving_periods, int stack_solve_algo, const vector<string> &P_endo_names, const vector_table_conditional_local_type &vector_table_conditional_local)
dynSparseMatrix::Simulate_Newton_Two_Boundaries(int blck, int y_size, int y_kmin, int y_kmax,int Size, int periods, bool cvg, int minimal_solving_periods, int stack_solve_algo, const vector_table_conditional_local_type &vector_table_conditional_local)
{
double top = 0.5;
double bottom = 0.1;
@ -3955,9 +3955,9 @@ dynSparseMatrix::Simulate_Newton_Two_Boundaries(int blck, int y_size, int y_kmin
break;
}
if (select)
mexPrintf("-> variable %s (%d) at time %d = %f direction = %f\n", P_endo_names[j].c_str(), j+1, it_, y[j+it_*y_size], direction[j+it_*y_size]);
mexPrintf("-> variable %s (%d) at time %d = %f direction = %f\n", symbol_table.getName(SymbolType::endogenous, j).c_str(), j+1, it_, y[j+it_*y_size], direction[j+it_*y_size]);
else
mexPrintf(" variable %s (%d) at time %d = %f direction = %f\n", P_endo_names[j].c_str(), j+1, it_, y[j+it_*y_size], direction[j+it_*y_size]);
mexPrintf(" variable %s (%d) at time %d = %f direction = %f\n", symbol_table.getName(SymbolType::endogenous, j).c_str(), j+1, it_, y[j+it_*y_size], direction[j+it_*y_size]);
}
if (iter == 0)
throw FatalExceptionHandling(" in Simulate_Newton_Two_Boundaries, the initial values of endogenous variables are too far from the solution.\nChange them!\n");

4
mex/sources/bytecode/SparseMatrix.hh
View File

@ -51,8 +51,8 @@ constexpr double mem_increasing_factor = 1.1;
class dynSparseMatrix : public Evaluate
{
public:
dynSparseMatrix(int y_size_arg, int y_kmin_arg, int y_kmax_arg, bool print_it_arg, bool steady_state_arg, int periods_arg, int minimal_solving_periods_arg);
void Simulate_Newton_Two_Boundaries(int blck, int y_size, int y_kmin, int y_kmax, int Size, int periods, bool cvg, int minimal_solving_periods, int stack_solve_algo, const vector<string> &P_endo_names, const vector_table_conditional_local_type &vector_table_conditional_local);
dynSparseMatrix(int y_size_arg, int y_kmin_arg, int y_kmax_arg, bool print_it_arg, bool steady_state_arg, int periods_arg, int minimal_solving_periods_arg, BasicSymbolTable &symbol_table_arg);
void Simulate_Newton_Two_Boundaries(int blck, int y_size, int y_kmin, int y_kmax, int Size, int periods, bool cvg, int minimal_solving_periods, int stack_solve_algo, const vector_table_conditional_local_type &vector_table_conditional_local);
void Simulate_Newton_One_Boundary(bool forward);
void fixe_u(double **u, int u_count_int, int max_lag_plus_max_lead_plus_1);
void Read_SparseMatrix(const string &file_name, int Size, int periods, int y_kmin, int y_kmax, bool two_boundaries, int stack_solve_algo, int solve_algo);

22
mex/sources/bytecode/bytecode.cc
View File

@ -257,7 +257,7 @@ mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
params = mxGetPr(mxGetFieldByNumber(M_, 0, field));
}
ErrorMsg emsg;
BasicSymbolTable symbol_table;
vector<string> dates;
if (extended_path)
@ -416,8 +416,7 @@ mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
char name[100];
mxGetString(tmp, name, 100);
splan[i].var = name;
SymbolType variable_type = SymbolType::endogenous;
int exo_num = emsg.get_ID(name, &variable_type);
auto [variable_type, exo_num] = symbol_table.getIDAndType(name);
if (variable_type == SymbolType::exogenous)
splan[i].var_num = exo_num;
else
@ -429,8 +428,7 @@ mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
char name[100];
mxGetString(tmp, name, 100);
splan[i].exo = name;
SymbolType variable_type;
int exo_num = emsg.get_ID(name, &variable_type);
auto [variable_type, exo_num] = symbol_table.getIDAndType(name);
if (variable_type == SymbolType::endogenous)
splan[i].exo_num = exo_num;
else
@ -478,8 +476,7 @@ mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
char name[100];
mxGetString(tmp, name, 100);
spfplan[i].var = name;
SymbolType variable_type = SymbolType::endogenous;
int exo_num = emsg.get_ID(name, &variable_type);
auto [variable_type, exo_num] = symbol_table.getIDAndType(name);
if (variable_type == SymbolType::exogenous)
splan[i].var_num = exo_num;
else
@ -491,8 +488,7 @@ mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
char name[100];
mxGetString(tmp, name, 100);
spfplan[i].exo = name;
SymbolType variable_type;
int exo_num = emsg.get_ID(name, &variable_type);
auto [variable_type, exo_num] = symbol_table.getIDAndType(name);
if (variable_type == SymbolType::endogenous)
spfplan[i].exo_num = exo_num;
else
@ -715,9 +711,11 @@ mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
size_t nb_row_x = row_x;
clock_t t0 = clock();
Interpreter interprete(params, y, ya, x, steady_yd, steady_xd, direction, y_size, nb_row_x, periods, y_kmin, y_kmax, maxit_, solve_tolf, size_of_direction, y_decal,
markowitz_c, file_name, minimal_solving_periods, stack_solve_algo, solve_algo, global_temporary_terms, print, print_error, GlobalTemporaryTerms, steady_state,
print_it, col_x, col_y);
Interpreter interprete {params, y, ya, x, steady_yd, steady_xd, direction, y_size, nb_row_x,
periods, y_kmin, y_kmax, maxit_, solve_tolf, size_of_direction, y_decal,
markowitz_c, file_name, minimal_solving_periods, stack_solve_algo,
solve_algo, global_temporary_terms, print, print_error, GlobalTemporaryTerms,
steady_state, print_it, col_x, col_y, symbol_table};
string f(fname);
mxFree(fname);
int nb_blocks = 0;