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

Preprocessor: uniformize typedef names (with a "_t" suffix)

issue#70
Sébastien Villemot 2010-09-16 19:00:48 +02:00
parent c3c8fa5cca
commit c8fdd5d9d1
26 changed files with 752 additions and 752 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
CodeInterpreter.hh
View File

@ -999,7 +999,7 @@ public:
};
#ifdef BYTE_CODE
typedef vector<pair<Tags, void * > > tags_liste_type;
typedef vector<pair<Tags, void * > > tags_liste_t;
class CodeLoad
{
private:
@ -1017,10 +1017,10 @@ public:
{
return code;
};
inline tags_liste_type
inline tags_liste_t
get_op_code(string file_name)
{
tags_liste_type tags_liste;
tags_liste_t tags_liste;
ifstream CompiledCode;
streamoff Code_Size;
CompiledCode.open((file_name + ".cod").c_str(), std::ios::in | std::ios::binary| std::ios::ate);

58
ComputingTasks.cc
View File

@ -112,7 +112,7 @@ StochSimulStatement::checkPass(ModFileStructure &mod_file_struct)
mod_file_struct.stoch_simul_present = true;
// Fill in option_order of mod_file_struct
OptionsList::num_options_type::const_iterator it = options_list.num_options.find("order");
OptionsList::num_options_t::const_iterator it = options_list.num_options.find("order");
if (it != options_list.num_options.end())
mod_file_struct.order_option = max(mod_file_struct.order_option, atoi(it->second.c_str()));
@ -175,7 +175,7 @@ RamseyPolicyStatement::checkPass(ModFileStructure &mod_file_struct)
/* Fill in option_order of mod_file_struct
Since ramsey policy needs one further order of derivation (for example, for 1st order
approximation, it needs 2nd derivatives), we add 1 to the order declared by user */
OptionsList::num_options_type::const_iterator it = options_list.num_options.find("order");
OptionsList::num_options_t::const_iterator it = options_list.num_options.find("order");
if (it != options_list.num_options.end())
{
int order = atoi(it->second.c_str());
@ -222,7 +222,7 @@ EstimationStatement::checkPass(ModFileStructure &mod_file_struct)
mod_file_struct.estimation_present = true;
// Fill in option_order of mod_file_struct
OptionsList::num_options_type::const_iterator it = options_list.num_options.find("order");
OptionsList::num_options_t::const_iterator it = options_list.num_options.find("order");
if (it != options_list.num_options.end())
mod_file_struct.order_option = max(mod_file_struct.order_option, atoi(it->second.c_str()));
@ -237,7 +237,7 @@ EstimationStatement::checkPass(ModFileStructure &mod_file_struct)
mod_file_struct.dsge_var_calibrated = it->second;
// Fill in mod_file_struct.dsge_var_estimated
OptionsList::string_options_type::const_iterator it_str = options_list.string_options.find("dsge_var");
OptionsList::string_options_t::const_iterator it_str = options_list.string_options.find("dsge_var");
if (it_str != options_list.string_options.end())
mod_file_struct.dsge_var_estimated = true;
@ -280,7 +280,7 @@ DynareSensitivityStatement::DynareSensitivityStatement(const OptionsList &option
void
DynareSensitivityStatement::checkPass(ModFileStructure &mod_file_struct)
{
OptionsList::num_options_type::const_iterator it = options_list.num_options.find("identification");
OptionsList::num_options_t::const_iterator it = options_list.num_options.find("identification");
if (it != options_list.num_options.end()
&& it->second == "1")
mod_file_struct.identification_present = true;
@ -366,8 +366,8 @@ EstimatedParamsStatement::checkPass(ModFileStructure &mod_file_struct)
if (it->prior == "1") //BETA_PDF is associated with "1" in DynareBison.yy
try
{
if (it->mean->eval(eval_context_type()) == 0.5 &&
it->std->eval(eval_context_type()) == 0.5)
if (it->mean->eval(eval_context_t()) == 0.5 &&
it->std->eval(eval_context_t()) == 0.5)
{
cerr << "ERROR: The prior density is not defined for the beta distribution when the mean = standard deviation = 0.5." << endl;
exit(EXIT_FAILURE);
@ -586,7 +586,7 @@ EstimatedParamsBoundsStatement::writeOutput(ostream &output, const string &basen
}
}
ObservationTrendsStatement::ObservationTrendsStatement(const trend_elements_type &trend_elements_arg,
ObservationTrendsStatement::ObservationTrendsStatement(const trend_elements_t &trend_elements_arg,
const SymbolTable &symbol_table_arg) :
trend_elements(trend_elements_arg),
symbol_table(symbol_table_arg)
@ -598,7 +598,7 @@ ObservationTrendsStatement::writeOutput(ostream &output, const string &basename)
{
output << "options_.trend_coeff_ = {};" << endl;
trend_elements_type::const_iterator it;
trend_elements_t::const_iterator it;
for (it = trend_elements.begin(); it != trend_elements.end(); it++)
{
@ -615,9 +615,9 @@ ObservationTrendsStatement::writeOutput(ostream &output, const string &basename)
}
}
CalibVarStatement::CalibVarStatement(const calib_var_type &calib_var_arg,
const calib_covar_type &calib_covar_arg,
const calib_ac_type &calib_ac_arg,
CalibVarStatement::CalibVarStatement(const calib_var_t &calib_var_arg,
const calib_covar_t &calib_covar_arg,
const calib_ac_t &calib_ac_arg,
const SymbolTable &symbol_table_arg) :
calib_var(calib_var_arg),
calib_covar(calib_covar_arg),
@ -642,7 +642,7 @@ CalibVarStatement::writeOutput(ostream &output, const string &basename) const
}
// Print calibration variances
for (calib_var_type::const_iterator it = calib_var.begin();
for (calib_var_t::const_iterator it = calib_var.begin();
it != calib_var.end(); it++)
{
const string &name = it->first;
@ -669,7 +669,7 @@ CalibVarStatement::writeOutput(ostream &output, const string &basename) const
}
// Print calibration covariances
for (calib_covar_type::const_iterator it = calib_covar.begin();
for (calib_covar_t::const_iterator it = calib_covar.begin();
it != calib_covar.end(); it++)
{
const string &name1 = it->first.first;
@ -700,7 +700,7 @@ CalibVarStatement::writeOutput(ostream &output, const string &basename) const
// Print calibration autocorrelations
int max_iar = 3;
for (calib_ac_type::const_iterator it = calib_ac.begin();
for (calib_ac_t::const_iterator it = calib_ac.begin();
it != calib_ac.end(); it++)
{
const string &name = it->first.first;
@ -764,7 +764,7 @@ OsrStatement::checkPass(ModFileStructure &mod_file_struct)
mod_file_struct.osr_present = true;
// Fill in option_order of mod_file_struct
OptionsList::num_options_type::const_iterator it = options_list.num_options.find("order");
OptionsList::num_options_t::const_iterator it = options_list.num_options.find("order");
if (it != options_list.num_options.end())
mod_file_struct.order_option = max(mod_file_struct.order_option, atoi(it->second.c_str()));
@ -788,8 +788,8 @@ OsrStatement::writeOutput(ostream &output, const string &basename) const
output << "osr(var_list_,osr_params_,obj_var_,optim_weights_);\n";
}
OptimWeightsStatement::OptimWeightsStatement(const var_weights_type &var_weights_arg,
const covar_weights_type &covar_weights_arg,
OptimWeightsStatement::OptimWeightsStatement(const var_weights_t &var_weights_arg,
const covar_weights_t &covar_weights_arg,
const SymbolTable &symbol_table_arg) :
var_weights(var_weights_arg),
covar_weights(covar_weights_arg),
@ -806,7 +806,7 @@ OptimWeightsStatement::writeOutput(ostream &output, const string &basename) cons
<< "optim_weights_ = sparse(M_.endo_nbr,M_.endo_nbr);" << endl
<< "obj_var_ = [];" << endl << endl;
for (var_weights_type::const_iterator it = var_weights.begin();
for (var_weights_t::const_iterator it = var_weights.begin();
it != var_weights.end(); it++)
{
const string &name = it->first;
@ -818,7 +818,7 @@ OptimWeightsStatement::writeOutput(ostream &output, const string &basename) cons
output << "obj_var_ = [obj_var_; " << id << "];\n";
}
for (covar_weights_type::const_iterator it = covar_weights.begin();
for (covar_weights_t::const_iterator it = covar_weights.begin();
it != covar_weights.end(); it++)
{
const string &name1 = it->first.first;
@ -863,7 +863,7 @@ DynaTypeStatement::writeOutput(ostream &output, const string &basename) const
<< "',var_list_);" << endl;
}
ModelComparisonStatement::ModelComparisonStatement(const filename_list_type &filename_list_arg,
ModelComparisonStatement::ModelComparisonStatement(const filename_list_t &filename_list_arg,
const OptionsList &options_list_arg) :
filename_list(filename_list_arg),
options_list(options_list_arg)
@ -878,7 +878,7 @@ ModelComparisonStatement::writeOutput(ostream &output, const string &basename) c
output << "ModelNames_ = {};" << endl;
output << "ModelPriors_ = [];" << endl;
for (filename_list_type::const_iterator it = filename_list.begin();
for (filename_list_t::const_iterator it = filename_list.begin();
it != filename_list.end(); it++)
{
output << "ModelNames_ = { ModelNames_{:} '" << (*it).first << "'};" << endl;
@ -906,7 +906,7 @@ PlannerObjectiveStatement::checkPass(ModFileStructure &mod_file_struct)
void
PlannerObjectiveStatement::computingPass()
{
model_tree->computingPass(eval_context_type(), false, true, false, false);
model_tree->computingPass(eval_context_t(), false, true, false, false);
}
void
@ -1072,7 +1072,7 @@ PlotConditionalForecastStatement::writeOutput(ostream &output, const string &bas
output << "plot_icforecast(var_list_, " << periods << ");" << endl;
}
SvarIdentificationStatement::SvarIdentificationStatement(const svar_identification_exclusion_type &exclusion_arg,
SvarIdentificationStatement::SvarIdentificationStatement(const svar_identification_exclusion_t &exclusion_arg,
const bool &upper_cholesky_present_arg,
const bool &lower_cholesky_present_arg,
const SymbolTable &symbol_table_arg) :
@ -1087,7 +1087,7 @@ int
SvarIdentificationStatement::getMaxLag() const
{
int max_lag = 0;
for (svar_identification_exclusion_type::const_iterator it = exclusion.begin(); it != exclusion.end(); it++)
for (svar_identification_exclusion_t::const_iterator it = exclusion.begin(); it != exclusion.end(); it++)
if (it->first.first > max_lag)
max_lag = it->first.first;
@ -1151,7 +1151,7 @@ SvarIdentificationStatement::writeOutput(ostream &output, const string &basename
output << "options_.ms.Qi = zeros(" << n << ", " << n << ", " << n << ");" << endl;
output << "options_.ms.Ri = zeros(" << k << ", " << k << ", " << n << ");" << endl;
for (svar_identification_exclusion_type::const_iterator it = exclusion.begin(); it != exclusion.end(); it++)
for (svar_identification_exclusion_t::const_iterator it = exclusion.begin(); it != exclusion.end(); it++)
{
for (unsigned int h = 0; h < it->second.size(); h++)
{
@ -1197,7 +1197,7 @@ MarkovSwitchingStatement::MarkovSwitchingStatement(const OptionsList &options_li
void
MarkovSwitchingStatement::writeOutput(ostream &output, const string &basename) const
{
OptionsList::num_options_type::const_iterator itChain, itState, itNOS, itDuration;
OptionsList::num_options_t::const_iterator itChain, itState, itNOS, itDuration;
itChain = options_list.num_options.find("ms.chain");
if (itChain == options_list.num_options.end())
@ -1237,8 +1237,8 @@ SvarStatement::SvarStatement(const OptionsList &options_list_arg) :
void
SvarStatement::writeOutput(ostream &output, const string &basename) const
{
OptionsList::num_options_type::const_iterator it0, it1, it2;
OptionsList::vec_int_options_type::const_iterator itv;
OptionsList::num_options_t::const_iterator it0, it1, it2;
OptionsList::vec_int_options_t::const_iterator itv;
it0 = options_list.num_options.find("ms.chain");
if (it0 != options_list.num_options.end())

48
ComputingTasks.hh
View File

@ -169,12 +169,12 @@ public:
class ObservationTrendsStatement : public Statement
{
public:
typedef map<string, NodeID> trend_elements_type;
typedef map<string, NodeID> trend_elements_t;
private:
const trend_elements_type trend_elements;
const trend_elements_t trend_elements;
const SymbolTable &symbol_table;
public:
ObservationTrendsStatement(const trend_elements_type &trend_elements_arg,
ObservationTrendsStatement(const trend_elements_t &trend_elements_arg,
const SymbolTable &symbol_table_arg);
virtual void writeOutput(ostream &output, const string &basename) const;
};
@ -225,12 +225,12 @@ public:
class ModelComparisonStatement : public Statement
{
public:
typedef vector<pair<string, string> > filename_list_type;
typedef vector<pair<string, string> > filename_list_t;
private:
filename_list_type filename_list;
filename_list_t filename_list;
OptionsList options_list;
public:
ModelComparisonStatement(const filename_list_type &filename_list_arg,
ModelComparisonStatement(const filename_list_t &filename_list_arg,
const OptionsList &options_list_arg);
virtual void writeOutput(ostream &output, const string &basename) const;
};
@ -298,15 +298,15 @@ public:
class OptimWeightsStatement : public Statement
{
public:
typedef map<string, NodeID> var_weights_type;
typedef map<pair<string, string>, NodeID> covar_weights_type;
typedef map<string, NodeID> var_weights_t;
typedef map<pair<string, string>, NodeID> covar_weights_t;
private:
const var_weights_type var_weights;
const covar_weights_type covar_weights;
const var_weights_t var_weights;
const covar_weights_t covar_weights;
const SymbolTable &symbol_table;
public:
OptimWeightsStatement(const var_weights_type &var_weights_arg,
const covar_weights_type &covar_weights_arg,
OptimWeightsStatement(const var_weights_t &var_weights_arg,
const covar_weights_t &covar_weights_arg,
const SymbolTable &symbol_table_arg);
virtual void writeOutput(ostream &output, const string &basename) const;
};
@ -324,20 +324,20 @@ class CalibVarStatement : public Statement
{
public:
//! Maps a variable to a pair (weight, expression)
typedef map<string, pair<string, NodeID> > calib_var_type;
typedef map<string, pair<string, NodeID> > calib_var_t;
//! Maps a pair of variables to a pair (weight, expression)
typedef map<pair<string, string>, pair<string, NodeID> > calib_covar_type;
typedef map<pair<string, string>, pair<string, NodeID> > calib_covar_t;
//! Maps a pair (variable, autocorr) to a pair (weight, expression)
typedef map<pair<string, int>, pair<string, NodeID> > calib_ac_type;
typedef map<pair<string, int>, pair<string, NodeID> > calib_ac_t;
private:
const calib_var_type calib_var;
const calib_covar_type calib_covar;
const calib_ac_type calib_ac;
const calib_var_t calib_var;
const calib_covar_t calib_covar;
const calib_ac_t calib_ac;
const SymbolTable &symbol_table;
public:
CalibVarStatement(const calib_var_type &calib_var_arg,
const calib_covar_type &calib_covar_arg,
const calib_ac_type &calib_ac_arg,
CalibVarStatement(const calib_var_t &calib_var_arg,
const calib_covar_t &calib_covar_arg,
const calib_ac_t &calib_ac_arg,
const SymbolTable &symbol_table_arg);
virtual void writeOutput(ostream &output, const string &basename) const;
};
@ -465,15 +465,15 @@ public:
class SvarIdentificationStatement : public Statement
{
public:
typedef map<pair<int, int>, vector<int> > svar_identification_exclusion_type;
typedef map<pair<int, int>, vector<int> > svar_identification_exclusion_t;
private:
const svar_identification_exclusion_type exclusion;
const svar_identification_exclusion_t exclusion;
const bool upper_cholesky_present;
const bool lower_cholesky_present;
const SymbolTable &symbol_table;
int getMaxLag() const;
public:
SvarIdentificationStatement(const svar_identification_exclusion_type &exclusion_arg,
SvarIdentificationStatement(const svar_identification_exclusion_t &exclusion_arg,
const bool &upper_cholesky_present_arg,
const bool &lower_cholesky_present_arg,
const SymbolTable &symbol_table_arg);

26
DataTree.cc
View File

@ -46,7 +46,7 @@ DataTree::DataTree(SymbolTable &symbol_table_arg,
DataTree::~DataTree()
{
for (node_list_type::iterator it = node_list.begin(); it != node_list.end(); it++)
for (node_list_t::iterator it = node_list.begin(); it != node_list.end(); it++)
delete *it;
}
@ -55,7 +55,7 @@ DataTree::AddNumConstant(const string &value)
{
int id = num_constants.AddConstant(value);
num_const_node_map_type::iterator it = num_const_node_map.find(id);
num_const_node_map_t::iterator it = num_const_node_map.find(id);
if (it != num_const_node_map.end())
return it->second;
else
@ -65,7 +65,7 @@ DataTree::AddNumConstant(const string &value)
VariableNode *
DataTree::AddVariableInternal(int symb_id, int lag)
{
variable_node_map_type::iterator it = variable_node_map.find(make_pair(symb_id, lag));
variable_node_map_t::iterator it = variable_node_map.find(make_pair(symb_id, lag));
if (it != variable_node_map.end())
return it->second;
else
@ -467,7 +467,7 @@ DataTree::AddExternalFunction(int symb_id, const vector<NodeID> &arguments)
{
assert(symbol_table.getType(symb_id) == eExternalFunction);
external_function_node_map_type::iterator it = external_function_node_map.find(make_pair(arguments, symb_id));
external_function_node_map_t::iterator it = external_function_node_map.find(make_pair(arguments, symb_id));
if (it != external_function_node_map.end())
return it->second;
@ -479,7 +479,7 @@ DataTree::AddFirstDerivExternalFunctionNode(int top_level_symb_id, const vector<
{
assert(symbol_table.getType(top_level_symb_id) == eExternalFunction);
first_deriv_external_function_node_map_type::iterator it =
first_deriv_external_function_node_map_t::iterator it =
first_deriv_external_function_node_map.find(make_pair(make_pair(arguments, input_index),
top_level_symb_id));
if (it != first_deriv_external_function_node_map.end())
@ -493,7 +493,7 @@ DataTree::AddSecondDerivExternalFunctionNode(int top_level_symb_id, const vector
{
assert(symbol_table.getType(top_level_symb_id) == eExternalFunction);
second_deriv_external_function_node_map_type::iterator it =
second_deriv_external_function_node_map_t::iterator it =
second_deriv_external_function_node_map.find(make_pair(make_pair(arguments,
make_pair(input_index1, input_index2)),
top_level_symb_id));
@ -506,7 +506,7 @@ DataTree::AddSecondDerivExternalFunctionNode(int top_level_symb_id, const vector
bool
DataTree::isSymbolUsed(int symb_id) const
{
for (variable_node_map_type::const_iterator it = variable_node_map.begin();
for (variable_node_map_t::const_iterator it = variable_node_map.begin();
it != variable_node_map.end(); it++)
if (it->first.first == symb_id)
return true;
@ -532,7 +532,7 @@ DataTree::getDynJacobianCol(int deriv_id) const throw (UnknownDerivIDException)
bool
DataTree::isUnaryOpUsed(UnaryOpcode opcode) const
{
for (unary_op_node_map_type::const_iterator it = unary_op_node_map.begin();
for (unary_op_node_map_t::const_iterator it = unary_op_node_map.begin();
it != unary_op_node_map.end(); it++)
if (it->first.second == opcode)
return true;
@ -543,7 +543,7 @@ DataTree::isUnaryOpUsed(UnaryOpcode opcode) const
bool
DataTree::isBinaryOpUsed(BinaryOpcode opcode) const
{
for (binary_op_node_map_type::const_iterator it = binary_op_node_map.begin();
for (binary_op_node_map_t::const_iterator it = binary_op_node_map.begin();
it != binary_op_node_map.end(); it++)
if (it->first.second == opcode)
return true;
@ -554,7 +554,7 @@ DataTree::isBinaryOpUsed(BinaryOpcode opcode) const
bool
DataTree::isTrinaryOpUsed(TrinaryOpcode opcode) const
{
for (trinary_op_node_map_type::const_iterator it = trinary_op_node_map.begin();
for (trinary_op_node_map_t::const_iterator it = trinary_op_node_map.begin();
it != trinary_op_node_map.end(); it++)
if (it->first.second == opcode)
return true;
@ -565,7 +565,7 @@ DataTree::isTrinaryOpUsed(TrinaryOpcode opcode) const
bool
DataTree::isExternalFunctionUsed(int symb_id) const
{
for (external_function_node_map_type::const_iterator it = external_function_node_map.begin();
for (external_function_node_map_t::const_iterator it = external_function_node_map.begin();
it != external_function_node_map.end(); it++)
if (it->first.second == symb_id)
return true;
@ -576,7 +576,7 @@ DataTree::isExternalFunctionUsed(int symb_id) const
bool
DataTree::isFirstDerivExternalFunctionUsed(int symb_id) const
{
for (first_deriv_external_function_node_map_type::const_iterator it = first_deriv_external_function_node_map.begin();
for (first_deriv_external_function_node_map_t::const_iterator it = first_deriv_external_function_node_map.begin();
it != first_deriv_external_function_node_map.end(); it++)
if (it->first.second == symb_id)
return true;
@ -587,7 +587,7 @@ DataTree::isFirstDerivExternalFunctionUsed(int symb_id) const
bool
DataTree::isSecondDerivExternalFunctionUsed(int symb_id) const
{
for (second_deriv_external_function_node_map_type::const_iterator it = second_deriv_external_function_node_map.begin();
for (second_deriv_external_function_node_map_t::const_iterator it = second_deriv_external_function_node_map.begin();
it != second_deriv_external_function_node_map.end(); it++)
if (it->first.second == symb_id)
return true;

54
DataTree.hh
View File

@ -54,23 +54,23 @@ protected:
//! A reference to the external functions table
ExternalFunctionsTable &external_functions_table;
typedef map<int, NumConstNode *> num_const_node_map_type;
num_const_node_map_type num_const_node_map;
typedef map<int, NumConstNode *> num_const_node_map_t;
num_const_node_map_t num_const_node_map;
//! Pair (symbol_id, lag) used as key
typedef map<pair<int, int>, VariableNode *> variable_node_map_type;
variable_node_map_type variable_node_map;
typedef map<pair<NodeID, UnaryOpcode>, UnaryOpNode *> unary_op_node_map_type;
unary_op_node_map_type unary_op_node_map;
typedef map<pair<pair<NodeID, NodeID>, BinaryOpcode>, BinaryOpNode *> binary_op_node_map_type;
binary_op_node_map_type binary_op_node_map;
typedef map<pair<pair<pair<NodeID, NodeID>, NodeID>, TrinaryOpcode>, TrinaryOpNode *> trinary_op_node_map_type;
trinary_op_node_map_type trinary_op_node_map;
typedef map<pair<vector<NodeID>, int>, ExternalFunctionNode *> external_function_node_map_type;
external_function_node_map_type external_function_node_map;
typedef map<pair<pair<vector<NodeID>, int>, int>, FirstDerivExternalFunctionNode *> first_deriv_external_function_node_map_type;
first_deriv_external_function_node_map_type first_deriv_external_function_node_map;
typedef map<pair<pair<vector<NodeID>, pair<int, int> >, int>, SecondDerivExternalFunctionNode *> second_deriv_external_function_node_map_type;
second_deriv_external_function_node_map_type second_deriv_external_function_node_map;
typedef map<pair<int, int>, VariableNode *> variable_node_map_t;
variable_node_map_t variable_node_map;
typedef map<pair<NodeID, UnaryOpcode>, UnaryOpNode *> unary_op_node_map_t;
unary_op_node_map_t unary_op_node_map;
typedef map<pair<pair<NodeID, NodeID>, BinaryOpcode>, BinaryOpNode *> binary_op_node_map_t;
binary_op_node_map_t binary_op_node_map;
typedef map<pair<pair<pair<NodeID, NodeID>, NodeID>, TrinaryOpcode>, TrinaryOpNode *> trinary_op_node_map_t;
trinary_op_node_map_t trinary_op_node_map;
typedef map<pair<vector<NodeID>, int>, ExternalFunctionNode *> external_function_node_map_t;
external_function_node_map_t external_function_node_map;
typedef map<pair<pair<vector<NodeID>, int>, int>, FirstDerivExternalFunctionNode *> first_deriv_external_function_node_map_t;
first_deriv_external_function_node_map_t first_deriv_external_function_node_map;
typedef map<pair<pair<vector<NodeID>, pair<int, int> >, int>, SecondDerivExternalFunctionNode *> second_deriv_external_function_node_map_t;
second_deriv_external_function_node_map_t second_deriv_external_function_node_map;
//! Stores local variables value (maps symbol ID to corresponding node)
map<int, NodeID> local_variables_table;
@ -79,9 +79,9 @@ protected:
VariableNode *AddVariableInternal(int symb_id, int lag);
private:
typedef list<NodeID> node_list_type;
typedef list<NodeID> node_list_t;
//! The list of nodes
node_list_type node_list;
node_list_t node_list;
//! A counter for filling ExprNode's idx field
int node_counter;
@ -250,7 +250,7 @@ inline NodeID
DataTree::AddUnaryOp(UnaryOpcode op_code, NodeID arg, int arg_exp_info_set, const string &arg_exp_info_set_name)
{
// If the node already exists in tree, share it
unary_op_node_map_type::iterator it = unary_op_node_map.find(make_pair(arg, op_code));
unary_op_node_map_t::iterator it = unary_op_node_map.find(make_pair(arg, op_code));
if (it != unary_op_node_map.end())
return it->second;
@ -261,7 +261,7 @@ DataTree::AddUnaryOp(UnaryOpcode op_code, NodeID arg, int arg_exp_info_set, cons
{
try
{
double argval = arg->eval(eval_context_type());
double argval = arg->eval(eval_context_t());
double val = UnaryOpNode::eval_opcode(op_code, argval);
return AddPossiblyNegativeConstant(val);
}
@ -275,15 +275,15 @@ DataTree::AddUnaryOp(UnaryOpcode op_code, NodeID arg, int arg_exp_info_set, cons
inline NodeID
DataTree::AddBinaryOp(NodeID arg1, BinaryOpcode op_code, NodeID arg2)
{
binary_op_node_map_type::iterator it = binary_op_node_map.find(make_pair(make_pair(arg1, arg2), op_code));
binary_op_node_map_t::iterator it = binary_op_node_map.find(make_pair(make_pair(arg1, arg2), op_code));
if (it != binary_op_node_map.end())
return it->second;
// Try to reduce to a constant
try
{
double argval1 = arg1->eval(eval_context_type());
double argval2 = arg2->eval(eval_context_type());
double argval1 = arg1->eval(eval_context_t());
double argval2 = arg2->eval(eval_context_t());
double val = BinaryOpNode::eval_opcode(argval1, op_code, argval2);
return AddPossiblyNegativeConstant(val);
}
@ -296,16 +296,16 @@ DataTree::AddBinaryOp(NodeID arg1, BinaryOpcode op_code, NodeID arg2)
inline NodeID
DataTree::AddTrinaryOp(NodeID arg1, TrinaryOpcode op_code, NodeID arg2, NodeID arg3)
{
trinary_op_node_map_type::iterator it = trinary_op_node_map.find(make_pair(make_pair(make_pair(arg1, arg2), arg3), op_code));
trinary_op_node_map_t::iterator it = trinary_op_node_map.find(make_pair(make_pair(make_pair(arg1, arg2), arg3), op_code));
if (it != trinary_op_node_map.end())
return it->second;
// Try to reduce to a constant
try
{
double argval1 = arg1->eval(eval_context_type());
double argval2 = arg2->eval(eval_context_type());
double argval3 = arg3->eval(eval_context_type());
double argval1 = arg1->eval(eval_context_t());
double argval2 = arg2->eval(eval_context_t());
double argval3 = arg3->eval(eval_context_t());
double val = TrinaryOpNode::eval_opcode(argval1, op_code, argval2, argval3);
return AddPossiblyNegativeConstant(val);
}

166
DynamicModel.cc
View File

@ -57,9 +57,9 @@ DynamicModel::AddVariable(int symb_id, int lag)
}
void
DynamicModel::compileDerivative(ofstream &code_file, int eq, int symb_id, int lag, const map_idx_type &map_idx) const
DynamicModel::compileDerivative(ofstream &code_file, int eq, int symb_id, int lag, const map_idx_t &map_idx) const
{
first_derivatives_type::const_iterator it = first_derivatives.find(make_pair(eq, getDerivID(symbol_table.getID(eEndogenous, symb_id), lag)));
first_derivatives_t::const_iterator it = first_derivatives.find(make_pair(eq, getDerivID(symbol_table.getID(eEndogenous, symb_id), lag)));
if (it != first_derivatives.end())
(it->second)->compile(code_file, false, temporary_terms, map_idx, true, false);
else
@ -70,7 +70,7 @@ DynamicModel::compileDerivative(ofstream &code_file, int eq, int symb_id, int la
}
void
DynamicModel::compileChainRuleDerivative(ofstream &code_file, int eqr, int varr, int lag, const map_idx_type &map_idx) const
DynamicModel::compileChainRuleDerivative(ofstream &code_file, int eqr, int varr, int lag, const map_idx_t &map_idx) const
{
map<pair<int, pair<int, int> >, NodeID>::const_iterator it = first_chain_rule_derivatives.find(make_pair(eqr, make_pair(varr, lag)));
if (it != first_chain_rule_derivatives.end())
@ -100,15 +100,15 @@ DynamicModel::computeTemporaryTermsOrdered()
map<NodeID, pair<int, int> > first_occurence;
map<NodeID, int> reference_count;
BinaryOpNode *eq_node;
first_derivatives_type::const_iterator it;
first_chain_rule_derivatives_type::const_iterator it_chr;
first_derivatives_t::const_iterator it;
first_chain_rule_derivatives_t::const_iterator it_chr;
ostringstream tmp_s;
v_temporary_terms.clear();
map_idx.clear();
unsigned int nb_blocks = getNbBlocks();
v_temporary_terms = vector<vector<temporary_terms_type> >(nb_blocks);
v_temporary_terms_inuse = vector<temporary_terms_inuse_type>(nb_blocks);
v_temporary_terms = vector<vector<temporary_terms_t> >(nb_blocks);
v_temporary_terms_inuse = vector<temporary_terms_inuse_t>(nb_blocks);
temporary_terms.clear();
if (!global_temporary_terms)
@ -120,7 +120,7 @@ DynamicModel::computeTemporaryTermsOrdered()
unsigned int block_size = getBlockSize(block);
unsigned int block_nb_mfs = getBlockMfs(block);
unsigned int block_nb_recursives = block_size - block_nb_mfs;
v_temporary_terms[block] = vector<temporary_terms_type>(block_size);
v_temporary_terms[block] = vector<temporary_terms_t>(block_size);
for (unsigned int i = 0; i < block_size; i++)
{
if (i < block_nb_recursives && isBlockEquationRenormalized(block, i))
@ -131,14 +131,14 @@ DynamicModel::computeTemporaryTermsOrdered()
eq_node->computeTemporaryTerms(reference_count, temporary_terms, first_occurence, block, v_temporary_terms, i);
}
}
for (t_block_derivatives_equation_variable_laglead_nodeid::const_iterator it = blocks_derivatives[block].begin(); it != (blocks_derivatives[block]).end(); it++)
for (block_derivatives_equation_variable_laglead_nodeid_t::const_iterator it = blocks_derivatives[block].begin(); it != (blocks_derivatives[block]).end(); it++)
{
NodeID id = it->second.second;
id->computeTemporaryTerms(reference_count, temporary_terms, first_occurence, block, v_temporary_terms, block_size-1);
}
for (t_derivative::const_iterator it = derivative_endo[block].begin(); it != derivative_endo[block].end(); it++)
for (derivative_t::const_iterator it = derivative_endo[block].begin(); it != derivative_endo[block].end(); it++)
it->second->computeTemporaryTerms(reference_count, temporary_terms, first_occurence, block, v_temporary_terms, block_size-1);
for (t_derivative::const_iterator it = derivative_other_endo[block].begin(); it != derivative_other_endo[block].end(); it++)
for (derivative_t::const_iterator it = derivative_other_endo[block].begin(); it != derivative_other_endo[block].end(); it++)
it->second->computeTemporaryTerms(reference_count, temporary_terms, first_occurence, block, v_temporary_terms, block_size-1);
set<int> temporary_terms_in_use;
@ -154,7 +154,7 @@ DynamicModel::computeTemporaryTermsOrdered()
unsigned int block_size = getBlockSize(block);
unsigned int block_nb_mfs = getBlockMfs(block);
unsigned int block_nb_recursives = block_size - block_nb_mfs;
v_temporary_terms[block] = vector<temporary_terms_type>(block_size);
v_temporary_terms[block] = vector<temporary_terms_t>(block_size);
for (unsigned int i = 0; i < block_size; i++)
{
if (i < block_nb_recursives && isBlockEquationRenormalized(block, i))
@ -165,14 +165,14 @@ DynamicModel::computeTemporaryTermsOrdered()
eq_node->computeTemporaryTerms(reference_count, temporary_terms, first_occurence, block, v_temporary_terms, i);
}
}
for (t_block_derivatives_equation_variable_laglead_nodeid::const_iterator it = blocks_derivatives[block].begin(); it != (blocks_derivatives[block]).end(); it++)
for (block_derivatives_equation_variable_laglead_nodeid_t::const_iterator it = blocks_derivatives[block].begin(); it != (blocks_derivatives[block]).end(); it++)
{
NodeID id = it->second.second;
id->computeTemporaryTerms(reference_count, temporary_terms, first_occurence, block, v_temporary_terms, block_size-1);
}
for (t_derivative::const_iterator it = derivative_endo[block].begin(); it != derivative_endo[block].end(); it++)
for (derivative_t::const_iterator it = derivative_endo[block].begin(); it != derivative_endo[block].end(); it++)
it->second->computeTemporaryTerms(reference_count, temporary_terms, first_occurence, block, v_temporary_terms, block_size-1);
for (t_derivative::const_iterator it = derivative_other_endo[block].begin(); it != derivative_other_endo[block].end(); it++)
for (derivative_t::const_iterator it = derivative_other_endo[block].begin(); it != derivative_other_endo[block].end(); it++)
it->second->computeTemporaryTerms(reference_count, temporary_terms, first_occurence, block, v_temporary_terms, block_size-1);
}
for (unsigned int block = 0; block < nb_blocks; block++)
@ -192,14 +192,14 @@ DynamicModel::computeTemporaryTermsOrdered()
eq_node->collectTemporary_terms(temporary_terms, temporary_terms_in_use, block);
}
}
for (t_block_derivatives_equation_variable_laglead_nodeid::const_iterator it = blocks_derivatives[block].begin(); it != (blocks_derivatives[block]).end(); it++)
for (block_derivatives_equation_variable_laglead_nodeid_t::const_iterator it = blocks_derivatives[block].begin(); it != (blocks_derivatives[block]).end(); it++)
{
NodeID id = it->second.second;
id->collectTemporary_terms(temporary_terms, temporary_terms_in_use, block);
}
for (t_derivative::const_iterator it = derivative_endo[block].begin(); it != derivative_endo[block].end(); it++)
for (derivative_t::const_iterator it = derivative_endo[block].begin(); it != derivative_endo[block].end(); it++)
it->second->collectTemporary_terms(temporary_terms, temporary_terms_in_use, block);
for (t_derivative::const_iterator it = derivative_other_endo[block].begin(); it != derivative_other_endo[block].end(); it++)
for (derivative_t::const_iterator it = derivative_other_endo[block].begin(); it != derivative_other_endo[block].end(); it++)
it->second->collectTemporary_terms(temporary_terms, temporary_terms_in_use, block);
v_temporary_terms_inuse[block] = temporary_terms_in_use;
}
@ -212,7 +212,7 @@ DynamicModel::computeTemporaryTermsMapping()
{
// Add a mapping form node ID to temporary terms order
int j = 0;
for (temporary_terms_type::const_iterator it = temporary_terms.begin();
for (temporary_terms_t::const_iterator it = temporary_terms.begin();
it != temporary_terms.end(); it++)
map_idx[(*it)->idx] = j++;
}
@ -227,7 +227,7 @@ DynamicModel::writeModelEquationsOrdered_M(const string &dynamic_basename) const
BinaryOpNode *eq_node;
ostringstream Uf[symbol_table.endo_nbr()];
map<NodeID, int> reference_count;
temporary_terms_type local_temporary_terms;
temporary_terms_t local_temporary_terms;
ofstream output;
int nze, nze_exo, nze_other_endo;
vector<int> feedback_variables;
@ -347,14 +347,14 @@ DynamicModel::writeModelEquationsOrdered_M(const string &dynamic_basename) const
if (v_temporary_terms_inuse[block].size())
{
tmp_output.str("");
for (temporary_terms_inuse_type::const_iterator it = v_temporary_terms_inuse[block].begin();
for (temporary_terms_inuse_t::const_iterator it = v_temporary_terms_inuse[block].begin();
it != v_temporary_terms_inuse[block].end(); it++)
tmp_output << " T" << *it;
output << " global" << tmp_output.str() << ";\n";
}
if (simulation_type == SOLVE_TWO_BOUNDARIES_COMPLETE || simulation_type == SOLVE_TWO_BOUNDARIES_SIMPLE)
{
temporary_terms_type tt2;
temporary_terms_t tt2;
tt2.clear();
for (int i = 0; i < (int) block_size; i++)
{
@ -362,7 +362,7 @@ DynamicModel::writeModelEquationsOrdered_M(const string &dynamic_basename) const
{
output << " " << "% //Temporary variables initialization" << endl
<< " " << "T_zeros = zeros(y_kmin+periods, 1);" << endl;
for (temporary_terms_type::const_iterator it = v_temporary_terms[block][i].begin();
for (temporary_terms_t::const_iterator it = v_temporary_terms[block][i].begin();
it != v_temporary_terms[block][i].end(); it++)
{
output << " ";
@ -398,12 +398,12 @@ DynamicModel::writeModelEquationsOrdered_M(const string &dynamic_basename) const
// The equations
for (unsigned int i = 0; i < block_size; i++)
{
temporary_terms_type tt2;
temporary_terms_t tt2;
tt2.clear();
if (v_temporary_terms[block].size())
{
output << " " << "% //Temporary variables" << endl;
for (temporary_terms_type::const_iterator it = v_temporary_terms[block][i].begin();
for (temporary_terms_t::const_iterator it = v_temporary_terms[block][i].begin();
it != v_temporary_terms[block][i].end(); it++)
{
output << " " << sps;
@ -509,7 +509,7 @@ DynamicModel::writeModelEquationsOrdered_M(const string &dynamic_basename) const
{
case EVALUATE_BACKWARD:
case EVALUATE_FORWARD:
for (t_derivative::const_iterator it = derivative_endo[block].begin(); it != derivative_endo[block].end(); it++)
for (derivative_t::const_iterator it = derivative_endo[block].begin(); it != derivative_endo[block].end(); it++)
{
int lag = it->first.first;
int eq = it->first.second.first;
@ -526,7 +526,7 @@ DynamicModel::writeModelEquationsOrdered_M(const string &dynamic_basename) const
<< ") " << var+1
<< ", equation=" << eq+1 << endl;
}
for (t_derivative::const_iterator it = derivative_other_endo[block].begin(); it != derivative_other_endo[block].end(); it++)
for (derivative_t::const_iterator it = derivative_other_endo[block].begin(); it != derivative_other_endo[block].end(); it++)
{
int lag = it->first.first;
int eq = it->first.second.first;
@ -550,7 +550,7 @@ DynamicModel::writeModelEquationsOrdered_M(const string &dynamic_basename) const
case SOLVE_FORWARD_SIMPLE:
case SOLVE_BACKWARD_COMPLETE:
case SOLVE_FORWARD_COMPLETE:
for (t_derivative::const_iterator it = derivative_endo[block].begin(); it != derivative_endo[block].end(); it++)
for (derivative_t::const_iterator it = derivative_endo[block].begin(); it != derivative_endo[block].end(); it++)
{
int lag = it->first.first;
unsigned int eq = it->first.second.first;
@ -565,7 +565,7 @@ DynamicModel::writeModelEquationsOrdered_M(const string &dynamic_basename) const
<< ", equation=" << eq+1 << endl;
}
for (t_derivative::const_iterator it = derivative_other_endo[block].begin(); it != derivative_other_endo[block].end(); it++)
for (derivative_t::const_iterator it = derivative_other_endo[block].begin(); it != derivative_other_endo[block].end(); it++)
{
int lag = it->first.first;
unsigned int eq = it->first.second.first;
@ -582,7 +582,7 @@ DynamicModel::writeModelEquationsOrdered_M(const string &dynamic_basename) const
output << " varargout{1}=g1_x;\n";
output << " varargout{2}=g1_o;\n";
output << " else" << endl;
for (t_block_derivatives_equation_variable_laglead_nodeid::const_iterator it = blocks_derivatives[block].begin(); it != (blocks_derivatives[block]).end(); it++)
for (block_derivatives_equation_variable_laglead_nodeid_t::const_iterator it = blocks_derivatives[block].begin(); it != (blocks_derivatives[block]).end(); it++)
{
unsigned int eq = it->first.first;
unsigned int var = it->first.second;
@ -602,7 +602,7 @@ DynamicModel::writeModelEquationsOrdered_M(const string &dynamic_basename) const
case SOLVE_TWO_BOUNDARIES_SIMPLE:
case SOLVE_TWO_BOUNDARIES_COMPLETE:
output << " if ~jacobian_eval" << endl;
for (t_block_derivatives_equation_variable_laglead_nodeid::const_iterator it = blocks_derivatives[block].begin(); it != (blocks_derivatives[block]).end(); it++)
for (block_derivatives_equation_variable_laglead_nodeid_t::const_iterator it = blocks_derivatives[block].begin(); it != (blocks_derivatives[block]).end(); it++)
{
unsigned int eq = it->first.first;
unsigned int var = it->first.second;
@ -682,7 +682,7 @@ DynamicModel::writeModelEquationsOrdered_M(const string &dynamic_basename) const
output << " else" << endl;
for (t_derivative::const_iterator it = derivative_endo[block].begin(); it != derivative_endo[block].end(); it++)
for (derivative_t::const_iterator it = derivative_endo[block].begin(); it != derivative_endo[block].end(); it++)
{
int lag = it->first.first;
unsigned int eq = it->first.second.first;
@ -695,7 +695,7 @@ DynamicModel::writeModelEquationsOrdered_M(const string &dynamic_basename) const
<< ") " << var+1
<< ", equation=" << eq+1 << endl;
}
for (t_derivative::const_iterator it = derivative_other_endo[block].begin(); it != derivative_other_endo[block].end(); it++)
for (derivative_t::const_iterator it = derivative_other_endo[block].begin(); it != derivative_other_endo[block].end(); it++)
{
int lag = it->first.first;
unsigned int eq = it->first.second.first;
@ -722,7 +722,7 @@ DynamicModel::writeModelEquationsOrdered_M(const string &dynamic_basename) const
}
void
DynamicModel::writeModelEquationsCode(string &file_name, const string &bin_basename, const map_idx_type &map_idx) const
DynamicModel::writeModelEquationsCode(string &file_name, const string &bin_basename, const map_idx_t &map_idx) const
{
ostringstream tmp_output;
ofstream code_file;
@ -778,7 +778,7 @@ DynamicModel::writeModelEquationsCode(string &file_name, const string &bin_basen
vector<vector<pair<pair<int, int>, int > > > derivatives;
derivatives.resize(symbol_table.endo_nbr());
count_u = symbol_table.endo_nbr();
for (first_derivatives_type::const_iterator it = first_derivatives.begin();
for (first_derivatives_t::const_iterator it = first_derivatives.begin();
it != first_derivatives.end(); it++)
{
int deriv_id = it->first.second;
@ -835,7 +835,7 @@ DynamicModel::writeModelEquationsCode(string &file_name, const string &bin_basen
void
DynamicModel::writeModelEquationsCode_Block(string &file_name, const string &bin_basename, const map_idx_type &map_idx) const
DynamicModel::writeModelEquationsCode_Block(string &file_name, const string &bin_basename, const map_idx_t &map_idx) const
{
struct Uff_l
{
@ -913,11 +913,11 @@ DynamicModel::writeModelEquationsCode_Block(string &file_name, const string &bin
for (i = 0; i < (int) block_size; i++)
{
//The Temporary terms
temporary_terms_type tt2;
temporary_terms_t tt2;
tt2.clear();
if (v_temporary_terms[block][i].size())
{
for (temporary_terms_type::const_iterator it = v_temporary_terms[block][i].begin();
for (temporary_terms_t::const_iterator it = v_temporary_terms[block][i].begin();
it != v_temporary_terms[block][i].end(); it++)
{
FNUMEXPR_ fnumexpr(TemporaryTerm, (int)(map_idx.find((*it)->idx)->second));
@ -937,10 +937,10 @@ DynamicModel::writeModelEquationsCode_Block(string &file_name, const string &bin
}
}
#ifdef DEBUGC
for (temporary_terms_type::const_iterator it = v_temporary_terms[block][i].begin();
for (temporary_terms_t::const_iterator it = v_temporary_terms[block][i].begin();
it != v_temporary_terms[block][i].end(); it++)
{
map_idx_type::const_iterator ii = map_idx.find((*it)->idx);
map_idx_t::const_iterator ii = map_idx.find((*it)->idx);
cout << "map_idx[" << (*it)->idx <<"]=" << ii->second << "\n";
}
#endif
@ -1028,7 +1028,7 @@ DynamicModel::writeModelEquationsCode_Block(string &file_name, const string &bin
case SOLVE_TWO_BOUNDARIES_COMPLETE:
case SOLVE_TWO_BOUNDARIES_SIMPLE:
count_u = feedback_variables.size();
for (t_block_derivatives_equation_variable_laglead_nodeid::const_iterator it = blocks_derivatives[block].begin(); it != (blocks_derivatives[block]).end(); it++)
for (block_derivatives_equation_variable_laglead_nodeid_t::const_iterator it = blocks_derivatives[block].begin(); it != (blocks_derivatives[block]).end(); it++)
{
unsigned int eq = it->first.first;
unsigned int var = it->first.second;
@ -1270,7 +1270,7 @@ DynamicModel::Write_Inf_To_Bin_File_Block(const string &dynamic_basename, const
unsigned int block_size = getBlockSize(num);
unsigned int block_mfs = getBlockMfs(num);
unsigned int block_recursive = block_size - block_mfs;
for (t_block_derivatives_equation_variable_laglead_nodeid::const_iterator it = blocks_derivatives[num].begin(); it != (blocks_derivatives[num]).end(); it++)
for (block_derivatives_equation_variable_laglead_nodeid_t::const_iterator it = blocks_derivatives[num].begin(); it != (blocks_derivatives[num]).end(); it++)
{
unsigned int eq = it->first.first;
unsigned int var = it->first.second;
@ -1335,7 +1335,7 @@ DynamicModel::writeSparseDynamicMFile(const string &dynamic_basename, const stri
//Temporary variables declaration
OK = true;
ostringstream tmp_output;
for (temporary_terms_type::const_iterator it = temporary_terms.begin();
for (temporary_terms_t::const_iterator it = temporary_terms.begin();
it != temporary_terms.end(); it++)
{
if (OK)
@ -1349,7 +1349,7 @@ DynamicModel::writeSparseDynamicMFile(const string &dynamic_basename, const stri
mDynamicModelFile << " T_init=zeros(1,options_.periods+M_.maximum_lag+M_.maximum_lead);\n";
tmp_output.str("");
for (temporary_terms_type::const_iterator it = temporary_terms.begin();
for (temporary_terms_t::const_iterator it = temporary_terms.begin();
it != temporary_terms.end(); it++)
{
tmp_output << " ";
@ -1655,7 +1655,7 @@ DynamicModel::writeDynamicModel(ostream &DynamicOutput, bool use_dll) const
int hessianColsNbr = dynJacobianColsNbr * dynJacobianColsNbr;
// Writing Jacobian
for (first_derivatives_type::const_iterator it = first_derivatives.begin();
for (first_derivatives_t::const_iterator it = first_derivatives.begin();
it != first_derivatives.end(); it++)
{
int eq = it->first.first;
@ -1671,7 +1671,7 @@ DynamicModel::writeDynamicModel(ostream &DynamicOutput, bool use_dll) const
// Writing Hessian
int k = 0; // Keep the line of a 2nd derivative in v2
for (second_derivatives_type::const_iterator it = second_derivatives.begin();
for (second_derivatives_t::const_iterator it = second_derivatives.begin();
it != second_derivatives.end(); it++)
{
int eq = it->first.first;
@ -1718,7 +1718,7 @@ DynamicModel::writeDynamicModel(ostream &DynamicOutput, bool use_dll) const
// Writing third derivatives
k = 0; // Keep the line of a 3rd derivative in v3
for (third_derivatives_type::const_iterator it = third_derivatives.begin();
for (third_derivatives_t::const_iterator it = third_derivatives.begin();
it != third_derivatives.end(); it++)
{
int eq = it->first.first;
@ -1935,7 +1935,7 @@ DynamicModel::writeOutput(ostream &output, const string &basename, bool block_de
tmp_s_eq << " " << getBlockEquationID(block, i)+1;
}
it_exogenous = exogenous.begin();
for (t_lag_var::const_iterator it = exo_block[block].begin(); it != exo_block[block].end(); it++)
for (lag_var_t::const_iterator it = exo_block[block].begin(); it != exo_block[block].end(); it++)
it_exogenous = set_union(it->second.begin(), it->second.end(), exogenous.begin(), exogenous.end(), it_exogenous);
output << "M_.block_structure.block(" << block+1 << ").num = " << block+1 << ";\n";
output << "M_.block_structure.block(" << block+1 << ").Simulation_Type = " << simulation_type << ";\n";
@ -1963,15 +1963,15 @@ DynamicModel::writeOutput(ostream &output, const string &basename, bool block_de
tmp_s.str("");
count_lead_lag_incidence = 0;
dynamic_jacob_map reordered_dynamic_jacobian;
for (t_block_derivatives_equation_variable_laglead_nodeid::const_iterator it = blocks_derivatives[block].begin(); it != blocks_derivatives[block].end(); it++)
dynamic_jacob_map_t reordered_dynamic_jacobian;
for (block_derivatives_equation_variable_laglead_nodeid_t::const_iterator it = blocks_derivatives[block].begin(); it != blocks_derivatives[block].end(); it++)
reordered_dynamic_jacobian[make_pair(it->second.first, make_pair(it->first.second, it->first.first))] = it->second.second;
output << "M_.block_structure.block(" << block+1 << ").lead_lag_incidence = [];\n";
int last_var = -1;
for (int lag = -max_lag_endo; lag < max_lead_endo+1; lag++)
{
last_var = 0;
for (dynamic_jacob_map::const_iterator it = reordered_dynamic_jacobian.begin(); it != reordered_dynamic_jacobian.end(); it++)
for (dynamic_jacob_map_t::const_iterator it = reordered_dynamic_jacobian.begin(); it != reordered_dynamic_jacobian.end(); it++)
{
if (lag == it->first.first && last_var != it->first.second.first)
{
@ -2001,7 +2001,7 @@ DynamicModel::writeOutput(ostream &output, const string &basename, bool block_de
output << " " << equation_reordered[i]+1;
output << "];\n";
map<pair< int, pair<int, int> >, int> lag_row_incidence;
for (first_derivatives_type::const_iterator it = first_derivatives.begin();
for (first_derivatives_t::const_iterator it = first_derivatives.begin();
it != first_derivatives.end(); it++)
{
int deriv_id = it->first.second;
@ -2078,7 +2078,7 @@ map<pair<int, pair<int, int > >, NodeID>
DynamicModel::collect_first_order_derivatives_endogenous()
{
map<pair<int, pair<int, int > >, NodeID> endo_derivatives;
for (first_derivatives_type::iterator it2 = first_derivatives.begin();
for (first_derivatives_t::iterator it2 = first_derivatives.begin();
it2 != first_derivatives.end(); it2++)
{
if (getTypeByDerivID(it2->first.second) == eEndogenous)
@ -2094,7 +2094,7 @@ DynamicModel::collect_first_order_derivatives_endogenous()
void
DynamicModel::computingPass(bool jacobianExo, bool hessian, bool thirdDerivatives, bool paramsDerivatives,
const eval_context_type &eval_context, bool no_tmp_terms, bool block, bool use_dll, bool bytecode)
const eval_context_t &eval_context, bool no_tmp_terms, bool block, bool use_dll, bool bytecode)
{
assert(jacobianExo || !(hessian || thirdDerivatives || paramsDerivatives));
@ -2142,7 +2142,7 @@ DynamicModel::computingPass(bool jacobianExo, bool hessian, bool thirdDerivative
if (block)
{
jacob_map contemporaneous_jacobian, static_jacobian;
jacob_map_t contemporaneous_jacobian, static_jacobian;
// for each block contains pair<Size, Feddback_variable>
vector<pair<int, int> > blocks;
@ -2241,14 +2241,14 @@ DynamicModel::get_Derivatives(int block)
}
void
DynamicModel::computeChainRuleJacobian(t_blocks_derivatives &blocks_derivatives)
DynamicModel::computeChainRuleJacobian(blocks_derivatives_t &blocks_derivatives)
{
map<int, NodeID> recursive_variables;
unsigned int nb_blocks = getNbBlocks();
blocks_derivatives = t_blocks_derivatives(nb_blocks);
blocks_derivatives = blocks_derivatives_t(nb_blocks);
for (unsigned int block = 0; block < nb_blocks; block++)
{
t_block_derivatives_equation_variable_laglead_nodeid tmp_derivatives;
block_derivatives_equation_variable_laglead_nodeid_t tmp_derivatives;
recursive_variables.clear();
BlockSimulationType simulation_type = getBlockSimulationType(block);
int block_size = getBlockSize(block);
@ -2256,7 +2256,7 @@ DynamicModel::computeChainRuleJacobian(t_blocks_derivatives &blocks_derivatives)
int block_nb_recursives = block_size - block_nb_mfs;
if (simulation_type == SOLVE_TWO_BOUNDARIES_COMPLETE || simulation_type == SOLVE_TWO_BOUNDARIES_SIMPLE)
{
blocks_derivatives.push_back(t_block_derivatives_equation_variable_laglead_nodeid(0));
blocks_derivatives.push_back(block_derivatives_equation_variable_laglead_nodeid_t(0));
for (int i = 0; i < block_nb_recursives; i++)
{
if (getBlockEquationType(block, i) == E_EVALUATE_S)
@ -2293,7 +2293,7 @@ DynamicModel::computeChainRuleJacobian(t_blocks_derivatives &blocks_derivatives)
else if (simulation_type == SOLVE_BACKWARD_SIMPLE || simulation_type == SOLVE_FORWARD_SIMPLE
|| simulation_type == SOLVE_BACKWARD_COMPLETE || simulation_type == SOLVE_FORWARD_COMPLETE)
{
blocks_derivatives.push_back(t_block_derivatives_equation_variable_laglead_nodeid(0));
blocks_derivatives.push_back(block_derivatives_equation_variable_laglead_nodeid_t(0));
for (int i = 0; i < block_nb_recursives; i++)
{
if (getBlockEquationType(block, i) == E_EVALUATE_S)
@ -2337,19 +2337,19 @@ DynamicModel::collect_block_first_order_derivatives()
variable_2_block[getBlockVariableID(block, i)] = block;
}
}
other_endo_block = vector<t_lag_var>(nb_blocks);
exo_block = vector<t_lag_var>(nb_blocks);
exo_det_block = vector<t_lag_var>(nb_blocks);
derivative_endo = vector<t_derivative>(nb_blocks);
derivative_other_endo = vector<t_derivative>(nb_blocks);
derivative_exo = vector<t_derivative>(nb_blocks);
derivative_exo_det = vector<t_derivative>(nb_blocks);
other_endo_block = vector<lag_var_t>(nb_blocks);
exo_block = vector<lag_var_t>(nb_blocks);
exo_det_block = vector<lag_var_t>(nb_blocks);
derivative_endo = vector<derivative_t>(nb_blocks);
derivative_other_endo = vector<derivative_t>(nb_blocks);
derivative_exo = vector<derivative_t>(nb_blocks);
derivative_exo_det = vector<derivative_t>(nb_blocks);
endo_max_leadlag_block = vector<pair<int, int> >(nb_blocks, make_pair(0, 0));
other_endo_max_leadlag_block = vector<pair<int, int> >(nb_blocks, make_pair(0, 0));
exo_max_leadlag_block = vector<pair<int, int> >(nb_blocks, make_pair(0, 0));
exo_det_max_leadlag_block = vector<pair<int, int> >(nb_blocks, make_pair(0, 0));
max_leadlag_block = vector<pair<int, int> >(nb_blocks, make_pair(0, 0));
for (first_derivatives_type::iterator it2 = first_derivatives.begin();
for (first_derivatives_t::iterator it2 = first_derivatives.begin();
it2 != first_derivatives.end(); it2++)
{
int eq = it2->first.first;
@ -2357,8 +2357,8 @@ DynamicModel::collect_block_first_order_derivatives()
int lag = getLagByDerivID(it2->first.second);
int block_eq = equation_2_block[eq];
int block_var = variable_2_block[var];
t_derivative tmp_derivative;
t_lag_var lag_var;
derivative_t tmp_derivative;
lag_var_t lag_var;
switch (getTypeByDerivID(it2->first.second))
{
case eEndogenous:
@ -2655,7 +2655,7 @@ DynamicModel::computeParamsDerivatives()
residuals_params_derivatives[make_pair(eq, param)] = d1;
}
for (first_derivatives_type::const_iterator it2 = residuals_params_derivatives.begin();
for (first_derivatives_t::const_iterator it2 = residuals_params_derivatives.begin();
it2 != residuals_params_derivatives.end(); it2++)
{
int eq = it2->first.first;
@ -2668,7 +2668,7 @@ DynamicModel::computeParamsDerivatives()
residuals_params_second_derivatives[make_pair(eq, make_pair(param1, param))] = d2;
}
for (first_derivatives_type::const_iterator it2 = first_derivatives.begin();
for (first_derivatives_t::const_iterator it2 = first_derivatives.begin();
it2 != first_derivatives.end(); it2++)
{
int eq = it2->first.first;
@ -2681,7 +2681,7 @@ DynamicModel::computeParamsDerivatives()
jacobian_params_derivatives[make_pair(eq, make_pair(var, param))] = d2;
}
for (second_derivatives_type::const_iterator it2 = jacobian_params_derivatives.begin();
for (second_derivatives_t::const_iterator it2 = jacobian_params_derivatives.begin();
it2 != jacobian_params_derivatives.end(); it2++)
{
int eq = it2->first.first;
@ -2695,7 +2695,7 @@ DynamicModel::computeParamsDerivatives()
jacobian_params_second_derivatives[make_pair(eq, make_pair(var, make_pair(param1, param)))] = d2;
}
for (second_derivatives_type::const_iterator it2 = second_derivatives.begin();
for (second_derivatives_t::const_iterator it2 = second_derivatives.begin();
it2 != second_derivatives.end(); it2++)
{
int eq = it2->first.first;
@ -2717,11 +2717,11 @@ DynamicModel::computeParamsDerivativesTemporaryTerms()
map<NodeID, int> reference_count;
params_derivs_temporary_terms.clear();
for (first_derivatives_type::iterator it = residuals_params_derivatives.begin();
for (first_derivatives_t::iterator it = residuals_params_derivatives.begin();
it != residuals_params_derivatives.end(); it++)
it->second->computeTemporaryTerms(reference_count, params_derivs_temporary_terms, true);
for (second_derivatives_type::iterator it = jacobian_params_derivatives.begin();
for (second_derivatives_t::iterator it = jacobian_params_derivatives.begin();
it != jacobian_params_derivatives.end(); it++)
it->second->computeTemporaryTerms(reference_count, params_derivs_temporary_terms, true);
}
@ -2759,7 +2759,7 @@ DynamicModel::writeParamsDerivativesFile(const string &basename) const
paramsDerivsFile << "rp = zeros(" << equation_number() << ", "
<< symbol_table.param_nbr() << ");" << endl;
for (first_derivatives_type::const_iterator it = residuals_params_derivatives.begin();
for (first_derivatives_t::const_iterator it = residuals_params_derivatives.begin();
it != residuals_params_derivatives.end(); it++)
{
int eq = it->first.first;
@ -2777,7 +2777,7 @@ DynamicModel::writeParamsDerivativesFile(const string &basename) const
paramsDerivsFile << "gp = zeros(" << equation_number() << ", " << dynJacobianColsNbr << ", "
<< symbol_table.param_nbr() << ");" << endl;
for (second_derivatives_type::const_iterator it = jacobian_params_derivatives.begin();
for (second_derivatives_t::const_iterator it = jacobian_params_derivatives.begin();
it != jacobian_params_derivatives.end(); it++)
{
int eq = it->first.first;
@ -2801,7 +2801,7 @@ DynamicModel::writeParamsDerivativesFile(const string &basename) const
<< ",4);" << endl;
int i = 1;
for (second_derivatives_type::const_iterator it = residuals_params_second_derivatives.begin();
for (second_derivatives_t::const_iterator it = residuals_params_second_derivatives.begin();
it != residuals_params_second_derivatives.end(); ++it, i++)
{
int eq = it->first.first;
@ -2825,7 +2825,7 @@ DynamicModel::writeParamsDerivativesFile(const string &basename) const
<< ",5);" << endl;
i = 1;
for (third_derivatives_type::const_iterator it = jacobian_params_second_derivatives.begin();
for (third_derivatives_t::const_iterator it = jacobian_params_second_derivatives.begin();
it != jacobian_params_second_derivatives.end(); ++it, i++)
{
int eq = it->first.first;
@ -2855,7 +2855,7 @@ DynamicModel::writeParamsDerivativesFile(const string &basename) const
paramsDerivsFile << "hp = zeros(" << hessian_params_derivatives.size() << ",5);" << endl;
i = 1;
for (third_derivatives_type::const_iterator it = hessian_params_derivatives.begin();
for (third_derivatives_t::const_iterator it = hessian_params_derivatives.begin();
it != hessian_params_derivatives.end(); ++it, i++)
{
int eq = it->first.first;
@ -2885,7 +2885,7 @@ DynamicModel::writeParamsDerivativesFile(const string &basename) const
void
DynamicModel::writeChainRuleDerivative(ostream &output, int eqr, int varr, int lag,
ExprNodeOutputType output_type,
const temporary_terms_type &temporary_terms) const
const temporary_terms_t &temporary_terms) const
{
map<pair<int, pair<int, int> >, NodeID>::const_iterator it = first_chain_rule_derivatives.find(make_pair(eqr, make_pair(varr, lag)));
if (it != first_chain_rule_derivatives.end())
@ -3087,7 +3087,7 @@ DynamicModel::transformPredeterminedVariables()
}
void
DynamicModel::fillEvalContext(eval_context_type &eval_context) const
DynamicModel::fillEvalContext(eval_context_t &eval_context) const
{
// First, auxiliary variables
for (deque<BinaryOpNode *>::const_iterator it = aux_equations.begin();

58
DynamicModel.hh
View File

@ -62,47 +62,47 @@ private:
Only non-null derivatives are stored in the map.
Parameter indices are those of the getDerivID() method.
*/
first_derivatives_type residuals_params_derivatives;
first_derivatives_t residuals_params_derivatives;
//! Second derivatives of the residuals w.r. to parameters
/*! First index is equation number, second and third indeces are parameters.
Only non-null derivatives are stored in the map.
Parameter indices are those of the getDerivID() method.
*/
second_derivatives_type residuals_params_second_derivatives;
second_derivatives_t residuals_params_second_derivatives;
//! Derivatives of the jacobian w.r. to parameters
/*! First index is equation number, second is endo/exo/exo_det variable, and third is parameter.
Only non-null derivatives are stored in the map.
Variable and parameter indices are those of the getDerivID() method.
*/
second_derivatives_type jacobian_params_derivatives;
second_derivatives_t jacobian_params_derivatives;
//! Second derivatives of the jacobian w.r. to parameters
/*! First index is equation number, second is endo/exo/exo_det variable, and third and fourth are parameters.
Only non-null derivatives are stored in the map.
Variable and parameter indices are those of the getDerivID() method.
*/
third_derivatives_type jacobian_params_second_derivatives;
third_derivatives_t jacobian_params_second_derivatives;
//! Derivatives of the hessian w.r. to parameters
/*! First index is equation number, first and second are endo/exo/exo_det variable, and third is parameter.
Only non-null derivatives are stored in the map.
Variable and parameter indices are those of the getDerivID() method.
*/
third_derivatives_type hessian_params_derivatives;
third_derivatives_t hessian_params_derivatives;
//! Temporary terms for the file containing parameters dervicatives
temporary_terms_type params_derivs_temporary_terms;
temporary_terms_t params_derivs_temporary_terms;
//! Temporary terms for block decomposed models
vector< vector<temporary_terms_type> > v_temporary_terms;
vector< vector<temporary_terms_t> > v_temporary_terms;
vector<temporary_terms_inuse_type> v_temporary_terms_inuse;
vector<temporary_terms_inuse_t> v_temporary_terms_inuse;
//! Store the derivatives or the chainrule derivatives:map<pair< equation, pair< variable, lead_lag >, NodeID>
typedef map< pair< int, pair< int, int> >, NodeID> first_chain_rule_derivatives_type;
first_chain_rule_derivatives_type first_chain_rule_derivatives;
typedef map< pair< int, pair< int, int> >, NodeID> first_chain_rule_derivatives_t;
first_chain_rule_derivatives_t first_chain_rule_derivatives;
//! Writes dynamic model file (Matlab version)
void writeDynamicMFile(const string &dynamic_basename) const;
@ -117,24 +117,24 @@ private:
//! Writes the Block reordred structure of the model in M output
void writeModelEquationsOrdered_M(const string &dynamic_basename) const;
//! Writes the code of the Block reordred structure of the model in virtual machine bytecode
void writeModelEquationsCode_Block(string &file_name, const string &bin_basename, const map_idx_type &map_idx) const;
void writeModelEquationsCode_Block(string &file_name, const string &bin_basename, const map_idx_t &map_idx) const;
//! Writes the code of the model in virtual machine bytecode
void writeModelEquationsCode(string &file_name, const string &bin_basename, const map_idx_type &map_idx) const;
void writeModelEquationsCode(string &file_name, const string &bin_basename, const map_idx_t &map_idx) const;
//! Computes jacobian and prepares for equation normalization
/*! Using values from initval/endval blocks and parameter initializations:
- computes the jacobian for the model w.r. to contemporaneous variables
- removes edges of the incidence matrix when derivative w.r. to the corresponding variable is too close to zero (below the cutoff)
*/
//void evaluateJacobian(const eval_context_type &eval_context, jacob_map *j_m, bool dynamic);
//void evaluateJacobian(const eval_context_t &eval_context, jacob_map *j_m, bool dynamic);
//! return a map on the block jacobian
map<pair<pair<int, pair<int, int> >, pair<int, int> >, int> get_Derivatives(int block);
//! Computes chain rule derivatives of the Jacobian w.r. to endogenous variables
void computeChainRuleJacobian(t_blocks_derivatives &blocks_derivatives);
void computeChainRuleJacobian(blocks_derivatives_t &blocks_derivatives);
string reform(string name) const;
map_idx_type map_idx;
map_idx_t map_idx;
//! sorts the temporary terms in the blocks order
void computeTemporaryTermsOrdered();
@ -142,9 +142,9 @@ private:
//! creates a mapping from the index of temporary terms to a natural index
void computeTemporaryTermsMapping();
//! Write derivative code of an equation w.r. to a variable
void compileDerivative(ofstream &code_file, int eq, int symb_id, int lag, const map_idx_type &map_idx) const;
void compileDerivative(ofstream &code_file, int eq, int symb_id, int lag, const map_idx_t &map_idx) const;
//! Write chain rule derivative code of an equation w.r. to a variable
void compileChainRuleDerivative(ofstream &code_file, int eq, int var, int lag, const map_idx_type &map_idx) const;
void compileChainRuleDerivative(ofstream &code_file, int eq, int var, int lag, const map_idx_t &map_idx) const;
//! Get the type corresponding to a derivation ID
virtual SymbolType getTypeByDerivID(int deriv_id) const throw (UnknownDerivIDException);
@ -175,7 +175,7 @@ private:
void sparseHelper(int order, ostream &output, int row_nb, int col_nb, ExprNodeOutputType output_type) const;
//! Write chain rule derivative of a recursive equation w.r. to a variable
void writeChainRuleDerivative(ostream &output, int eq, int var, int lag, ExprNodeOutputType output_type, const temporary_terms_type &temporary_terms) const;
void writeChainRuleDerivative(ostream &output, int eq, int var, int lag, ExprNodeOutputType output_type, const temporary_terms_t &temporary_terms) const;
//! Collecte the derivatives w.r. to endogenous of the block, to endogenous of previouys blocks and to exogenous
void collect_block_first_order_derivatives();
@ -192,29 +192,29 @@ private:
vector<int> equation_reordered, variable_reordered, inv_equation_reordered, inv_variable_reordered;
//! Vector describing equations: BlockSimulationType, if BlockSimulationType == EVALUATE_s then a NodeID on the new normalized equation
t_equation_type_and_normalized_equation equation_type_and_normalized_equation;
equation_type_and_normalized_equation_t equation_type_and_normalized_equation;
//! for each block contains pair< Simulation_Type, pair < Block_Size, Recursive_part_Size > >
t_block_type_firstequation_size_mfs block_type_firstequation_size_mfs;
block_type_firstequation_size_mfs_t block_type_firstequation_size_mfs;
//! for all blocks derivatives description
t_blocks_derivatives blocks_derivatives;
blocks_derivatives_t blocks_derivatives;
//! The jacobian without the elements below the cutoff
dynamic_jacob_map dynamic_jacobian;
dynamic_jacob_map_t dynamic_jacobian;
//! Vector indicating if the block is linear in endogenous variable (true) or not (false)
vector<bool> blocks_linear;
//! Map the derivatives for a block pair<lag, make_pair(make_pair(eq, var)), NodeID>
typedef map<pair< int, pair<int, int> >, NodeID> t_derivative;
typedef map<pair< int, pair<int, int> >, NodeID> derivative_t;
//! Vector of derivative for each blocks
vector<t_derivative> derivative_endo, derivative_other_endo, derivative_exo, derivative_exo_det;
vector<derivative_t> derivative_endo, derivative_other_endo, derivative_exo, derivative_exo_det;
//!List for each block and for each lag-leag all the other endogenous variables and exogenous variables
typedef set<int> t_var;
typedef map<int, t_var> t_lag_var;
vector<t_lag_var> other_endo_block, exo_block, exo_det_block;
typedef set<int> var_t;
typedef map<int, var_t> lag_var_t;
vector<lag_var_t> other_endo_block, exo_block, exo_det_block;
//!Maximum lead and lag for each block on endogenous of the block, endogenous of the previous blocks, exogenous and deterministic exogenous
vector<pair<int, int> > endo_max_leadlag_block, other_endo_max_leadlag_block, exo_max_leadlag_block, exo_det_max_leadlag_block, max_leadlag_block;
@ -245,7 +245,7 @@ public:
\param no_tmp_terms if true, no temporary terms will be computed in the dynamic files
*/
void computingPass(bool jacobianExo, bool hessian, bool thirdDerivatives, bool paramsDerivatives,
const eval_context_type &eval_context, bool no_tmp_terms, bool block, bool use_dll, bool bytecode);
const eval_context_t &eval_context, bool no_tmp_terms, bool block, bool use_dll, bool bytecode);
//! Writes model initialization and lead/lag incidence matrix to output
void writeOutput(ostream &output, const string &basename, bool block, bool byte_code, bool use_dll, int order) const;
@ -297,7 +297,7 @@ public:
void transformPredeterminedVariables();
//! Fills eval context with values of model local variables and auxiliary variables
void fillEvalContext(eval_context_type &eval_context) const;
void fillEvalContext(eval_context_t &eval_context) const;
//! Return the number of blocks
virtual unsigned int

236
ExprNode.cc
View File

@ -71,14 +71,14 @@ ExprNode::getDerivative(int deriv_id)
}
int
ExprNode::precedence(ExprNodeOutputType output_type, const temporary_terms_type &temporary_terms) const
ExprNode::precedence(ExprNodeOutputType output_type, const temporary_terms_t &temporary_terms) const
{
// For a constant, a variable, or a unary op, the precedence is maximal
return 100;
}
int
ExprNode::cost(const temporary_terms_type &temporary_terms, bool is_matlab) const
ExprNode::cost(const temporary_terms_t &temporary_terms, bool is_matlab) const
{
// For a terminal node, the cost is null
return 0;
@ -115,7 +115,7 @@ ExprNode::collectModelLocalVariables(set<int> &result) const
void
ExprNode::computeTemporaryTerms(map<NodeID, int> &reference_count,
temporary_terms_type &temporary_terms,
temporary_terms_t &temporary_terms,
bool is_matlab) const
{
// Nothing to do for a terminal node
@ -123,10 +123,10 @@ ExprNode::computeTemporaryTerms(map<NodeID, int> &reference_count,
void
ExprNode::computeTemporaryTerms(map<NodeID, int> &reference_count,
temporary_terms_type &temporary_terms,
temporary_terms_t &temporary_terms,
map<NodeID, pair<int, int> > &first_occurence,
int Curr_block,
vector<vector<temporary_terms_type> > &v_temporary_terms,
vector<vector<temporary_terms_t> > &v_temporary_terms,
int equation) const
{
// Nothing to do for a terminal node
@ -141,26 +141,26 @@ ExprNode::normalizeEquation(int var_endo, vector<pair<int, pair<NodeID, NodeID>
void
ExprNode::writeOutput(ostream &output) const
{
writeOutput(output, oMatlabOutsideModel, temporary_terms_type());
writeOutput(output, oMatlabOutsideModel, temporary_terms_t());
}
void
ExprNode::writeOutput(ostream &output, ExprNodeOutputType output_type) const
{
writeOutput(output, output_type, temporary_terms_type());
writeOutput(output, output_type, temporary_terms_t());
}
void
ExprNode::writeOutput(ostream &output, ExprNodeOutputType output_type, const temporary_terms_type &temporary_terms) const
ExprNode::writeOutput(ostream &output, ExprNodeOutputType output_type, const temporary_terms_t &temporary_terms) const
{
deriv_node_temp_terms_type tef_terms;
deriv_node_temp_terms_t tef_terms;
writeOutput(output, output_type, temporary_terms, tef_terms);
}
void
ExprNode::writeExternalFunctionOutput(ostream &output, ExprNodeOutputType output_type,
const temporary_terms_type &temporary_terms,
deriv_node_temp_terms_type &tef_terms) const
const temporary_terms_t &temporary_terms,
deriv_node_temp_terms_t &tef_terms) const
{
// Nothing to do
}
@ -271,19 +271,19 @@ NumConstNode::computeDerivative(int deriv_id)
}
void
NumConstNode::collectTemporary_terms(const temporary_terms_type &temporary_terms, temporary_terms_inuse_type &temporary_terms_inuse, int Curr_Block) const
NumConstNode::collectTemporary_terms(const temporary_terms_t &temporary_terms, temporary_terms_inuse_t &temporary_terms_inuse, int Curr_Block) const
{
temporary_terms_type::const_iterator it = temporary_terms.find(const_cast<NumConstNode *>(this));
temporary_terms_t::const_iterator it = temporary_terms.find(const_cast<NumConstNode *>(this));
if (it != temporary_terms.end())
temporary_terms_inuse.insert(idx);
}
void
NumConstNode::writeOutput(ostream &output, ExprNodeOutputType output_type,
const temporary_terms_type &temporary_terms,
deriv_node_temp_terms_type &tef_terms) const
const temporary_terms_t &temporary_terms,
deriv_node_temp_terms_t &tef_terms) const
{
temporary_terms_type::const_iterator it = temporary_terms.find(const_cast<NumConstNode *>(this));
temporary_terms_t::const_iterator it = temporary_terms.find(const_cast<NumConstNode *>(this));
if (it != temporary_terms.end())
if (output_type == oMatlabDynamicModelSparse)
output << "T" << idx << "(it_)";
@ -294,13 +294,13 @@ NumConstNode::writeOutput(ostream &output, ExprNodeOutputType output_type,
}
double
NumConstNode::eval(const eval_context_type &eval_context) const throw (EvalException)
NumConstNode::eval(const eval_context_t &eval_context) const throw (EvalException)
{
return (datatree.num_constants.getDouble(id));
}
void
NumConstNode::compile(ostream &CompileCode, bool lhs_rhs, const temporary_terms_type &temporary_terms, const map_idx_type &map_idx, bool dynamic, bool steady_dynamic) const
NumConstNode::compile(ostream &CompileCode, bool lhs_rhs, const temporary_terms_t &temporary_terms, const map_idx_t &map_idx, bool dynamic, bool steady_dynamic) const
{
FLDC_ fldc(datatree.num_constants.getDouble(id));
fldc.write(CompileCode);
@ -483,9 +483,9 @@ VariableNode::computeDerivative(int deriv_id)
}
void
VariableNode::collectTemporary_terms(const temporary_terms_type &temporary_terms, temporary_terms_inuse_type &temporary_terms_inuse, int Curr_Block) const
VariableNode::collectTemporary_terms(const temporary_terms_t &temporary_terms, temporary_terms_inuse_t &temporary_terms_inuse, int Curr_Block) const
{
temporary_terms_type::const_iterator it = temporary_terms.find(const_cast<VariableNode *>(this));
temporary_terms_t::const_iterator it = temporary_terms.find(const_cast<VariableNode *>(this));
if (it != temporary_terms.end())
temporary_terms_inuse.insert(idx);
if (type == eModelLocalVariable)
@ -494,11 +494,11 @@ VariableNode::collectTemporary_terms(const temporary_terms_type &temporary_terms
void
VariableNode::writeOutput(ostream &output, ExprNodeOutputType output_type,
const temporary_terms_type &temporary_terms,
deriv_node_temp_terms_type &tef_terms) const
const temporary_terms_t &temporary_terms,
deriv_node_temp_terms_t &tef_terms) const
{
// If node is a temporary term
temporary_terms_type::const_iterator it = temporary_terms.find(const_cast<VariableNode *>(this));
temporary_terms_t::const_iterator it = temporary_terms.find(const_cast<VariableNode *>(this));
if (it != temporary_terms.end())
{
if (output_type == oMatlabDynamicModelSparse)
@ -679,9 +679,9 @@ VariableNode::writeOutput(ostream &output, ExprNodeOutputType output_type,
}
double
VariableNode::eval(const eval_context_type &eval_context) const throw (EvalException)
VariableNode::eval(const eval_context_t &eval_context) const throw (EvalException)
{
eval_context_type::const_iterator it = eval_context.find(symb_id);
eval_context_t::const_iterator it = eval_context.find(symb_id);
if (it == eval_context.end())
throw EvalException();
@ -689,7 +689,7 @@ VariableNode::eval(const eval_context_type &eval_context) const throw (EvalExcep
}
void
VariableNode::compile(ostream &CompileCode, bool lhs_rhs, const temporary_terms_type &temporary_terms, const map_idx_type &map_idx, bool dynamic, bool steady_dynamic) const
VariableNode::compile(ostream &CompileCode, bool lhs_rhs, const temporary_terms_t &temporary_terms, const map_idx_t &map_idx, bool dynamic, bool steady_dynamic) const
{
if (type == eModelLocalVariable || type == eModFileLocalVariable)
datatree.local_variables_table[symb_id]->compile(CompileCode, lhs_rhs, temporary_terms, map_idx, dynamic, steady_dynamic);
@ -761,10 +761,10 @@ VariableNode::compile(ostream &CompileCode, bool lhs_rhs, const temporary_terms_
void
VariableNode::computeTemporaryTerms(map<NodeID, int> &reference_count,
temporary_terms_type &temporary_terms,
temporary_terms_t &temporary_terms,
map<NodeID, pair<int, int> > &first_occurence,
int Curr_block,
vector<vector<temporary_terms_type> > &v_temporary_terms,
vector<vector<temporary_terms_t> > &v_temporary_terms,
int equation) const
{
if (type == eModelLocalVariable)
@ -1220,10 +1220,10 @@ UnaryOpNode::computeDerivative(int deriv_id)
}
int
UnaryOpNode::cost(const temporary_terms_type &temporary_terms, bool is_matlab) const
UnaryOpNode::cost(const temporary_terms_t &temporary_terms, bool is_matlab) const
{
// For a temporary term, the cost is null
temporary_terms_type::const_iterator it = temporary_terms.find(const_cast<UnaryOpNode *>(this));
temporary_terms_t::const_iterator it = temporary_terms.find(const_cast<UnaryOpNode *>(this));
if (it != temporary_terms.end())
return 0;
@ -1314,7 +1314,7 @@ UnaryOpNode::cost(const temporary_terms_type &temporary_terms, bool is_matlab) c
void
UnaryOpNode::computeTemporaryTerms(map<NodeID, int> &reference_count,
temporary_terms_type &temporary_terms,
temporary_terms_t &temporary_terms,
bool is_matlab) const
{
NodeID this2 = const_cast<UnaryOpNode *>(this);
@ -1335,10 +1335,10 @@ UnaryOpNode::computeTemporaryTerms(map<NodeID, int> &reference_count,
void
UnaryOpNode::computeTemporaryTerms(map<NodeID, int> &reference_count,
temporary_terms_type &temporary_terms,
temporary_terms_t &temporary_terms,
map<NodeID, pair<int, int> > &first_occurence,
int Curr_block,
vector< vector<temporary_terms_type> > &v_temporary_terms,
vector< vector<temporary_terms_t> > &v_temporary_terms,
int equation) const
{
NodeID this2 = const_cast<UnaryOpNode *>(this);
@ -1361,9 +1361,9 @@ UnaryOpNode::computeTemporaryTerms(map<NodeID, int> &reference_count,
}
void
UnaryOpNode::collectTemporary_terms(const temporary_terms_type &temporary_terms, temporary_terms_inuse_type &temporary_terms_inuse, int Curr_Block) const
UnaryOpNode::collectTemporary_terms(const temporary_terms_t &temporary_terms, temporary_terms_inuse_t &temporary_terms_inuse, int Curr_Block) const
{
temporary_terms_type::const_iterator it = temporary_terms.find(const_cast<UnaryOpNode *>(this));
temporary_terms_t::const_iterator it = temporary_terms.find(const_cast<UnaryOpNode *>(this));
if (it != temporary_terms.end())
temporary_terms_inuse.insert(idx);
else
@ -1372,11 +1372,11 @@ UnaryOpNode::collectTemporary_terms(const temporary_terms_type &temporary_terms,
void
UnaryOpNode::writeOutput(ostream &output, ExprNodeOutputType output_type,
const temporary_terms_type &temporary_terms,
deriv_node_temp_terms_type &tef_terms) const
const temporary_terms_t &temporary_terms,
deriv_node_temp_terms_t &tef_terms) const
{
// If node is a temporary term
temporary_terms_type::const_iterator it = temporary_terms.find(const_cast<UnaryOpNode *>(this));
temporary_terms_t::const_iterator it = temporary_terms.find(const_cast<UnaryOpNode *>(this));
if (it != temporary_terms.end())
{
if (output_type == oMatlabDynamicModelSparse)
@ -1502,8 +1502,8 @@ UnaryOpNode::writeOutput(ostream &output, ExprNodeOutputType output_type,
void
UnaryOpNode::writeExternalFunctionOutput(ostream &output, ExprNodeOutputType output_type,
const temporary_terms_type &temporary_terms,
deriv_node_temp_terms_type &tef_terms) const
const temporary_terms_t &temporary_terms,
deriv_node_temp_terms_t &tef_terms) const
{
arg->writeExternalFunctionOutput(output, output_type, temporary_terms, tef_terms);
}
@ -1559,7 +1559,7 @@ UnaryOpNode::eval_opcode(UnaryOpcode op_code, double v) throw (EvalException)
}
double
UnaryOpNode::eval(const eval_context_type &eval_context) const throw (EvalException)
UnaryOpNode::eval(const eval_context_t &eval_context) const throw (EvalException)
{
double v = arg->eval(eval_context);
@ -1567,20 +1567,20 @@ UnaryOpNode::eval(const eval_context_type &eval_context) const throw (EvalExcept
}
void
UnaryOpNode::compile(ostream &CompileCode, bool lhs_rhs, const temporary_terms_type &temporary_terms, const map_idx_type &map_idx, bool dynamic, bool steady_dynamic) const
UnaryOpNode::compile(ostream &CompileCode, bool lhs_rhs, const temporary_terms_t &temporary_terms, const map_idx_t &map_idx, bool dynamic, bool steady_dynamic) const
{
temporary_terms_type::const_iterator it = temporary_terms.find(const_cast<UnaryOpNode *>(this));
temporary_terms_t::const_iterator it = temporary_terms.find(const_cast<UnaryOpNode *>(this));
if (it != temporary_terms.end())
{
if (dynamic)
{
map_idx_type::const_iterator ii = map_idx.find(idx);
map_idx_t::const_iterator ii = map_idx.find(idx);
FLDT_ fldt(ii->second);
fldt.write(CompileCode);
}
else
{
map_idx_type::const_iterator ii = map_idx.find(idx);
map_idx_t::const_iterator ii = map_idx.find(idx);
FLDST_ fldst(ii->second);
fldst.write(CompileCode);
}
@ -2057,9 +2057,9 @@ BinaryOpNode::computeDerivative(int deriv_id)
}
int
BinaryOpNode::precedence(ExprNodeOutputType output_type, const temporary_terms_type &temporary_terms) const
BinaryOpNode::precedence(ExprNodeOutputType output_type, const temporary_terms_t &temporary_terms) const
{
temporary_terms_type::const_iterator it = temporary_terms.find(const_cast<BinaryOpNode *>(this));
temporary_terms_t::const_iterator it = temporary_terms.find(const_cast<BinaryOpNode *>(this));
// A temporary term behaves as a variable
if (it != temporary_terms.end())
return 100;
@ -2097,9 +2097,9 @@ BinaryOpNode::precedence(ExprNodeOutputType output_type, const temporary_terms_t
}
int
BinaryOpNode::cost(const temporary_terms_type &temporary_terms, bool is_matlab) const
BinaryOpNode::cost(const temporary_terms_t &temporary_terms, bool is_matlab) const
{
temporary_terms_type::const_iterator it = temporary_terms.find(const_cast<BinaryOpNode *>(this));
temporary_terms_t::const_iterator it = temporary_terms.find(const_cast<BinaryOpNode *>(this));
// For a temporary term, the cost is null
if (it != temporary_terms.end())
return 0;
@ -2163,7 +2163,7 @@ BinaryOpNode::cost(const temporary_terms_type &temporary_terms, bool is_matlab)
void
BinaryOpNode::computeTemporaryTerms(map<NodeID, int> &reference_count,
temporary_terms_type &temporary_terms,
temporary_terms_t &temporary_terms,
bool is_matlab) const
{
NodeID this2 = const_cast<BinaryOpNode *>(this);
@ -2190,10 +2190,10 @@ BinaryOpNode::computeTemporaryTerms(map<NodeID, int> &reference_count,
void
BinaryOpNode::computeTemporaryTerms(map<NodeID, int> &reference_count,
temporary_terms_type &temporary_terms,
temporary_terms_t &temporary_terms,
map<NodeID, pair<int, int> > &first_occurence,
int Curr_block,
vector<vector<temporary_terms_type> > &v_temporary_terms,
vector<vector<temporary_terms_t> > &v_temporary_terms,
int equation) const
{
NodeID this2 = const_cast<BinaryOpNode *>(this);
@ -2262,7 +2262,7 @@ BinaryOpNode::eval_opcode(double v1, BinaryOpcode op_code, double v2) throw (Eva
}
double
BinaryOpNode::eval(const eval_context_type &eval_context) const throw (EvalException)
BinaryOpNode::eval(const eval_context_t &eval_context) const throw (EvalException)
{
double v1 = arg1->eval(eval_context);
double v2 = arg2->eval(eval_context);
@ -2271,21 +2271,21 @@ BinaryOpNode::eval(const eval_context_type &eval_context) const throw (EvalExcep
}
void
BinaryOpNode::compile(ostream &CompileCode, bool lhs_rhs, const temporary_terms_type &temporary_terms, const map_idx_type &map_idx, bool dynamic, bool steady_dynamic) const
BinaryOpNode::compile(ostream &CompileCode, bool lhs_rhs, const temporary_terms_t &temporary_terms, const map_idx_t &map_idx, bool dynamic, bool steady_dynamic) const
{
// If current node is a temporary term
temporary_terms_type::const_iterator it = temporary_terms.find(const_cast<BinaryOpNode *>(this));
temporary_terms_t::const_iterator it = temporary_terms.find(const_cast<BinaryOpNode *>(this));
if (it != temporary_terms.end())
{
if (dynamic)
{
map_idx_type::const_iterator ii = map_idx.find(idx);
map_idx_t::const_iterator ii = map_idx.find(idx);
FLDT_ fldt(ii->second);
fldt.write(CompileCode);
}
else
{
map_idx_type::const_iterator ii = map_idx.find(idx);
map_idx_t::const_iterator ii = map_idx.find(idx);
FLDST_ fldst(ii->second);
fldst.write(CompileCode);
}
@ -2298,9 +2298,9 @@ BinaryOpNode::compile(ostream &CompileCode, bool lhs_rhs, const temporary_terms_
}
void
BinaryOpNode::collectTemporary_terms(const temporary_terms_type &temporary_terms, temporary_terms_inuse_type &temporary_terms_inuse, int Curr_Block) const
BinaryOpNode::collectTemporary_terms(const temporary_terms_t &temporary_terms, temporary_terms_inuse_t &temporary_terms_inuse, int Curr_Block) const
{
temporary_terms_type::const_iterator it = temporary_terms.find(const_cast<BinaryOpNode *>(this));
temporary_terms_t::const_iterator it = temporary_terms.find(const_cast<BinaryOpNode *>(this));
if (it != temporary_terms.end())
temporary_terms_inuse.insert(idx);
else
@ -2312,11 +2312,11 @@ BinaryOpNode::collectTemporary_terms(const temporary_terms_type &temporary_terms
void
BinaryOpNode::writeOutput(ostream &output, ExprNodeOutputType output_type,
const temporary_terms_type &temporary_terms,
deriv_node_temp_terms_type &tef_terms) const
const temporary_terms_t &temporary_terms,
deriv_node_temp_terms_t &tef_terms) const
{
// If current node is a temporary term
temporary_terms_type::const_iterator it = temporary_terms.find(const_cast<BinaryOpNode *>(this));
temporary_terms_t::const_iterator it = temporary_terms.find(const_cast<BinaryOpNode *>(this));
if (it != temporary_terms.end())
{
if (output_type == oMatlabDynamicModelSparse)
@ -2473,8 +2473,8 @@ BinaryOpNode::writeOutput(ostream &output, ExprNodeOutputType output_type,
void
BinaryOpNode::writeExternalFunctionOutput(ostream &output, ExprNodeOutputType output_type,
const temporary_terms_type &temporary_terms,
deriv_node_temp_terms_type &tef_terms) const
const temporary_terms_t &temporary_terms,
deriv_node_temp_terms_t &tef_terms) const
{
arg1->writeExternalFunctionOutput(output, output_type, temporary_terms, tef_terms);
arg2->writeExternalFunctionOutput(output, output_type, temporary_terms, tef_terms);
@ -2490,7 +2490,7 @@ BinaryOpNode::collectVariables(SymbolType type_arg, set<pair<int, int> > &result
NodeID
BinaryOpNode::Compute_RHS(NodeID arg1, NodeID arg2, int op, int op_type) const
{
temporary_terms_type temp;
temporary_terms_t temp;
switch (op_type)
{
case 0: /*Unary Operator*/
@ -3077,9 +3077,9 @@ TrinaryOpNode::computeDerivative(int deriv_id)
}
int
TrinaryOpNode::precedence(ExprNodeOutputType output_type, const temporary_terms_type &temporary_terms) const
TrinaryOpNode::precedence(ExprNodeOutputType output_type, const temporary_terms_t &temporary_terms) const
{
temporary_terms_type::const_iterator it = temporary_terms.find(const_cast<TrinaryOpNode *>(this));
temporary_terms_t::const_iterator it = temporary_terms.find(const_cast<TrinaryOpNode *>(this));
// A temporary term behaves as a variable
if (it != temporary_terms.end())
return 100;
@ -3095,9 +3095,9 @@ TrinaryOpNode::precedence(ExprNodeOutputType output_type, const temporary_terms_
}
int
TrinaryOpNode::cost(const temporary_terms_type &temporary_terms, bool is_matlab) const
TrinaryOpNode::cost(const temporary_terms_t &temporary_terms, bool is_matlab) const
{
temporary_terms_type::const_iterator it = temporary_terms.find(const_cast<TrinaryOpNode *>(this));
temporary_terms_t::const_iterator it = temporary_terms.find(const_cast<TrinaryOpNode *>(this));
// For a temporary term, the cost is null
if (it != temporary_terms.end())
return 0;
@ -3127,7 +3127,7 @@ TrinaryOpNode::cost(const temporary_terms_type &temporary_terms, bool is_matlab)
void
TrinaryOpNode::computeTemporaryTerms(map<NodeID, int> &reference_count,
temporary_terms_type &temporary_terms,
temporary_terms_t &temporary_terms,
bool is_matlab) const
{
NodeID this2 = const_cast<TrinaryOpNode *>(this);
@ -3153,10 +3153,10 @@ TrinaryOpNode::computeTemporaryTerms(map<NodeID, int> &reference_count,
void
TrinaryOpNode::computeTemporaryTerms(map<NodeID, int> &reference_count,
temporary_terms_type &temporary_terms,
temporary_terms_t &temporary_terms,
map<NodeID, pair<int, int> > &first_occurence,
int Curr_block,
vector<vector<temporary_terms_type> > &v_temporary_terms,
vector<vector<temporary_terms_t> > &v_temporary_terms,
int equation) const
{
NodeID this2 = const_cast<TrinaryOpNode *>(this);
@ -3195,7 +3195,7 @@ TrinaryOpNode::eval_opcode(double v1, TrinaryOpcode op_code, double v2, double v
}
double
TrinaryOpNode::eval(const eval_context_type &eval_context) const throw (EvalException)
TrinaryOpNode::eval(const eval_context_t &eval_context) const throw (EvalException)
{
double v1 = arg1->eval(eval_context);
double v2 = arg2->eval(eval_context);
@ -3205,21 +3205,21 @@ TrinaryOpNode::eval(const eval_context_type &eval_context) const throw (EvalExce
}
void
TrinaryOpNode::compile(ostream &CompileCode, bool lhs_rhs, const temporary_terms_type &temporary_terms, const map_idx_type &map_idx, bool dynamic, bool steady_dynamic) const
TrinaryOpNode::compile(ostream &CompileCode, bool lhs_rhs, const temporary_terms_t &temporary_terms, const map_idx_t &map_idx, bool dynamic, bool steady_dynamic) const
{
// If current node is a temporary term
temporary_terms_type::const_iterator it = temporary_terms.find(const_cast<TrinaryOpNode *>(this));
temporary_terms_t::const_iterator it = temporary_terms.find(const_cast<TrinaryOpNode *>(this));
if (it != temporary_terms.end())
{
if (dynamic)
{
map_idx_type::const_iterator ii = map_idx.find(idx);
map_idx_t::const_iterator ii = map_idx.find(idx);
FLDT_ fldt(ii->second);
fldt.write(CompileCode);
}
else
{
map_idx_type::const_iterator ii = map_idx.find(idx);
map_idx_t::const_iterator ii = map_idx.find(idx);
FLDST_ fldst(ii->second);
fldst.write(CompileCode);
}
@ -3233,9 +3233,9 @@ TrinaryOpNode::compile(ostream &CompileCode, bool lhs_rhs, const temporary_terms
}
void
TrinaryOpNode::collectTemporary_terms(const temporary_terms_type &temporary_terms, temporary_terms_inuse_type &temporary_terms_inuse, int Curr_Block) const
TrinaryOpNode::collectTemporary_terms(const temporary_terms_t &temporary_terms, temporary_terms_inuse_t &temporary_terms_inuse, int Curr_Block) const
{
temporary_terms_type::const_iterator it = temporary_terms.find(const_cast<TrinaryOpNode *>(this));
temporary_terms_t::const_iterator it = temporary_terms.find(const_cast<TrinaryOpNode *>(this));
if (it != temporary_terms.end())
temporary_terms_inuse.insert(idx);
else
@ -3248,11 +3248,11 @@ TrinaryOpNode::collectTemporary_terms(const temporary_terms_type &temporary_term
void
TrinaryOpNode::writeOutput(ostream &output, ExprNodeOutputType output_type,
const temporary_terms_type &temporary_terms,
deriv_node_temp_terms_type &tef_terms) const
const temporary_terms_t &temporary_terms,
deriv_node_temp_terms_t &tef_terms) const
{
// If current node is a temporary term
temporary_terms_type::const_iterator it = temporary_terms.find(const_cast<TrinaryOpNode *>(this));
temporary_terms_t::const_iterator it = temporary_terms.find(const_cast<TrinaryOpNode *>(this));
if (it != temporary_terms.end())
{
output << "T" << idx;
@ -3316,8 +3316,8 @@ TrinaryOpNode::writeOutput(ostream &output, ExprNodeOutputType output_type,
void
TrinaryOpNode::writeExternalFunctionOutput(ostream &output, ExprNodeOutputType output_type,
const temporary_terms_type &temporary_terms,
deriv_node_temp_terms_type &tef_terms) const
const temporary_terms_t &temporary_terms,
deriv_node_temp_terms_t &tef_terms) const
{
arg1->writeExternalFunctionOutput(output, output_type, temporary_terms, tef_terms);
arg2->writeExternalFunctionOutput(output, output_type, temporary_terms, tef_terms);
@ -3546,7 +3546,7 @@ ExternalFunctionNode::getChainRuleDerivative(int deriv_id, const map<int, NodeID
void
ExternalFunctionNode::computeTemporaryTerms(map<NodeID, int> &reference_count,
temporary_terms_type &temporary_terms,
temporary_terms_t &temporary_terms,
bool is_matlab) const
{
temporary_terms.insert(const_cast<ExternalFunctionNode *>(this));
@ -3554,8 +3554,8 @@ ExternalFunctionNode::computeTemporaryTerms(map<NodeID, int> &reference_count,
void
ExternalFunctionNode::writeExternalFunctionArguments(ostream &output, ExprNodeOutputType output_type,
const temporary_terms_type &temporary_terms,
deriv_node_temp_terms_type &tef_terms) const
const temporary_terms_t &temporary_terms,
deriv_node_temp_terms_t &tef_terms) const
{
for (vector<NodeID>::const_iterator it = arguments.begin();
it != arguments.end(); it++)
@ -3569,8 +3569,8 @@ ExternalFunctionNode::writeExternalFunctionArguments(ostream &output, ExprNodeOu
void
ExternalFunctionNode::writeOutput(ostream &output, ExprNodeOutputType output_type,
const temporary_terms_type &temporary_terms,
deriv_node_temp_terms_type &tef_terms) const
const temporary_terms_t &temporary_terms,
deriv_node_temp_terms_t &tef_terms) const
{
if (output_type == oMatlabOutsideModel)
{
@ -3580,7 +3580,7 @@ ExternalFunctionNode::writeOutput(ostream &output, ExprNodeOutputType output_typ
return;
}
temporary_terms_type::const_iterator it = temporary_terms.find(const_cast<ExternalFunctionNode *>(this));
temporary_terms_t::const_iterator it = temporary_terms.find(const_cast<ExternalFunctionNode *>(this));
if (it != temporary_terms.end())
{
if (output_type == oMatlabDynamicModelSparse)
@ -3595,8 +3595,8 @@ ExternalFunctionNode::writeOutput(ostream &output, ExprNodeOutputType output_typ
void
ExternalFunctionNode::writeExternalFunctionOutput(ostream &output, ExprNodeOutputType output_type,
const temporary_terms_type &temporary_terms,
deriv_node_temp_terms_type &tef_terms) const
const temporary_terms_t &temporary_terms,
deriv_node_temp_terms_t &tef_terms) const
{
int first_deriv_symb_id = datatree.external_functions_table.getFirstDerivSymbID(symb_id);
assert(first_deriv_symb_id != eExtFunSetButNoNameProvided);
@ -3628,10 +3628,10 @@ ExternalFunctionNode::writeExternalFunctionOutput(ostream &output, ExprNodeOutpu
void
ExternalFunctionNode::computeTemporaryTerms(map<NodeID, int> &reference_count,
temporary_terms_type &temporary_terms,
temporary_terms_t &temporary_terms,
map<NodeID, pair<int, int> > &first_occurence,
int Curr_block,
vector< vector<temporary_terms_type> > &v_temporary_terms,
vector< vector<temporary_terms_t> > &v_temporary_terms,
int equation) const
{
cerr << "ExternalFunctionNode::computeTemporaryTerms: not implemented" << endl;
@ -3647,9 +3647,9 @@ ExternalFunctionNode::collectVariables(SymbolType type_arg, set<pair<int, int> >
}
void
ExternalFunctionNode::collectTemporary_terms(const temporary_terms_type &temporary_terms, temporary_terms_inuse_type &temporary_terms_inuse, int Curr_Block) const
ExternalFunctionNode::collectTemporary_terms(const temporary_terms_t &temporary_terms, temporary_terms_inuse_t &temporary_terms_inuse, int Curr_Block) const
{
temporary_terms_type::const_iterator it = temporary_terms.find(const_cast<ExternalFunctionNode *>(this));
temporary_terms_t::const_iterator it = temporary_terms.find(const_cast<ExternalFunctionNode *>(this));
if (it != temporary_terms.end())
temporary_terms_inuse.insert(idx);
else
@ -3659,13 +3659,13 @@ ExternalFunctionNode::collectTemporary_terms(const temporary_terms_type &tempora
}
double
ExternalFunctionNode::eval(const eval_context_type &eval_context) const throw (EvalException)
ExternalFunctionNode::eval(const eval_context_t &eval_context) const throw (EvalException)
{
throw EvalException();
}
void
ExternalFunctionNode::compile(ostream &CompileCode, bool lhs_rhs, const temporary_terms_type &temporary_terms, const map_idx_type &map_idx, bool dynamic, bool steady_dynamic) const
ExternalFunctionNode::compile(ostream &CompileCode, bool lhs_rhs, const temporary_terms_t &temporary_terms, const map_idx_t &map_idx, bool dynamic, bool steady_dynamic) const
{
cerr << "ExternalFunctionNode::compile: operation impossible!" << endl;
exit(EXIT_FAILURE);
@ -3810,18 +3810,18 @@ ExternalFunctionNode::buildSimilarExternalFunctionNode(vector<NodeID> &alt_args,
}
bool
ExternalFunctionNode::alreadyWrittenAsTefTerm(int the_symb_id, deriv_node_temp_terms_type &tef_terms) const
ExternalFunctionNode::alreadyWrittenAsTefTerm(int the_symb_id, deriv_node_temp_terms_t &tef_terms) const
{
deriv_node_temp_terms_type::const_iterator it = tef_terms.find(make_pair(the_symb_id, arguments));
deriv_node_temp_terms_t::const_iterator it = tef_terms.find(make_pair(the_symb_id, arguments));
if (it != tef_terms.end())
return true;
return false;
}
int
ExternalFunctionNode::getIndxInTefTerms(int the_symb_id, deriv_node_temp_terms_type &tef_terms) const throw (UnknownFunctionNameAndArgs)
ExternalFunctionNode::getIndxInTefTerms(int the_symb_id, deriv_node_temp_terms_t &tef_terms) const throw (UnknownFunctionNameAndArgs)
{
deriv_node_temp_terms_type::const_iterator it = tef_terms.find(make_pair(the_symb_id, arguments));
deriv_node_temp_terms_t::const_iterator it = tef_terms.find(make_pair(the_symb_id, arguments));
if (it != tef_terms.end())
return it->second;
throw UnknownFunctionNameAndArgs();
@ -3852,7 +3852,7 @@ FirstDerivExternalFunctionNode::FirstDerivExternalFunctionNode(DataTree &datatre
void
FirstDerivExternalFunctionNode::computeTemporaryTerms(map<NodeID, int> &reference_count,
temporary_terms_type &temporary_terms,
temporary_terms_t &temporary_terms,
bool is_matlab) const
{
temporary_terms.insert(const_cast<FirstDerivExternalFunctionNode *>(this));
@ -3860,10 +3860,10 @@ FirstDerivExternalFunctionNode::computeTemporaryTerms(map<NodeID, int> &referenc
void
FirstDerivExternalFunctionNode::computeTemporaryTerms(map<NodeID, int> &reference_count,
temporary_terms_type &temporary_terms,
temporary_terms_t &temporary_terms,
map<NodeID, pair<int, int> > &first_occurence,
int Curr_block,
vector< vector<temporary_terms_type> > &v_temporary_terms,
vector< vector<temporary_terms_t> > &v_temporary_terms,
int equation) const
{
cerr << "FirstDerivExternalFunctionNode::computeTemporaryTerms: not implemented" << endl;
@ -3886,13 +3886,13 @@ FirstDerivExternalFunctionNode::composeDerivatives(const vector<NodeID> &dargs)
void
FirstDerivExternalFunctionNode::writeOutput(ostream &output, ExprNodeOutputType output_type,
const temporary_terms_type &temporary_terms,
deriv_node_temp_terms_type &tef_terms) const
const temporary_terms_t &temporary_terms,
deriv_node_temp_terms_t &tef_terms) const
{
assert(output_type != oMatlabOutsideModel);
// If current node is a temporary term
temporary_terms_type::const_iterator it = temporary_terms.find(const_cast<FirstDerivExternalFunctionNode *>(this));
temporary_terms_t::const_iterator it = temporary_terms.find(const_cast<FirstDerivExternalFunctionNode *>(this));
if (it != temporary_terms.end())
{
if (output_type == oMatlabDynamicModelSparse)
@ -3916,8 +3916,8 @@ FirstDerivExternalFunctionNode::writeOutput(ostream &output, ExprNodeOutputType
void
FirstDerivExternalFunctionNode::writeExternalFunctionOutput(ostream &output, ExprNodeOutputType output_type,
const temporary_terms_type &temporary_terms,
deriv_node_temp_terms_type &tef_terms) const
const temporary_terms_t &temporary_terms,
deriv_node_temp_terms_t &tef_terms) const
{
assert(output_type != oMatlabOutsideModel);
int first_deriv_symb_id = datatree.external_functions_table.getFirstDerivSymbID(symb_id);
@ -3960,7 +3960,7 @@ SecondDerivExternalFunctionNode::SecondDerivExternalFunctionNode(DataTree &datat
void
SecondDerivExternalFunctionNode::computeTemporaryTerms(map<NodeID, int> &reference_count,
temporary_terms_type &temporary_terms,
temporary_terms_t &temporary_terms,
bool is_matlab) const
{
temporary_terms.insert(const_cast<SecondDerivExternalFunctionNode *>(this));
@ -3968,10 +3968,10 @@ SecondDerivExternalFunctionNode::computeTemporaryTerms(map<NodeID, int> &referen
void
SecondDerivExternalFunctionNode::computeTemporaryTerms(map<NodeID, int> &reference_count,
temporary_terms_type &temporary_terms,
temporary_terms_t &temporary_terms,
map<NodeID, pair<int, int> > &first_occurence,
int Curr_block,
vector< vector<temporary_terms_type> > &v_temporary_terms,
vector< vector<temporary_terms_t> > &v_temporary_terms,
int equation) const
{
cerr << "SecondDerivExternalFunctionNode::computeTemporaryTerms: not implemented" << endl;
@ -3987,13 +3987,13 @@ SecondDerivExternalFunctionNode::computeDerivative(int deriv_id)
void
SecondDerivExternalFunctionNode::writeOutput(ostream &output, ExprNodeOutputType output_type,
const temporary_terms_type &temporary_terms,
deriv_node_temp_terms_type &tef_terms) const
const temporary_terms_t &temporary_terms,
deriv_node_temp_terms_t &tef_terms) const
{
assert(output_type != oMatlabOutsideModel);
// If current node is a temporary term
temporary_terms_type::const_iterator it = temporary_terms.find(const_cast<SecondDerivExternalFunctionNode *>(this));
temporary_terms_t::const_iterator it = temporary_terms.find(const_cast<SecondDerivExternalFunctionNode *>(this));
if (it != temporary_terms.end())
{
if (output_type == oMatlabDynamicModelSparse)
@ -4017,8 +4017,8 @@ SecondDerivExternalFunctionNode::writeOutput(ostream &output, ExprNodeOutputType
void
SecondDerivExternalFunctionNode::writeExternalFunctionOutput(ostream &output, ExprNodeOutputType output_type,
const temporary_terms_type &temporary_terms,
deriv_node_temp_terms_type &tef_terms) const
const temporary_terms_t &temporary_terms,
deriv_node_temp_terms_t &tef_terms) const
{
assert(output_type != oMatlabOutsideModel);
int second_deriv_symb_id = datatree.external_functions_table.getSecondDerivSymbID(symb_id);

166
ExprNode.hh
View File

@ -43,19 +43,19 @@ struct ExprNodeLess;
//! Type for set of temporary terms
/*! They are ordered by index number thanks to ExprNodeLess */
typedef set<NodeID, ExprNodeLess> temporary_terms_type;
typedef set<NodeID, ExprNodeLess> temporary_terms_t;
//! set of temporary terms used in a block
typedef set<int> temporary_terms_inuse_type;
typedef set<int> temporary_terms_inuse_t;
typedef map<int, int> map_idx_type;
typedef map<int, int> map_idx_t;
//! Type for evaluation contexts
/*! The key is a symbol id. Lags are assumed to be null */
typedef map<int, double> eval_context_type;
typedef map<int, double> eval_context_t;
//! Type for tracking first/second derivative functions that have already been written as temporary terms
typedef map<pair<int, vector<NodeID> >, int> deriv_node_temp_terms_type;
typedef map<pair<int, vector<NodeID> >, int> deriv_node_temp_terms_t;
//! Possible types of output when writing ExprNode(s)
enum ExprNodeOutputType
@ -143,7 +143,7 @@ protected:
//! Cost of computing current node
/*! Nodes included in temporary_terms are considered having a null cost */
virtual int cost(const temporary_terms_type &temporary_terms, bool is_matlab) const;
virtual int cost(const temporary_terms_t &temporary_terms, bool is_matlab) const;
public:
ExprNode(DataTree &datatree_arg);
@ -166,11 +166,11 @@ public:
//! Returns precedence of node
/*! Equals 100 for constants, variables, unary ops, and temporary terms */
virtual int precedence(ExprNodeOutputType output_type, const temporary_terms_type &temporary_terms) const;
virtual int precedence(ExprNodeOutputType output_t, const temporary_terms_t &temporary_terms) const;
//! Fills temporary_terms set, using reference counts
/*! A node will be marked as a temporary term if it is referenced at least two times (i.e. has at least two parents), and has a computing cost (multiplied by reference count) greater to datatree.min_cost */
virtual void computeTemporaryTerms(map<NodeID, int> &reference_count, temporary_terms_type &temporary_terms, bool is_matlab) const;
virtual void computeTemporaryTerms(map<NodeID, int> &reference_count, temporary_terms_t &temporary_terms, bool is_matlab) const;
//! Writes output of node, using a Txxx notation for nodes in temporary_terms, and specifiying the set of already written external functions
/*!
@ -179,7 +179,7 @@ public:
\param[in] temporary_terms the nodes that are marked as temporary terms
\param[in,out] tef_terms the set of already written external function nodes
*/
virtual void writeOutput(ostream &output, ExprNodeOutputType output_type, const temporary_terms_type &temporary_terms, deriv_node_temp_terms_type &tef_terms) const = 0;
virtual void writeOutput(ostream &output, ExprNodeOutputType output_type, const temporary_terms_t &temporary_terms, deriv_node_temp_terms_t &tef_terms) const = 0;
//! Writes output of node (with no temporary terms and with "outside model" output type)
void writeOutput(ostream &output) const;
@ -188,12 +188,12 @@ public:
void writeOutput(ostream &output, ExprNodeOutputType output_type) const;
//! Writes output of node, using a Txxx notation for nodes in temporary_terms
void writeOutput(ostream &output, ExprNodeOutputType output_type, const temporary_terms_type &temporary_terms) const;
void writeOutput(ostream &output, ExprNodeOutputType output_type, const temporary_terms_t &temporary_terms) const;
//! Writes the output for an external function, ensuring that the external function is called as few times as possible using temporary terms
virtual void writeExternalFunctionOutput(ostream &output, ExprNodeOutputType output_type,
const temporary_terms_type &temporary_terms,
deriv_node_temp_terms_type &tef_terms) const;
const temporary_terms_t &temporary_terms,
deriv_node_temp_terms_t &tef_terms) const;
//! Computes the set of all variables of a given symbol type in the expression
/*!
@ -227,12 +227,12 @@ public:
*/
virtual void collectModelLocalVariables(set<int> &result) const;
virtual void collectTemporary_terms(const temporary_terms_type &temporary_terms, temporary_terms_inuse_type &temporary_terms_inuse, int Curr_Block) const = 0;
virtual void collectTemporary_terms(const temporary_terms_t &temporary_terms, temporary_terms_inuse_t &temporary_terms_inuse, int Curr_Block) const = 0;
virtual void computeTemporaryTerms(map<NodeID, int> &reference_count,
temporary_terms_type &temporary_terms,
temporary_terms_t &temporary_terms,
map<NodeID, pair<int, int> > &first_occurence,
int Curr_block,
vector< vector<temporary_terms_type> > &v_temporary_terms,
vector< vector<temporary_terms_t> > &v_temporary_terms,
int equation) const;
class EvalException
@ -240,8 +240,8 @@ public:
{
};
virtual double eval(const eval_context_type &eval_context) const throw (EvalException) = 0;
virtual void compile(ostream &CompileCode, bool lhs_rhs, const temporary_terms_type &temporary_terms, const map_idx_type &map_idx, bool dynamic, bool steady_dynamic) const = 0;
virtual double eval(const eval_context_t &eval_context) const throw (EvalException) = 0;
virtual void compile(ostream &CompileCode, bool lhs_rhs, const temporary_terms_t &temporary_terms, const map_idx_t &map_idx, bool dynamic, bool steady_dynamic) const = 0;
//! Creates a static version of this node
/*!
This method duplicates the current node by creating a similar node from which all leads/lags have been stripped,
@ -383,11 +383,11 @@ public:
return id;
};
virtual void prepareForDerivation();
virtual void writeOutput(ostream &output, ExprNodeOutputType output_type, const temporary_terms_type &temporary_terms, deriv_node_temp_terms_type &tef_terms) const;
virtual void writeOutput(ostream &output, ExprNodeOutputType output_type, const temporary_terms_t &temporary_terms, deriv_node_temp_terms_t &tef_terms) const;
virtual void collectVariables(SymbolType type_arg, set<pair<int, int> > &result) const;
virtual void collectTemporary_terms(const temporary_terms_type &temporary_terms, temporary_terms_inuse_type &temporary_terms_inuse, int Curr_Block) const;
virtual double eval(const eval_context_type &eval_context) const throw (EvalException);
virtual void compile(ostream &CompileCode, bool lhs_rhs, const temporary_terms_type &temporary_terms, const map_idx_type &map_idx, bool dynamic, bool steady_dynamic) const;
virtual void collectTemporary_terms(const temporary_terms_t &temporary_terms, temporary_terms_inuse_t &temporary_terms_inuse, int Curr_Block) const;
virtual double eval(const eval_context_t &eval_context) const throw (EvalException);
virtual void compile(ostream &CompileCode, bool lhs_rhs, const temporary_terms_t &temporary_terms, const map_idx_t &map_idx, bool dynamic, bool steady_dynamic) const;
virtual NodeID toStatic(DataTree &static_datatree) const;
virtual pair<int, NodeID> normalizeEquation(int symb_id_endo, vector<pair<int, pair<NodeID, NodeID> > > &List_of_Op_RHS) const;
virtual NodeID getChainRuleDerivative(int deriv_id, const map<int, NodeID> &recursive_variables);
@ -419,17 +419,17 @@ private:
public:
VariableNode(DataTree &datatree_arg, int symb_id_arg, int lag_arg);
virtual void prepareForDerivation();
virtual void writeOutput(ostream &output, ExprNodeOutputType output_type, const temporary_terms_type &temporary_terms, deriv_node_temp_terms_type &tef_terms) const;
virtual void writeOutput(ostream &output, ExprNodeOutputType output_type, const temporary_terms_t &temporary_terms, deriv_node_temp_terms_t &tef_terms) const;
virtual void collectVariables(SymbolType type_arg, set<pair<int, int> > &result) const;
virtual void computeTemporaryTerms(map<NodeID, int> &reference_count,
temporary_terms_type &temporary_terms,
temporary_terms_t &temporary_terms,
map<NodeID, pair<int, int> > &first_occurence,
int Curr_block,
vector< vector<temporary_terms_type> > &v_temporary_terms,
vector< vector<temporary_terms_t> > &v_temporary_terms,
int equation) const;
virtual void collectTemporary_terms(const temporary_terms_type &temporary_terms, temporary_terms_inuse_type &temporary_terms_inuse, int Curr_Block) const;
virtual double eval(const eval_context_type &eval_context) const throw (EvalException);
virtual void compile(ostream &CompileCode, bool lhs_rhs, const temporary_terms_type &temporary_terms, const map_idx_type &map_idx, bool dynamic, bool steady_dynamic) const;
virtual void collectTemporary_terms(const temporary_terms_t &temporary_terms, temporary_terms_inuse_t &temporary_terms_inuse, int Curr_Block) const;
virtual double eval(const eval_context_t &eval_context) const throw (EvalException);
virtual void compile(ostream &CompileCode, bool lhs_rhs, const temporary_terms_t &temporary_terms, const map_idx_t &map_idx, bool dynamic, bool steady_dynamic) const;
virtual NodeID toStatic(DataTree &static_datatree) const;
int
get_symb_id() const
@ -465,28 +465,28 @@ private:
const string expectation_information_set_name;
const UnaryOpcode op_code;
virtual NodeID computeDerivative(int deriv_id);
virtual int cost(const temporary_terms_type &temporary_terms, bool is_matlab) const;
virtual int cost(const temporary_terms_t &temporary_terms, bool is_matlab) const;
//! Returns the derivative of this node if darg is the derivative of the argument
NodeID composeDerivatives(NodeID darg);
public:
UnaryOpNode(DataTree &datatree_arg, UnaryOpcode op_code_arg, const NodeID arg_arg, const int expectation_information_set_arg, const string &expectation_information_set_name_arg);
virtual void prepareForDerivation();
virtual void computeTemporaryTerms(map<NodeID, int> &reference_count, temporary_terms_type &temporary_terms, bool is_matlab) const;
virtual void writeOutput(ostream &output, ExprNodeOutputType output_type, const temporary_terms_type &temporary_terms, deriv_node_temp_terms_type &tef_terms) const;
virtual void computeTemporaryTerms(map<NodeID, int> &reference_count, temporary_terms_t &temporary_terms, bool is_matlab) const;
virtual void writeOutput(ostream &output, ExprNodeOutputType output_type, const temporary_terms_t &temporary_terms, deriv_node_temp_terms_t &tef_terms) const;
virtual void writeExternalFunctionOutput(ostream &output, ExprNodeOutputType output_type,
const temporary_terms_type &temporary_terms,
deriv_node_temp_terms_type &tef_terms) const;
const temporary_terms_t &temporary_terms,
deriv_node_temp_terms_t &tef_terms) const;
virtual void computeTemporaryTerms(map<NodeID, int> &reference_count,
temporary_terms_type &temporary_terms,
temporary_terms_t &temporary_terms,
map<NodeID, pair<int, int> > &first_occurence,
int Curr_block,
vector< vector<temporary_terms_type> > &v_temporary_terms,
vector< vector<temporary_terms_t> > &v_temporary_terms,
int equation) const;
virtual void collectVariables(SymbolType type_arg, set<pair<int, int> > &result) const;
virtual void collectTemporary_terms(const temporary_terms_type &temporary_terms, temporary_terms_inuse_type &temporary_terms_inuse, int Curr_Block) const;
virtual void collectTemporary_terms(const temporary_terms_t &temporary_terms, temporary_terms_inuse_t &temporary_terms_inuse, int Curr_Block) const;
static double eval_opcode(UnaryOpcode op_code, double v) throw (EvalException);
virtual double eval(const eval_context_type &eval_context) const throw (EvalException);
virtual void compile(ostream &CompileCode, bool lhs_rhs, const temporary_terms_type &temporary_terms, const map_idx_type &map_idx, bool dynamic, bool steady_dynamic) const;
virtual double eval(const eval_context_t &eval_context) const throw (EvalException);
virtual void compile(ostream &CompileCode, bool lhs_rhs, const temporary_terms_t &temporary_terms, const map_idx_t &map_idx, bool dynamic, bool steady_dynamic) const;
//! Returns operand
NodeID
get_arg() const
@ -526,30 +526,30 @@ private:
const NodeID arg1, arg2;
const BinaryOpcode op_code;
virtual NodeID computeDerivative(int deriv_id);
virtual int cost(const temporary_terms_type &temporary_terms, bool is_matlab) const;
virtual int cost(const temporary_terms_t &temporary_terms, bool is_matlab) const;
//! Returns the derivative of this node if darg1 and darg2 are the derivatives of the arguments
NodeID composeDerivatives(NodeID darg1, NodeID darg2);
public:
BinaryOpNode(DataTree &datatree_arg, const NodeID arg1_arg,
BinaryOpcode op_code_arg, const NodeID arg2_arg);
virtual void prepareForDerivation();
virtual int precedence(ExprNodeOutputType output_type, const temporary_terms_type &temporary_terms) const;
virtual void computeTemporaryTerms(map<NodeID, int> &reference_count, temporary_terms_type &temporary_terms, bool is_matlab) const;
virtual void writeOutput(ostream &output, ExprNodeOutputType output_type, const temporary_terms_type &temporary_terms, deriv_node_temp_terms_type &tef_terms) const;
virtual int precedence(ExprNodeOutputType output_type, const temporary_terms_t &temporary_terms) const;
virtual void computeTemporaryTerms(map<NodeID, int> &reference_count, temporary_terms_t &temporary_terms, bool is_matlab) const;
virtual void writeOutput(ostream &output, ExprNodeOutputType output_type, const temporary_terms_t &temporary_terms, deriv_node_temp_terms_t &tef_terms) const;
virtual void writeExternalFunctionOutput(ostream &output, ExprNodeOutputType output_type,
const temporary_terms_type &temporary_terms,
deriv_node_temp_terms_type &tef_terms) const;
const temporary_terms_t &temporary_terms,
deriv_node_temp_terms_t &tef_terms) const;
virtual void computeTemporaryTerms(map<NodeID, int> &reference_count,
temporary_terms_type &temporary_terms,
temporary_terms_t &temporary_terms,
map<NodeID, pair<int, int> > &first_occurence,
int Curr_block,
vector< vector<temporary_terms_type> > &v_temporary_terms,
vector< vector<temporary_terms_t> > &v_temporary_terms,
int equation) const;
virtual void collectVariables(SymbolType type_arg, set<pair<int, int> > &result) const;
virtual void collectTemporary_terms(const temporary_terms_type &temporary_terms, temporary_terms_inuse_type &temporary_terms_inuse, int Curr_Block) const;
virtual void collectTemporary_terms(const temporary_terms_t &temporary_terms, temporary_terms_inuse_t &temporary_terms_inuse, int Curr_Block) const;
static double eval_opcode(double v1, BinaryOpcode op_code, double v2) throw (EvalException);
virtual double eval(const eval_context_type &eval_context) const throw (EvalException);
virtual void compile(ostream &CompileCode, bool lhs_rhs, const temporary_terms_type &temporary_terms, const map_idx_type &map_idx, bool dynamic, bool steady_dynamic) const;
virtual double eval(const eval_context_t &eval_context) const throw (EvalException);
virtual void compile(ostream &CompileCode, bool lhs_rhs, const temporary_terms_t &temporary_terms, const map_idx_t &map_idx, bool dynamic, bool steady_dynamic) const;
virtual NodeID Compute_RHS(NodeID arg1, NodeID arg2, int op, int op_type) const;
//! Returns first operand
NodeID
@ -597,30 +597,30 @@ private:
const NodeID arg1, arg2, arg3;
const TrinaryOpcode op_code;
virtual NodeID computeDerivative(int deriv_id);
virtual int cost(const temporary_terms_type &temporary_terms, bool is_matlab) const;
virtual int cost(const temporary_terms_t &temporary_terms, bool is_matlab) const;
//! Returns the derivative of this node if darg1, darg2 and darg3 are the derivatives of the arguments
NodeID composeDerivatives(NodeID darg1, NodeID darg2, NodeID darg3);
public:
TrinaryOpNode(DataTree &datatree_arg, const NodeID arg1_arg,
TrinaryOpcode op_code_arg, const NodeID arg2_arg, const NodeID arg3_arg);
virtual void prepareForDerivation();
virtual int precedence(ExprNodeOutputType output_type, const temporary_terms_type &temporary_terms) const;
virtual void computeTemporaryTerms(map<NodeID, int> &reference_count, temporary_terms_type &temporary_terms, bool is_matlab) const;
virtual void writeOutput(ostream &output, ExprNodeOutputType output_type, const temporary_terms_type &temporary_terms, deriv_node_temp_terms_type &tef_terms) const;
virtual int precedence(ExprNodeOutputType output_type, const temporary_terms_t &temporary_terms) const;
virtual void computeTemporaryTerms(map<NodeID, int> &reference_count, temporary_terms_t &temporary_terms, bool is_matlab) const;
virtual void writeOutput(ostream &output, ExprNodeOutputType output_type, const temporary_terms_t &temporary_terms, deriv_node_temp_terms_t &tef_terms) const;
virtual void writeExternalFunctionOutput(ostream &output, ExprNodeOutputType output_type,
const temporary_terms_type &temporary_terms,
deriv_node_temp_terms_type &tef_terms) const;
const temporary_terms_t &temporary_terms,
deriv_node_temp_terms_t &tef_terms) const;
virtual void computeTemporaryTerms(map<NodeID, int> &reference_count,
temporary_terms_type &temporary_terms,
temporary_terms_t &temporary_terms,
map<NodeID, pair<int, int> > &first_occurence,
int Curr_block,
vector< vector<temporary_terms_type> > &v_temporary_terms,
vector< vector<temporary_terms_t> > &v_temporary_terms,
int equation) const;
virtual void collectVariables(SymbolType type_arg, set<pair<int, int> > &result) const;
virtual void collectTemporary_terms(const temporary_terms_type &temporary_terms, temporary_terms_inuse_type &temporary_terms_inuse, int Curr_Block) const;
virtual void collectTemporary_terms(const temporary_terms_t &temporary_terms, temporary_terms_inuse_t &temporary_terms_inuse, int Curr_Block) const;
static double eval_opcode(double v1, TrinaryOpcode op_code, double v2, double v3) throw (EvalException);
virtual double eval(const eval_context_type &eval_context) const throw (EvalException);
virtual void compile(ostream &CompileCode, bool lhs_rhs, const temporary_terms_type &temporary_terms, const map_idx_type &map_idx, bool dynamic, bool steady_dynamic) const;
virtual double eval(const eval_context_t &eval_context) const throw (EvalException);
virtual void compile(ostream &CompileCode, bool lhs_rhs, const temporary_terms_t &temporary_terms, const map_idx_t &map_idx, bool dynamic, bool steady_dynamic) const;
virtual NodeID toStatic(DataTree &static_datatree) const;
virtual pair<int, NodeID> normalizeEquation(int symb_id_endo, vector<pair<int, pair<NodeID, NodeID> > > &List_of_Op_RHS) const;
virtual NodeID getChainRuleDerivative(int deriv_id, const map<int, NodeID> &recursive_variables);
@ -655,30 +655,30 @@ protected:
const int symb_id;
const vector<NodeID> arguments;
//! Returns true if the given external function has been written as a temporary term
bool alreadyWrittenAsTefTerm(int the_symb_id, deriv_node_temp_terms_type &tef_terms) const;
bool alreadyWrittenAsTefTerm(int the_symb_id, deriv_node_temp_terms_t &tef_terms) const;
//! Returns the index in the tef_terms map of this external function
int getIndxInTefTerms(int the_symb_id, deriv_node_temp_terms_type &tef_terms) const throw (UnknownFunctionNameAndArgs);
int getIndxInTefTerms(int the_symb_id, deriv_node_temp_terms_t &tef_terms) const throw (UnknownFunctionNameAndArgs);
//! Helper function to write output arguments of any given external function
void writeExternalFunctionArguments(ostream &output, ExprNodeOutputType output_type, const temporary_terms_type &temporary_terms, deriv_node_temp_terms_type &tef_terms) const;
void writeExternalFunctionArguments(ostream &output, ExprNodeOutputType output_type, const temporary_terms_t &temporary_terms, deriv_node_temp_terms_t &tef_terms) const;
public:
ExternalFunctionNode(DataTree &datatree_arg, int symb_id_arg,
const vector<NodeID> &arguments_arg);
virtual void prepareForDerivation();
virtual void computeTemporaryTerms(map<NodeID, int> &reference_count, temporary_terms_type &temporary_terms, bool is_matlab) const;
virtual void writeOutput(ostream &output, ExprNodeOutputType output_type, const temporary_terms_type &temporary_terms, deriv_node_temp_terms_type &tef_terms) const;
virtual void computeTemporaryTerms(map<NodeID, int> &reference_count, temporary_terms_t &temporary_terms, bool is_matlab) const;
virtual void writeOutput(ostream &output, ExprNodeOutputType output_type, const temporary_terms_t &temporary_terms, deriv_node_temp_terms_t &tef_terms) const;
virtual void writeExternalFunctionOutput(ostream &output, ExprNodeOutputType output_type,
const temporary_terms_type &temporary_terms,
deriv_node_temp_terms_type &tef_terms) const;
const temporary_terms_t &temporary_terms,
deriv_node_temp_terms_t &tef_terms) const;
virtual void computeTemporaryTerms(map<NodeID, int> &reference_count,
temporary_terms_type &temporary_terms,
temporary_terms_t &temporary_terms,
map<NodeID, pair<int, int> > &first_occurence,
int Curr_block,
vector< vector<temporary_terms_type> > &v_temporary_terms,
vector< vector<temporary_terms_t> > &v_temporary_terms,
int equation) const;
virtual void collectVariables(SymbolType type_arg, set<pair<int, int> > &result) const;
virtual void collectTemporary_terms(const temporary_terms_type &temporary_terms, temporary_terms_inuse_type &temporary_terms_inuse, int Curr_Block) const;
virtual double eval(const eval_context_type &eval_context) const throw (EvalException);
virtual void compile(ostream &CompileCode, bool lhs_rhs, const temporary_terms_type &temporary_terms, const map_idx_type &map_idx, bool dynamic, bool steady_dynamic) const;
virtual void collectTemporary_terms(const temporary_terms_t &temporary_terms, temporary_terms_inuse_t &temporary_terms_inuse, int Curr_Block) const;
virtual double eval(const eval_context_t &eval_context) const throw (EvalException);
virtual void compile(ostream &CompileCode, bool lhs_rhs, const temporary_terms_t &temporary_terms, const map_idx_t &map_idx, bool dynamic, bool steady_dynamic) const;
virtual NodeID toStatic(DataTree &static_datatree) const;
virtual pair<int, NodeID> normalizeEquation(int symb_id_endo, vector<pair<int, pair<NodeID, NodeID> > > &List_of_Op_RHS) const;
virtual NodeID getChainRuleDerivative(int deriv_id, const map<int, NodeID> &recursive_variables);
@ -708,17 +708,17 @@ public:
int top_level_symb_id_arg,
const vector<NodeID> &arguments_arg,
int inputIndex_arg);
virtual void computeTemporaryTerms(map<NodeID, int> &reference_count, temporary_terms_type &temporary_terms, bool is_matlab) const;
virtual void computeTemporaryTerms(map<NodeID, int> &reference_count, temporary_terms_t &temporary_terms, bool is_matlab) const;
virtual void computeTemporaryTerms(map<NodeID, int> &reference_count,
temporary_terms_type &temporary_terms,
temporary_terms_t &temporary_terms,
map<NodeID, pair<int, int> > &first_occurence,
int Curr_block,
vector< vector<temporary_terms_type> > &v_temporary_terms,
vector< vector<temporary_terms_t> > &v_temporary_terms,
int equation) const;
virtual void writeOutput(ostream &output, ExprNodeOutputType output_type, const temporary_terms_type &temporary_terms, deriv_node_temp_terms_type &tef_terms) const;
virtual void writeOutput(ostream &output, ExprNodeOutputType output_type, const temporary_terms_t &temporary_terms, deriv_node_temp_terms_t &tef_terms) const;
virtual void writeExternalFunctionOutput(ostream &output, ExprNodeOutputType output_type,
const temporary_terms_type &temporary_terms,
deriv_node_temp_terms_type &tef_terms) const;
const temporary_terms_t &temporary_terms,
deriv_node_temp_terms_t &tef_terms) const;
};
class SecondDerivExternalFunctionNode : public ExternalFunctionNode
@ -733,17 +733,17 @@ public:
const vector<NodeID> &arguments_arg,
int inputIndex1_arg,
int inputIndex2_arg);
virtual void computeTemporaryTerms(map<NodeID, int> &reference_count, temporary_terms_type &temporary_terms, bool is_matlab) const;
virtual void computeTemporaryTerms(map<NodeID, int> &reference_count, temporary_terms_t &temporary_terms, bool is_matlab) const;
virtual void computeTemporaryTerms(map<NodeID, int> &reference_count,
temporary_terms_type &temporary_terms,
temporary_terms_t &temporary_terms,
map<NodeID, pair<int, int> > &first_occurence,
int Curr_block,
vector< vector<temporary_terms_type> > &v_temporary_terms,
vector< vector<temporary_terms_t> > &v_temporary_terms,
int equation) const;
virtual void writeOutput(ostream &output, ExprNodeOutputType output_type, const temporary_terms_type &temporary_terms, deriv_node_temp_terms_type &tef_terms) const;
virtual void writeOutput(ostream &output, ExprNodeOutputType output_type, const temporary_terms_t &temporary_terms, deriv_node_temp_terms_t &tef_terms) const;
virtual void writeExternalFunctionOutput(ostream &output, ExprNodeOutputType output_type,
const temporary_terms_type &temporary_terms,
deriv_node_temp_terms_type &tef_terms) const;
const temporary_terms_t &temporary_terms,
deriv_node_temp_terms_t &tef_terms) const;
};
#endif

120
MinimumFeedbackSet.cc
View File

@ -24,29 +24,29 @@
namespace MFS
{
void
Suppress(AdjacencyList_type::vertex_descriptor vertex_to_eliminate, AdjacencyList_type &G)
Suppress(AdjacencyList_t::vertex_descriptor vertex_to_eliminate, AdjacencyList_t &G)
{
clear_vertex(vertex_to_eliminate, G);
remove_vertex(vertex_to_eliminate, G);
}
void
Suppress(int vertex_num, AdjacencyList_type &G)
Suppress(int vertex_num, AdjacencyList_t &G)
{
Suppress(vertex(vertex_num, G), G);
}
void
Eliminate(AdjacencyList_type::vertex_descriptor vertex_to_eliminate, AdjacencyList_type &G)
Eliminate(AdjacencyList_t::vertex_descriptor vertex_to_eliminate, AdjacencyList_t &G)
{
if (in_degree(vertex_to_eliminate, G) > 0 && out_degree(vertex_to_eliminate, G) > 0)
{
AdjacencyList_type::in_edge_iterator it_in, in_end;
AdjacencyList_type::out_edge_iterator it_out, out_end;
AdjacencyList_t::in_edge_iterator it_in, in_end;
AdjacencyList_t::out_edge_iterator it_out, out_end;
for (tie(it_in, in_end) = in_edges(vertex_to_eliminate, G); it_in != in_end; ++it_in)
for (tie(it_out, out_end) = out_edges(vertex_to_eliminate, G); it_out != out_end; ++it_out)
{
AdjacencyList_type::edge_descriptor ed;
AdjacencyList_t::edge_descriptor ed;
bool exist;
tie(ed, exist) = edge(source(*it_in, G), target(*it_out, G), G);
if (!exist)
@ -57,11 +57,11 @@ namespace MFS
}
bool
has_cycle_dfs(AdjacencyList_type &g, AdjacencyList_type::vertex_descriptor u, color_type &color, vector<int> &circuit_stack)
has_cycle_dfs(AdjacencyList_t &g, AdjacencyList_t::vertex_descriptor u, color_t &color, vector<int> &circuit_stack)
{
property_map<AdjacencyList_type, vertex_index_t>::type v_index = get(vertex_index, g);
property_map<AdjacencyList_t, vertex_index_t>::type v_index = get(vertex_index, g);
color[u] = gray_color;
graph_traits<AdjacencyList_type>::out_edge_iterator vi, vi_end;
graph_traits<AdjacencyList_t>::out_edge_iterator vi, vi_end;
for (tie(vi, vi_end) = out_edges(u, g); vi != vi_end; ++vi)
if (color[target(*vi, g)] == white_color && has_cycle_dfs(g, target(*vi, g), color, circuit_stack))
{
@ -80,11 +80,11 @@ namespace MFS
}
bool
has_cycle(vector<int> &circuit_stack, AdjacencyList_type &g)
has_cycle(vector<int> &circuit_stack, AdjacencyList_t &g)
{
// Initialize color map to white
color_type color;
graph_traits<AdjacencyList_type>::vertex_iterator vi, vi_end;
color_t color;
graph_traits<AdjacencyList_t>::vertex_iterator vi, vi_end;
for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
color[*vi] = white_color;
@ -97,32 +97,32 @@ namespace MFS
}
void
Print(AdjacencyList_type &G)
Print(AdjacencyList_t &G)
{
AdjacencyList_type::vertex_iterator it, it_end;
property_map<AdjacencyList_type, vertex_index_t>::type v_index = get(vertex_index, G);
AdjacencyList_t::vertex_iterator it, it_end;
property_map<AdjacencyList_t, vertex_index_t>::type v_index = get(vertex_index, G);
cout << "Graph\n";
cout << "-----\n";
for (tie(it, it_end) = vertices(G); it != it_end; ++it)
{
cout << "vertex[" << v_index[*it] + 1 << "] <-";
AdjacencyList_type::in_edge_iterator it_in, in_end;
AdjacencyList_t::in_edge_iterator it_in, in_end;
for (tie(it_in, in_end) = in_edges(*it, G); it_in != in_end; ++it_in)
cout << v_index[source(*it_in, G)] + 1 << " ";
cout << "\n ->";
AdjacencyList_type::out_edge_iterator it_out, out_end;
AdjacencyList_t::out_edge_iterator it_out, out_end;
for (tie(it_out, out_end) = out_edges(*it, G); it_out != out_end; ++it_out)
cout << v_index[target(*it_out, G)] + 1 << " ";
cout << "\n";
}
}
AdjacencyList_type
AdjacencyList_t
AM_2_AdjacencyList(bool *AM, unsigned int n)
{
AdjacencyList_type G(n);
property_map<AdjacencyList_type, vertex_index_t>::type v_index = get(vertex_index, G);
property_map<AdjacencyList_type, vertex_index1_t>::type v_index1 = get(vertex_index1, G);
AdjacencyList_t G(n);
property_map<AdjacencyList_t, vertex_index_t>::type v_index = get(vertex_index, G);
property_map<AdjacencyList_t, vertex_index1_t>::type v_index1 = get(vertex_index1, G);
for (unsigned int i = 0; i < n; i++)
{
put(v_index, vertex(i, G), i);
@ -168,13 +168,13 @@ namespace MFS
return G;
}
AdjacencyList_type
AdjacencyList_t
GraphvizDigraph_2_AdjacencyList(GraphvizDigraph &G1, set<int> select_index)
{
unsigned int n = select_index.size();
AdjacencyList_type G(n);
property_map<AdjacencyList_type, vertex_index_t>::type v_index = get(vertex_index, G);
property_map<AdjacencyList_type, vertex_index1_t>::type v_index1 = get(vertex_index1, G);
AdjacencyList_t G(n);
property_map<AdjacencyList_t, vertex_index_t>::type v_index = get(vertex_index, G);
property_map<AdjacencyList_t, vertex_index1_t>::type v_index1 = get(vertex_index1, G);
property_map<GraphvizDigraph, vertex_index_t>::type v1_index = get(vertex_index, G1);
set<int>::iterator it = select_index.begin();
map<int, int> reverse_index;
@ -199,12 +199,12 @@ namespace MFS
return G;
}
vector_vertex_descriptor
Collect_Doublet(AdjacencyList_type::vertex_descriptor vertex, AdjacencyList_type &G)
vector_vertex_descriptor_t
Collect_Doublet(AdjacencyList_t::vertex_descriptor vertex, AdjacencyList_t &G)
{
AdjacencyList_type::in_edge_iterator it_in, in_end;
AdjacencyList_type::out_edge_iterator it_out, out_end;
vector<AdjacencyList_type::vertex_descriptor> Doublet;
AdjacencyList_t::in_edge_iterator it_in, in_end;
AdjacencyList_t::out_edge_iterator it_out, out_end;
vector<AdjacencyList_t::vertex_descriptor> Doublet;
if (in_degree(vertex, G) > 0 && out_degree(vertex, G) > 0)
for (tie(it_in, in_end) = in_edges(vertex, G); it_in != in_end; ++it_in)
for (tie(it_out, out_end) = out_edges(vertex, G); it_out != out_end; ++it_out)
@ -214,12 +214,12 @@ namespace MFS
}
bool
Vertex_Belong_to_a_Clique(AdjacencyList_type::vertex_descriptor vertex, AdjacencyList_type &G)
Vertex_Belong_to_a_Clique(AdjacencyList_t::vertex_descriptor vertex, AdjacencyList_t &G)
{
vector<AdjacencyList_type::vertex_descriptor> liste;
vector<AdjacencyList_t::vertex_descriptor> liste;
bool agree = true;
AdjacencyList_type::in_edge_iterator it_in, in_end;
AdjacencyList_type::out_edge_iterator it_out, out_end;
AdjacencyList_t::in_edge_iterator it_in, in_end;
AdjacencyList_t::out_edge_iterator it_out, out_end;
tie(it_in, in_end) = in_edges(vertex, G);
tie(it_out, out_end) = out_edges(vertex, G);
while (it_in != in_end && it_out != out_end && agree)
@ -239,7 +239,7 @@ namespace MFS
unsigned int j = i + 1;
while (j < liste.size() && agree)
{
AdjacencyList_type::edge_descriptor ed;
AdjacencyList_t::edge_descriptor ed;
bool exist1, exist2;
tie(ed, exist1) = edge(liste[i], liste[j], G);
tie(ed, exist2) = edge(liste[j], liste[i], G);
@ -253,13 +253,13 @@ namespace MFS
}
bool
Elimination_of_Vertex_With_One_or_Less_Indegree_or_Outdegree_Step(AdjacencyList_type &G)
Elimination_of_Vertex_With_One_or_Less_Indegree_or_Outdegree_Step(AdjacencyList_t &G)
{
bool something_has_been_done = false;
bool not_a_loop;
int i;
AdjacencyList_type::vertex_iterator it, it1, ita, it_end;
property_map<AdjacencyList_type, vertex_index_t>::type v_index = get(vertex_index, G);
AdjacencyList_t::vertex_iterator it, it1, ita, it_end;
property_map<AdjacencyList_t, vertex_index_t>::type v_index = get(vertex_index, G);
for (tie(it, it_end) = vertices(G), i = 0; it != it_end; ++it, i++)
{
int in_degree_n = in_degree(*it, G);
@ -269,7 +269,7 @@ namespace MFS
not_a_loop = true;
if (in_degree_n >= 1 && out_degree_n >= 1) // Do not eliminate a vertex if it loops on itself!
{
AdjacencyList_type::in_edge_iterator it_in, in_end;
AdjacencyList_t::in_edge_iterator it_in, in_end;
for (tie(it_in, in_end) = in_edges(*it, G); it_in != in_end; ++it_in)
if (source(*it_in, G) == target(*it_in, G))
{
@ -282,7 +282,7 @@ namespace MFS
if (not_a_loop)
{
#ifdef verbose
property_map<AdjacencyList_type, vertex_index_t>::type v_index = get(vertex_index, G);
property_map<AdjacencyList_t, vertex_index_t>::type v_index = get(vertex_index, G);
cout << "->eliminate vertex[" << v_index[*it] + 1 << "]\n";
#endif
Eliminate(*it, G);
@ -305,9 +305,9 @@ namespace MFS
}
bool
Elimination_of_Vertex_belonging_to_a_clique_Step(AdjacencyList_type &G)
Elimination_of_Vertex_belonging_to_a_clique_Step(AdjacencyList_t &G)
{
AdjacencyList_type::vertex_iterator it, it1, ita, it_end;
AdjacencyList_t::vertex_iterator it, it1, ita, it_end;
bool something_has_been_done = false;
int i;
for (tie(it, it_end) = vertices(G), i = 0; it != it_end; ++it, i++)
@ -315,7 +315,7 @@ namespace MFS
if (Vertex_Belong_to_a_Clique(*it, G))
{
#ifdef verbose
property_map<AdjacencyList_type, vertex_index_t>::type v_index = get(vertex_index, G);
property_map<AdjacencyList_t, vertex_index_t>::type v_index = get(vertex_index, G);
cout << "eliminate vertex[" << v_index[*it] + 1 << "]\n";
#endif
Eliminate(*it, G);
@ -334,25 +334,25 @@ namespace MFS
}
bool
Suppression_of_Vertex_X_if_it_loops_store_in_set_of_feedback_vertex_Step(set<int> &feed_back_vertices, AdjacencyList_type &G)
Suppression_of_Vertex_X_if_it_loops_store_in_set_of_feedback_vertex_Step(set<int> &feed_back_vertices, AdjacencyList_t &G)
{
bool something_has_been_done = false;
AdjacencyList_type::vertex_iterator it, it_end, ita;
AdjacencyList_t::vertex_iterator it, it_end, ita;
int i = 0;
for (tie(it, it_end) = vertices(G); it != it_end; ++it, i++)
{
AdjacencyList_type::edge_descriptor ed;
AdjacencyList_t::edge_descriptor ed;
bool exist;
tie(ed, exist) = edge(*it, *it, G);
if (exist)
{
#ifdef verbose
property_map<AdjacencyList_type, vertex_index_t>::type v_index = get(vertex_index, G);
property_map<AdjacencyList_t, vertex_index_t>::type v_index = get(vertex_index, G);
cout << "store v[*it] = " << v_index[*it]+1 << "\n";
#endif
property_map<AdjacencyList_type, vertex_index1_t>::type v_index1 = get(vertex_index1, G);
property_map<AdjacencyList_t, vertex_index1_t>::type v_index1 = get(vertex_index1, G);
feed_back_vertices.insert(v_index1[*it]);
/*property_map<AdjacencyList_type, vertex_index_t>::type v_index = get(vertex_index, G);
/*property_map<AdjacencyList_t, vertex_index_t>::type v_index = get(vertex_index, G);
feed_back_vertices.insert(v_index[*it] );*/
Suppress(*it, G);
something_has_been_done = true;
@ -369,13 +369,13 @@ namespace MFS
return something_has_been_done;
}
AdjacencyList_type
Minimal_set_of_feedback_vertex(set<int> &feed_back_vertices, const AdjacencyList_type &G1)
AdjacencyList_t
Minimal_set_of_feedback_vertex(set<int> &feed_back_vertices, const AdjacencyList_t &G1)
{
bool something_has_been_done = true;
int cut_ = 0;
feed_back_vertices.clear();
AdjacencyList_type G(G1);
AdjacencyList_t G(G1);
while (num_vertices(G) > 0)
{
while (something_has_been_done && num_vertices(G) > 0)
@ -411,7 +411,7 @@ namespace MFS
{
/*if nothing has been done in the five previous rule then cut the vertex with the maximum in_degree+out_degree*/
unsigned int max_degree = 0, num = 0;
AdjacencyList_type::vertex_iterator it, it_end, max_degree_index;
AdjacencyList_t::vertex_iterator it, it_end, max_degree_index;
for (tie(it, it_end) = vertices(G); it != it_end; ++it, num++)
{
if (in_degree(*it, G) + out_degree(*it, G) > max_degree)
@ -420,14 +420,14 @@ namespace MFS
max_degree_index = it;
}
}
property_map<AdjacencyList_type, vertex_index1_t>::type v_index1 = get(vertex_index1, G);
property_map<AdjacencyList_t, vertex_index1_t>::type v_index1 = get(vertex_index1, G);
feed_back_vertices.insert(v_index1[*max_degree_index]);
/*property_map<AdjacencyList_type, vertex_index_t>::type v_index = get(vertex_index, G);
/*property_map<AdjacencyList_t, vertex_index_t>::type v_index = get(vertex_index, G);
feed_back_vertices.insert(v_index[*max_degree_index]);*/
//cout << "v_index1[*max_degree_index] = " << v_index1[*max_degree_index] << "\n";
cut_++;
#ifdef verbose
property_map<AdjacencyList_type, vertex_index_t>::type v_index = get(vertex_index, G);
property_map<AdjacencyList_t, vertex_index_t>::type v_index = get(vertex_index, G);
cout << "--> cut vertex " << v_index[*max_degree_index] + 1 << "\n";
#endif
Suppress(*max_degree_index, G);
@ -451,10 +451,10 @@ namespace MFS
};
void
Reorder_the_recursive_variables(const AdjacencyList_type &G1, set<int> &feedback_vertices, vector< int> &Reordered_Vertices)
Reorder_the_recursive_variables(const AdjacencyList_t &G1, set<int> &feedback_vertices, vector< int> &Reordered_Vertices)
{
AdjacencyList_type G(G1);
property_map<AdjacencyList_type, vertex_index_t>::type v_index = get(vertex_index, G);
AdjacencyList_t G(G1);
property_map<AdjacencyList_t, vertex_index_t>::type v_index = get(vertex_index, G);
set<int>::iterator its, ita;
set<int, rev> fv;
for (its = feedback_vertices.begin(); its != feedback_vertices.end(); its++)
@ -466,7 +466,7 @@ namespace MFS
while (something_has_been_done)
{
something_has_been_done = false;
AdjacencyList_type::vertex_iterator it, it_end, ita;
AdjacencyList_t::vertex_iterator it, it_end, ita;
for (tie(it, it_end) = vertices(G), i = 0; it != it_end; ++it, i++)
{
if (in_degree(*it, G) == 0)

38
MinimumFeedbackSet.hh
View File

@ -34,46 +34,46 @@ namespace MFS
property<vertex_index1_t, int,
property<vertex_degree_t, int,
property<vertex_in_degree_t, int,
property<vertex_out_degree_t, int > > > > > VertexProperty;
typedef adjacency_list<listS, listS, bidirectionalS, VertexProperty> AdjacencyList_type;
typedef map<graph_traits<AdjacencyList_type>::vertex_descriptor, default_color_type> color_type;
typedef vector<AdjacencyList_type::vertex_descriptor> vector_vertex_descriptor;
property<vertex_out_degree_t, int > > > > > VertexProperty_t;
typedef adjacency_list<listS, listS, bidirectionalS, VertexProperty_t> AdjacencyList_t;
typedef map<graph_traits<AdjacencyList_t>::vertex_descriptor, default_color_type> color_t;
typedef vector<AdjacencyList_t::vertex_descriptor> vector_vertex_descriptor_t;
//! Eliminate a vertex i
/*! For a vertex i replace all edges e_k_i and e_i_j by a shorcut e_k_j and then Suppress the vertex i*/
void Eliminate(AdjacencyList_type::vertex_descriptor vertex_to_eliminate, AdjacencyList_type &G);
void Eliminate(AdjacencyList_t::vertex_descriptor vertex_to_eliminate, AdjacencyList_t &G);
//! Collect all doublets (edges e_i_k such that there is an edge e_k_i with k!=i in the graph)
/*! Returns the vector of doublets */
vector_vertex_descriptor Collect_Doublet(AdjacencyList_type::vertex_descriptor vertex, AdjacencyList_type &G);
vector_vertex_descriptor_t Collect_Doublet(AdjacencyList_t::vertex_descriptor vertex, AdjacencyList_t &G);
//! Detect all the clique (all vertex in a clique are related to each other) in the graph
bool Vertex_Belong_to_a_Clique(AdjacencyList_type::vertex_descriptor vertex, AdjacencyList_type &G);
bool Vertex_Belong_to_a_Clique(AdjacencyList_t::vertex_descriptor vertex, AdjacencyList_t &G);
//! Graph reduction: eliminating purely intermediate variables or variables outside of any circuit
bool Elimination_of_Vertex_With_One_or_Less_Indegree_or_Outdegree_Step(AdjacencyList_type &G);
bool Elimination_of_Vertex_With_One_or_Less_Indegree_or_Outdegree_Step(AdjacencyList_t &G);
//! Graph reduction: elimination of a vertex inside a clique
bool Elimination_of_Vertex_belonging_to_a_clique_Step(AdjacencyList_type &G);
bool Elimination_of_Vertex_belonging_to_a_clique_Step(AdjacencyList_t &G);
//! A vertex belong to the feedback vertex set if the vertex loops on itself.
/*! We have to suppress this vertex and store it into the feedback set.*/
bool Suppression_of_Vertex_X_if_it_loops_store_in_set_of_feedback_vertex_Step(set<int> &feed_back_vertices, AdjacencyList_type &G1);
bool Suppression_of_Vertex_X_if_it_loops_store_in_set_of_feedback_vertex_Step(set<int> &feed_back_vertices, AdjacencyList_t &G1);
//! Print the Graph
void Print(GraphvizDigraph &G);
void Print(AdjacencyList_type &G);
void Print(AdjacencyList_t &G);
//! Create a GraphvizDigraph from a Adjacency Matrix (an incidence Matrix without the diagonal terms)
GraphvizDigraph AM_2_GraphvizDigraph(bool *AM, unsigned int n);
//! Create an adjacency graph from a Adjacency Matrix (an incidence Matrix without the diagonal terms)
AdjacencyList_type AM_2_AdjacencyList(bool *AMp, unsigned int n);
AdjacencyList_t AM_2_AdjacencyList(bool *AMp, unsigned int n);
//! Create an adjacency graph from a GraphvizDigraph
AdjacencyList_type GraphvizDigraph_2_AdjacencyList(GraphvizDigraph &G1, set<int> select_index);
AdjacencyList_t GraphvizDigraph_2_AdjacencyList(GraphvizDigraph &G1, set<int> select_index);
//! Check if the graph contains any cycle (true if the model contains at least one cycle, false otherwise)
bool has_cycle(vector<int> &circuit_stack, AdjacencyList_type &g);
bool has_cycle_dfs(AdjacencyList_type &g, AdjacencyList_type::vertex_descriptor u, color_type &color, vector<int> &circuit_stack);
bool has_cycle(vector<int> &circuit_stack, AdjacencyList_t &g);
bool has_cycle_dfs(AdjacencyList_t &g, AdjacencyList_t::vertex_descriptor u, color_t &color, vector<int> &circuit_stack);
//! Return the feedback set
AdjacencyList_type Minimal_set_of_feedback_vertex(set<int> &feed_back_vertices, const AdjacencyList_type &G);
AdjacencyList_t Minimal_set_of_feedback_vertex(set<int> &feed_back_vertices, const AdjacencyList_t &G);
//! Clear all in and out edges of vertex_to_eliminate and remove vertex_to_eliminate from the graph
void Suppress(AdjacencyList_type::vertex_descriptor vertex_to_eliminate, AdjacencyList_type &G);
void Suppress(int vertex_num, AdjacencyList_type &G);
void Suppress(AdjacencyList_t::vertex_descriptor vertex_to_eliminate, AdjacencyList_t &G);
void Suppress(int vertex_num, AdjacencyList_t &G);
//! Reorder the recursive variables
/*! They appear first in a quasi triangular form and they are followed by the feedback variables */
void Reorder_the_recursive_variables(const AdjacencyList_type &G1, set<int> &feedback_vertices, vector< int> &Reordered_Vertices);
void Reorder_the_recursive_variables(const AdjacencyList_t &G1, set<int> &feedback_vertices, vector< int> &Reordered_Vertices);
};
#endif // _MINIMUMFEEDBACKSET_HH

2
ModFile.hh
View File

@ -71,7 +71,7 @@ public:
//! Global evaluation context
/*! Filled using initval blocks and parameters initializations */
eval_context_type global_eval_context;
eval_context_t global_eval_context;
private:
//! List of statements

102
ModelTree.cc
View File

@ -34,7 +34,7 @@ using namespace boost;
using namespace MFS;
bool
ModelTree::computeNormalization(const jacob_map &contemporaneous_jacobian, bool verbose)
ModelTree::computeNormalization(const jacob_map_t &contemporaneous_jacobian, bool verbose)
{
const int n = equation_number();
@ -51,7 +51,7 @@ ModelTree::computeNormalization(const jacob_map &contemporaneous_jacobian, bool
// Fill in the graph
set<pair<int, int> > endo;
for (jacob_map::const_iterator it = contemporaneous_jacobian.begin(); it != contemporaneous_jacobian.end(); it++)
for (jacob_map_t::const_iterator it = contemporaneous_jacobian.begin(); it != contemporaneous_jacobian.end(); it++)
add_edge(it->first.first + n, it->first.second, g);
// Compute maximum cardinality matching
@ -137,7 +137,7 @@ ModelTree::computeNormalization(const jacob_map &contemporaneous_jacobian, bool
}
void
ModelTree::computeNonSingularNormalization(jacob_map &contemporaneous_jacobian, double cutoff, jacob_map &static_jacobian, dynamic_jacob_map &dynamic_jacobian)
ModelTree::computeNonSingularNormalization(jacob_map_t &contemporaneous_jacobian, double cutoff, jacob_map_t &static_jacobian, dynamic_jacob_map_t &dynamic_jacobian)
{
bool check = false;
@ -147,13 +147,13 @@ ModelTree::computeNonSingularNormalization(jacob_map &contemporaneous_jacobian,
// compute the maximum value of each row of the contemporaneous Jacobian matrix
//jacob_map normalized_contemporaneous_jacobian;
jacob_map normalized_contemporaneous_jacobian(contemporaneous_jacobian);
jacob_map_t normalized_contemporaneous_jacobian(contemporaneous_jacobian);
vector<double> max_val(n, 0.0);
for (jacob_map::const_iterator iter = contemporaneous_jacobian.begin(); iter != contemporaneous_jacobian.end(); iter++)
for (jacob_map_t::const_iterator iter = contemporaneous_jacobian.begin(); iter != contemporaneous_jacobian.end(); iter++)
if (fabs(iter->second) > max_val[iter->first.first])
max_val[iter->first.first] = fabs(iter->second);
for (jacob_map::iterator iter = normalized_contemporaneous_jacobian.begin(); iter != normalized_contemporaneous_jacobian.end(); iter++)
for (jacob_map_t::iterator iter = normalized_contemporaneous_jacobian.begin(); iter != normalized_contemporaneous_jacobian.end(); iter++)
iter->second /= max_val[iter->first.first];
//We start with the highest value of the cutoff and try to normalize the model
@ -162,9 +162,9 @@ ModelTree::computeNonSingularNormalization(jacob_map &contemporaneous_jacobian,
int suppressed = 0;
while (!check && current_cutoff > 1e-19)
{
jacob_map tmp_normalized_contemporaneous_jacobian;
jacob_map_t tmp_normalized_contemporaneous_jacobian;
int suppress = 0;
for (jacob_map::iterator iter = normalized_contemporaneous_jacobian.begin(); iter != normalized_contemporaneous_jacobian.end(); iter++)
for (jacob_map_t::iterator iter = normalized_contemporaneous_jacobian.begin(); iter != normalized_contemporaneous_jacobian.end(); iter++)
if (fabs(iter->second) > max(current_cutoff, cutoff))
tmp_normalized_contemporaneous_jacobian[make_pair(iter->first.first, iter->first.second)] = iter->second;
else
@ -186,7 +186,7 @@ ModelTree::computeNonSingularNormalization(jacob_map &contemporaneous_jacobian,
{
cout << "Normalization failed with cutoff, trying symbolic normalization..." << endl;
//if no non-singular normalization can be found, try to find a normalization even with a potential singularity
jacob_map tmp_normalized_contemporaneous_jacobian;
jacob_map_t tmp_normalized_contemporaneous_jacobian;
set<pair<int, int> > endo;
for (int i = 0; i < n; i++)
{
@ -199,7 +199,7 @@ ModelTree::computeNonSingularNormalization(jacob_map &contemporaneous_jacobian,
if (check)
{
// Update the jacobian matrix
for (jacob_map::const_iterator it = tmp_normalized_contemporaneous_jacobian.begin(); it != tmp_normalized_contemporaneous_jacobian.end(); it++)
for (jacob_map_t::const_iterator it = tmp_normalized_contemporaneous_jacobian.begin(); it != tmp_normalized_contemporaneous_jacobian.end(); it++)
{
if (static_jacobian.find(make_pair(it->first.first, it->first.second)) == static_jacobian.end())
static_jacobian[make_pair(it->first.first, it->first.second)] = 0;
@ -242,11 +242,11 @@ ModelTree::computeNormalizedEquations(multimap<int, int> &endo2eqs) const
}
void
ModelTree::evaluateAndReduceJacobian(const eval_context_type &eval_context, jacob_map &contemporaneous_jacobian, jacob_map &static_jacobian, dynamic_jacob_map &dynamic_jacobian, double cutoff, bool verbose)
ModelTree::evaluateAndReduceJacobian(const eval_context_t &eval_context, jacob_map_t &contemporaneous_jacobian, jacob_map_t &static_jacobian, dynamic_jacob_map_t &dynamic_jacobian, double cutoff, bool verbose)
{
int nb_elements_contemparenous_Jacobian = 0;
set<pair<int, int> > jacobian_elements_to_delete;
for (first_derivatives_type::const_iterator it = first_derivatives.begin();
for (first_derivatives_t::const_iterator it = first_derivatives.begin();
it != first_derivatives.end(); it++)
{
int deriv_id = it->first.second;
@ -304,7 +304,7 @@ ModelTree::evaluateAndReduceJacobian(const eval_context_type &eval_context, jaco
}
void
ModelTree::computePrologueAndEpilogue(const jacob_map &static_jacobian_arg, vector<int> &equation_reordered, vector<int> &variable_reordered)
ModelTree::computePrologueAndEpilogue(const jacob_map_t &static_jacobian_arg, vector<int> &equation_reordered, vector<int> &variable_reordered)
{
vector<int> eq2endo(equation_number(), 0);
equation_reordered.resize(equation_number());
@ -319,7 +319,7 @@ ModelTree::computePrologueAndEpilogue(const jacob_map &static_jacobian_arg, vect
equation_reordered[i] = i;
variable_reordered[*it] = i;
}
for (jacob_map::const_iterator it = static_jacobian_arg.begin(); it != static_jacobian_arg.end(); it++)
for (jacob_map_t::const_iterator it = static_jacobian_arg.begin(); it != static_jacobian_arg.end(); it++)
IM[it->first.first * n + endo2eq[it->first.second]] = true;
bool something_has_been_done = true;
prologue = 0;
@ -410,13 +410,13 @@ ModelTree::computePrologueAndEpilogue(const jacob_map &static_jacobian_arg, vect
free(IM);
}
t_equation_type_and_normalized_equation
equation_type_and_normalized_equation_t
ModelTree::equationTypeDetermination(const map<pair<int, pair<int, int> >, NodeID> &first_order_endo_derivatives, const vector<int> &Index_Var_IM, const vector<int> &Index_Equ_IM, int mfs) const
{
NodeID lhs, rhs;
BinaryOpNode *eq_node;
EquationType Equation_Simulation_Type;
t_equation_type_and_normalized_equation V_Equation_Simulation_Type(equations.size());
equation_type_and_normalized_equation_t V_Equation_Simulation_Type(equations.size());
for (unsigned int i = 0; i < equations.size(); i++)
{
int eq = Index_Equ_IM[i];
@ -459,11 +459,11 @@ ModelTree::equationTypeDetermination(const map<pair<int, pair<int, int> >, NodeI
}
void
ModelTree::getVariableLeadLagByBlock(const dynamic_jacob_map &dynamic_jacobian, const vector<int> &components_set, int nb_blck_sim, t_lag_lead_vector &equation_lead_lag, t_lag_lead_vector &variable_lead_lag, const vector<int> &equation_reordered, const vector<int> &variable_reordered) const
ModelTree::getVariableLeadLagByBlock(const dynamic_jacob_map_t &dynamic_jacobian, const vector<int> &components_set, int nb_blck_sim, lag_lead_vector_t &equation_lead_lag, lag_lead_vector_t &variable_lead_lag, const vector<int> &equation_reordered, const vector<int> &variable_reordered) const
{
int nb_endo = symbol_table.endo_nbr();
variable_lead_lag = t_lag_lead_vector(nb_endo, make_pair(0, 0));
equation_lead_lag = t_lag_lead_vector(nb_endo, make_pair(0, 0));
variable_lead_lag = lag_lead_vector_t(nb_endo, make_pair(0, 0));
equation_lead_lag = lag_lead_vector_t(nb_endo, make_pair(0, 0));
vector<int> variable_blck(nb_endo), equation_blck(nb_endo);
for (int i = 0; i < nb_endo; i++)
{
@ -483,7 +483,7 @@ ModelTree::getVariableLeadLagByBlock(const dynamic_jacob_map &dynamic_jacobian,
equation_blck[equation_reordered[i]] = i- (nb_endo - nb_blck_sim - prologue - epilogue);
}
}
for (dynamic_jacob_map::const_iterator it = dynamic_jacobian.begin(); it != dynamic_jacobian.end(); it++)
for (dynamic_jacob_map_t::const_iterator it = dynamic_jacobian.begin(); it != dynamic_jacobian.end(); it++)
{
int lag = it->first.first;
int j_1 = it->first.second.second;
@ -503,7 +503,7 @@ ModelTree::getVariableLeadLagByBlock(const dynamic_jacob_map &dynamic_jacobian,
}
void
ModelTree::computeBlockDecompositionAndFeedbackVariablesForEachBlock(const jacob_map &static_jacobian, const dynamic_jacob_map &dynamic_jacobian, vector<int> &equation_reordered, vector<int> &variable_reordered, vector<pair<int, int> > &blocks, const t_equation_type_and_normalized_equation &Equation_Type, bool verbose_, bool select_feedback_variable, int mfs, vector<int> &inv_equation_reordered, vector<int> &inv_variable_reordered) const
ModelTree::computeBlockDecompositionAndFeedbackVariablesForEachBlock(const jacob_map_t &static_jacobian, const dynamic_jacob_map_t &dynamic_jacobian, vector<int> &equation_reordered, vector<int> &variable_reordered, vector<pair<int, int> > &blocks, const equation_type_and_normalized_equation_t &Equation_Type, bool verbose_, bool select_feedback_variable, int mfs, vector<int> &inv_equation_reordered, vector<int> &inv_variable_reordered) const
{
int nb_var = variable_reordered.size();
int n = nb_var - prologue - epilogue;
@ -519,7 +519,7 @@ ModelTree::computeBlockDecompositionAndFeedbackVariablesForEachBlock(const jacob
reverse_variable_reordered[variable_reordered[i]] = i;
}
for (jacob_map::const_iterator it = static_jacobian.begin(); it != static_jacobian.end(); it++)
for (jacob_map_t::const_iterator it = static_jacobian.begin(); it != static_jacobian.end(); it++)
if (reverse_equation_reordered[it->first.first] >= prologue && reverse_equation_reordered[it->first.first] < nb_var - epilogue
&& reverse_variable_reordered[it->first.second] >= prologue && reverse_variable_reordered[it->first.second] < nb_var - epilogue
&& it->first.first != endo2eq[it->first.second])
@ -570,7 +570,7 @@ ModelTree::computeBlockDecompositionAndFeedbackVariablesForEachBlock(const jacob
components_set[endo2block[i]].first.insert(i);
}
t_lag_lead_vector equation_lag_lead, variable_lag_lead;
lag_lead_vector_t equation_lag_lead, variable_lag_lead;
getVariableLeadLagByBlock(dynamic_jacobian, endo2block, num, equation_lag_lead, variable_lag_lead, equation_reordered, variable_reordered);
@ -600,11 +600,11 @@ ModelTree::computeBlockDecompositionAndFeedbackVariablesForEachBlock(const jacob
for (int i = 0; i < num; i++)
{
AdjacencyList_type G = GraphvizDigraph_2_AdjacencyList(G2, components_set[i].first);
AdjacencyList_t G = GraphvizDigraph_2_AdjacencyList(G2, components_set[i].first);
set<int> feed_back_vertices;
//Print(G);
AdjacencyList_type G1 = Minimal_set_of_feedback_vertex(feed_back_vertices, G);
property_map<AdjacencyList_type, vertex_index_t>::type v_index = get(vertex_index, G);
AdjacencyList_t G1 = Minimal_set_of_feedback_vertex(feed_back_vertices, G);
property_map<AdjacencyList_t, vertex_index_t>::type v_index = get(vertex_index, G);
components_set[i].second.first = feed_back_vertices;
blocks[i].second = feed_back_vertices.size();
vector<int> Reordered_Vertice;
@ -664,14 +664,14 @@ ModelTree::printBlockDecomposition(const vector<pair<int, int> > &blocks) const
<< " and " << Nb_feedback_variable << " feedback variable(s)." << endl;
}
t_block_type_firstequation_size_mfs
ModelTree::reduceBlocksAndTypeDetermination(const dynamic_jacob_map &dynamic_jacobian, const vector<pair<int, int> > &blocks, const t_equation_type_and_normalized_equation &Equation_Type, const vector<int> &variable_reordered, const vector<int> &equation_reordered)
block_type_firstequation_size_mfs_t
ModelTree::reduceBlocksAndTypeDetermination(const dynamic_jacob_map_t &dynamic_jacobian, const vector<pair<int, int> > &blocks, const equation_type_and_normalized_equation_t &Equation_Type, const vector<int> &variable_reordered, const vector<int> &equation_reordered)
{
int i = 0;
int count_equ = 0, blck_count_simult = 0;
int Blck_Size, MFS_Size;
int Lead, Lag;
t_block_type_firstequation_size_mfs block_type_size_mfs;
block_type_firstequation_size_mfs_t block_type_size_mfs;
BlockSimulationType Simulation_Type, prev_Type = UNKNOWN;
int eq = 0;
for (i = 0; i < prologue+(int) blocks.size()+epilogue; i++)
@ -785,7 +785,7 @@ ModelTree::reduceBlocksAndTypeDetermination(const dynamic_jacob_map &dynamic_jac
}
vector<bool>
ModelTree::BlockLinear(const t_blocks_derivatives &blocks_derivatives, const vector<int> &variable_reordered) const
ModelTree::BlockLinear(const blocks_derivatives_t &blocks_derivatives, const vector<int> &variable_reordered) const
{
unsigned int nb_blocks = getNbBlocks();
vector<bool> blocks_linear(nb_blocks, true);
@ -793,11 +793,11 @@ ModelTree::BlockLinear(const t_blocks_derivatives &blocks_derivatives, const vec
{
BlockSimulationType simulation_type = getBlockSimulationType(block);
int block_size = getBlockSize(block);
t_block_derivatives_equation_variable_laglead_nodeid derivatives_block = blocks_derivatives[block];
block_derivatives_equation_variable_laglead_nodeid_t derivatives_block = blocks_derivatives[block];
int first_variable_position = getBlockFirstEquation(block);
if (simulation_type == SOLVE_BACKWARD_COMPLETE || simulation_type == SOLVE_FORWARD_COMPLETE)
{
for (t_block_derivatives_equation_variable_laglead_nodeid::const_iterator it = derivatives_block.begin(); it != derivatives_block.end(); it++)
for (block_derivatives_equation_variable_laglead_nodeid_t::const_iterator it = derivatives_block.begin(); it != derivatives_block.end(); it++)
{
int lag = it->second.first;
if (lag == 0)
@ -821,7 +821,7 @@ ModelTree::BlockLinear(const t_blocks_derivatives &blocks_derivatives, const vec
}
else if (simulation_type == SOLVE_TWO_BOUNDARIES_COMPLETE || simulation_type == SOLVE_TWO_BOUNDARIES_SIMPLE)
{
for (t_block_derivatives_equation_variable_laglead_nodeid::const_iterator it = derivatives_block.begin(); it != derivatives_block.end(); it++)
for (block_derivatives_equation_variable_laglead_nodeid_t::const_iterator it = derivatives_block.begin(); it != derivatives_block.end(); it++)
{
int lag = it->second.first;
NodeID Id = it->second.second; //
@ -864,9 +864,9 @@ ModelTree::equation_number() const
void
ModelTree::writeDerivative(ostream &output, int eq, int symb_id, int lag,
ExprNodeOutputType output_type,
const temporary_terms_type &temporary_terms) const
const temporary_terms_t &temporary_terms) const
{
first_derivatives_type::const_iterator it = first_derivatives.find(make_pair(eq, getDerivID(symb_id, lag)));
first_derivatives_t::const_iterator it = first_derivatives.find(make_pair(eq, getDerivID(symb_id, lag)));
if (it != first_derivatives.end())
(it->second)->writeOutput(output, output_type, temporary_terms);
else
@ -891,7 +891,7 @@ ModelTree::computeJacobian(const set<int> &vars)
void
ModelTree::computeHessian(const set<int> &vars)
{
for (first_derivatives_type::const_iterator it = first_derivatives.begin();
for (first_derivatives_t::const_iterator it = first_derivatives.begin();
it != first_derivatives.end(); it++)
{
int eq = it->first.first;
@ -921,7 +921,7 @@ ModelTree::computeHessian(const set<int> &vars)
void
ModelTree::computeThirdDerivatives(const set<int> &vars)
{
for (second_derivatives_type::const_iterator it = second_derivatives.begin();
for (second_derivatives_t::const_iterator it = second_derivatives.begin();
it != second_derivatives.end(); it++)
{
int eq = it->first.first;
@ -964,33 +964,33 @@ ModelTree::computeTemporaryTerms(bool is_matlab)
it != equations.end(); it++)
(*it)->computeTemporaryTerms(reference_count, temporary_terms, is_matlab);
for (first_derivatives_type::iterator it = first_derivatives.begin();
for (first_derivatives_t::iterator it = first_derivatives.begin();
it != first_derivatives.end(); it++)
it->second->computeTemporaryTerms(reference_count, temporary_terms, is_matlab);
for (second_derivatives_type::iterator it = second_derivatives.begin();
for (second_derivatives_t::iterator it = second_derivatives.begin();
it != second_derivatives.end(); it++)
it->second->computeTemporaryTerms(reference_count, temporary_terms, is_matlab);
for (third_derivatives_type::iterator it = third_derivatives.begin();
for (third_derivatives_t::iterator it = third_derivatives.begin();
it != third_derivatives.end(); it++)
it->second->computeTemporaryTerms(reference_count, temporary_terms, is_matlab);
}
void
ModelTree::writeTemporaryTerms(const temporary_terms_type &tt, ostream &output,
ModelTree::writeTemporaryTerms(const temporary_terms_t &tt, ostream &output,
ExprNodeOutputType output_type) const
{
// Local var used to keep track of temp nodes already written
temporary_terms_type tt2;
temporary_terms_t tt2;
// To store the functions that have already been written in the form TEF* = ext_fun();
deriv_node_temp_terms_type tef_terms;
deriv_node_temp_terms_t tef_terms;
if (tt.size() > 0 && (IS_C(output_type)))
output << "double" << endl;
for (temporary_terms_type::const_iterator it = tt.begin();
for (temporary_terms_t::const_iterator it = tt.begin();
it != tt.end(); it++)
{
if (IS_C(output_type) && it != tt.begin())
@ -1015,11 +1015,11 @@ ModelTree::writeTemporaryTerms(const temporary_terms_type &tt, ostream &output,
}
void
ModelTree::compileTemporaryTerms(ostream &code_file, const temporary_terms_type &tt, map_idx_type map_idx, bool dynamic, bool steady_dynamic) const
ModelTree::compileTemporaryTerms(ostream &code_file, const temporary_terms_t &tt, map_idx_t map_idx, bool dynamic, bool steady_dynamic) const
{
// Local var used to keep track of temp nodes already written
temporary_terms_type tt2;
for (temporary_terms_type::const_iterator it = tt.begin();
temporary_terms_t tt2;
for (temporary_terms_t::const_iterator it = tt.begin();
it != tt.end(); it++)
{
FNUMEXPR_ fnumexpr(TemporaryTerm, (int)(map_idx.find((*it)->idx)->second));
@ -1074,7 +1074,7 @@ ModelTree::writeModelEquations(ostream &output, ExprNodeOutputType output_type)
double vrhs = 1.0;
try
{
vrhs = rhs->eval(eval_context_type());
vrhs = rhs->eval(eval_context_t());
}
catch (ExprNode::EvalException &e)
{
@ -1108,7 +1108,7 @@ ModelTree::writeModelEquations(ostream &output, ExprNodeOutputType output_type)
}
void
ModelTree::compileModelEquations(ostream &code_file, const temporary_terms_type &tt, const map_idx_type &map_idx, bool dynamic, bool steady_dynamic) const
ModelTree::compileModelEquations(ostream &code_file, const temporary_terms_t &tt, const map_idx_t &map_idx, bool dynamic, bool steady_dynamic) const
{
for (int eq = 0; eq < (int) equations.size(); eq++)
{
@ -1121,7 +1121,7 @@ ModelTree::compileModelEquations(ostream &code_file, const temporary_terms_type
double vrhs = 1.0;
try
{
vrhs = rhs->eval(eval_context_type());
vrhs = rhs->eval(eval_context_t());
}
catch (ExprNode::EvalException &e)
{
@ -1164,7 +1164,7 @@ ModelTree::Write_Inf_To_Bin_File(const string &basename,
exit(EXIT_FAILURE);
}
u_count_int = 0;
for (first_derivatives_type::const_iterator it = first_derivatives.begin();it != first_derivatives.end(); it++)
for (first_derivatives_t::const_iterator it = first_derivatives.begin();it != first_derivatives.end(); it++)
{
int deriv_id = it->first.second;
if (getTypeByDerivID(deriv_id) == eEndogenous)

56
ModelTree.hh
View File

@ -31,19 +31,19 @@ using namespace std;
#include "DataTree.hh"
//! Vector describing equations: BlockSimulationType, if BlockSimulationType == EVALUATE_s then a NodeID on the new normalized equation
typedef vector<pair<EquationType, NodeID > > t_equation_type_and_normalized_equation;
typedef vector<pair<EquationType, NodeID > > equation_type_and_normalized_equation_t;
//! Vector describing variables: max_lag in the block, max_lead in the block
typedef vector<pair< int, int> > t_lag_lead_vector;
typedef vector<pair< int, int> > lag_lead_vector_t;
//! for each block contains pair< pair<Simulation_Type, first_equation>, pair < Block_Size, Recursive_part_Size > >
typedef vector<pair< pair< BlockSimulationType, int>, pair<int, int> > > t_block_type_firstequation_size_mfs;
typedef vector<pair< pair< BlockSimulationType, int>, pair<int, int> > > block_type_firstequation_size_mfs_t;
//! for a block contains derivatives pair< pair<block_equation_number, block_variable_number> , pair<lead_lag, NodeID> >
typedef vector< pair<pair<int, int>, pair< int, NodeID > > > t_block_derivatives_equation_variable_laglead_nodeid;
typedef vector< pair<pair<int, int>, pair< int, NodeID > > > block_derivatives_equation_variable_laglead_nodeid_t;
//! for all blocks derivatives description
typedef vector<t_block_derivatives_equation_variable_laglead_nodeid> t_blocks_derivatives;
typedef vector<block_derivatives_equation_variable_laglead_nodeid_t> blocks_derivatives_t;
//! Shared code for static and dynamic models
class ModelTree : public DataTree
@ -64,34 +64,34 @@ protected:
//! Number of non-zero derivatives
int NNZDerivatives[3];
typedef map<pair<int, int>, NodeID> first_derivatives_type;
typedef map<pair<int, int>, NodeID> first_derivatives_t;
//! First order derivatives
/*! First index is equation number, second is variable w.r. to which is computed the derivative.
Only non-null derivatives are stored in the map.
Variable indices are those of the getDerivID() method.
*/
first_derivatives_type first_derivatives;
first_derivatives_t first_derivatives;
typedef map<pair<int, pair<int, int> >, NodeID> second_derivatives_type;
typedef map<pair<int, pair<int, int> >, NodeID> second_derivatives_t;
//! Second order derivatives
/*! First index is equation number, second and third are variables w.r. to which is computed the derivative.
Only non-null derivatives are stored in the map.
Contains only second order derivatives where var1 >= var2 (for obvious symmetry reasons).
Variable indices are those of the getDerivID() method.
*/
second_derivatives_type second_derivatives;
second_derivatives_t second_derivatives;
typedef map<pair<int, pair<int, pair<int, int> > >, NodeID> third_derivatives_type;
typedef map<pair<int, pair<int, pair<int, int> > >, NodeID> third_derivatives_t;
//! Third order derivatives
/*! First index is equation number, second, third and fourth are variables w.r. to which is computed the derivative.
Only non-null derivatives are stored in the map.
Contains only third order derivatives where var1 >= var2 >= var3 (for obvious symmetry reasons).
Variable indices are those of the getDerivID() method.
*/
third_derivatives_type third_derivatives;
third_derivatives_t third_derivatives;
//! Temporary terms (those which will be noted Txxxx)
temporary_terms_type temporary_terms;
temporary_terms_t temporary_terms;
//! Computes 1st derivatives
/*! \param vars the derivation IDs w.r. to which compute the derivatives */
@ -104,13 +104,13 @@ protected:
void computeThirdDerivatives(const set<int> &vars);
//! Write derivative of an equation w.r. to a variable
void writeDerivative(ostream &output, int eq, int symb_id, int lag, ExprNodeOutputType output_type, const temporary_terms_type &temporary_terms) const;
void writeDerivative(ostream &output, int eq, int symb_id, int lag, ExprNodeOutputType output_type, const temporary_terms_t &temporary_terms) const;
//! Computes temporary terms (for all equations and derivatives)
void computeTemporaryTerms(bool is_matlab);
//! Writes temporary terms
void writeTemporaryTerms(const temporary_terms_type &tt, ostream &output, ExprNodeOutputType output_type) const;
void writeTemporaryTerms(const temporary_terms_t &tt, ostream &output, ExprNodeOutputType output_type) const;
//! Compiles temporary terms
void compileTemporaryTerms(ostream &code_file, const temporary_terms_type &tt, map_idx_type map_idx, bool dynamic, bool steady_dynamic) const;
void compileTemporaryTerms(ostream &code_file, const temporary_terms_t &tt, map_idx_t map_idx, bool dynamic, bool steady_dynamic) const;
//! Adds informations for simulation in a binary file
void Write_Inf_To_Bin_File(const string &basename, int &u_count_int, bool &file_open, bool is_two_boundaries, int block_mfs) const;
@ -120,18 +120,18 @@ protected:
//! Writes model equations
void writeModelEquations(ostream &output, ExprNodeOutputType output_type) const;
//! Compiles model equations
void compileModelEquations(ostream &code_file, const temporary_terms_type &tt, const map_idx_type &map_idx, bool dynamic, bool steady_dynamic) const;
void compileModelEquations(ostream &code_file, const temporary_terms_t &tt, const map_idx_t &map_idx, bool dynamic, bool steady_dynamic) const;
//! Writes LaTeX model file
void writeLatexModelFile(const string &filename, ExprNodeOutputType output_type) const;
//! Sparse matrix of double to store the values of the Jacobian
/*! First index is equation number, second index is endogenous type specific ID */
typedef map<pair<int, int>, double> jacob_map;
typedef map<pair<int, int>, double> jacob_map_t;
//! Sparse matrix of double to store the values of the Jacobian
/*! First index is lag, second index is equation number, third index is endogenous type specific ID */
typedef map<pair<int, pair<int, int> >, NodeID> dynamic_jacob_map;
typedef map<pair<int, pair<int, int> >, NodeID> dynamic_jacob_map_t;
//! Normalization of equations
/*! Maps endogenous type specific IDs to equation numbers */
@ -141,14 +141,14 @@ protected:
unsigned int epilogue, prologue;
//! for each block contains pair< max_lag, max_lead>
t_lag_lead_vector block_lag_lead;
lag_lead_vector_t block_lag_lead;
//! Compute the matching between endogenous and variable using the jacobian contemporaneous_jacobian
/*!
\param contemporaneous_jacobian Jacobian used as an incidence matrix: all elements declared in the map (even if they are zero), are used as vertices of the incidence matrix
\return True if a complete normalization has been achieved
*/
bool computeNormalization(const jacob_map &contemporaneous_jacobian, bool verbose);
bool computeNormalization(const jacob_map_t &contemporaneous_jacobian, bool verbose);
//! Try to compute the matching between endogenous and variable using a decreasing cutoff
/*!
@ -156,26 +156,26 @@ protected:
If no matching is found using a strictly positive cutoff, then a zero cutoff is applied (i.e. use a symbolic normalization); in that case, the method adds zeros in the jacobian matrices to reflect all the edges in the symbolic incidence matrix.
If no matching is found with a zero cutoff close to zero an error message is printout.
*/
void computeNonSingularNormalization(jacob_map &contemporaneous_jacobian, double cutoff, jacob_map &static_jacobian, dynamic_jacob_map &dynamic_jacobian);
void computeNonSingularNormalization(jacob_map_t &contemporaneous_jacobian, double cutoff, jacob_map_t &static_jacobian, dynamic_jacob_map_t &dynamic_jacobian);
//! Try to normalized each unnormalized equation (matched endogenous variable only on the LHS)
void computeNormalizedEquations(multimap<int, int> &endo2eqs) const;
//! Evaluate the jacobian and suppress all the elements below the cutoff
void evaluateAndReduceJacobian(const eval_context_type &eval_context, jacob_map &contemporaneous_jacobian, jacob_map &static_jacobian, dynamic_jacob_map &dynamic_jacobian, double cutoff, bool verbose);
void evaluateAndReduceJacobian(const eval_context_t &eval_context, jacob_map_t &contemporaneous_jacobian, jacob_map_t &static_jacobian, dynamic_jacob_map_t &dynamic_jacobian, double cutoff, bool verbose);
//! Search the equations and variables belonging to the prologue and the epilogue of the model
void computePrologueAndEpilogue(const jacob_map &static_jacobian, vector<int> &equation_reordered, vector<int> &variable_reordered);
void computePrologueAndEpilogue(const jacob_map_t &static_jacobian, vector<int> &equation_reordered, vector<int> &variable_reordered);
//! Determine the type of each equation of model and try to normalized the unnormalized equation using computeNormalizedEquations
t_equation_type_and_normalized_equation equationTypeDetermination(const map<pair<int, pair<int, int> >, NodeID> &first_order_endo_derivatives, const vector<int> &Index_Var_IM, const vector<int> &Index_Equ_IM, int mfs) const;
equation_type_and_normalized_equation_t equationTypeDetermination(const map<pair<int, pair<int, int> >, NodeID> &first_order_endo_derivatives, const vector<int> &Index_Var_IM, const vector<int> &Index_Equ_IM, int mfs) const;
//! Compute the block decomposition and for a non-recusive block find the minimum feedback set
void computeBlockDecompositionAndFeedbackVariablesForEachBlock(const jacob_map &static_jacobian, const dynamic_jacob_map &dynamic_jacobian, vector<int> &equation_reordered, vector<int> &variable_reordered, vector<pair<int, int> > &blocks, const t_equation_type_and_normalized_equation &Equation_Type, bool verbose_, bool select_feedback_variable, int mfs, vector<int> &inv_equation_reordered, vector<int> &inv_variable_reordered) const;
void computeBlockDecompositionAndFeedbackVariablesForEachBlock(const jacob_map_t &static_jacobian, const dynamic_jacob_map_t &dynamic_jacobian, vector<int> &equation_reordered, vector<int> &variable_reordered, vector<pair<int, int> > &blocks, const equation_type_and_normalized_equation_t &Equation_Type, bool verbose_, bool select_feedback_variable, int mfs, vector<int> &inv_equation_reordered, vector<int> &inv_variable_reordered) const;
//! Reduce the number of block merging the same type equation in the prologue and the epilogue and determine the type of each block
t_block_type_firstequation_size_mfs reduceBlocksAndTypeDetermination(const dynamic_jacob_map &dynamic_jacobian, const vector<pair<int, int> > &blocks, const t_equation_type_and_normalized_equation &Equation_Type, const vector<int> &variable_reordered, const vector<int> &equation_reordered);
block_type_firstequation_size_mfs_t reduceBlocksAndTypeDetermination(const dynamic_jacob_map_t &dynamic_jacobian, const vector<pair<int, int> > &blocks, const equation_type_and_normalized_equation_t &Equation_Type, const vector<int> &variable_reordered, const vector<int> &equation_reordered);
//! Determine the maximum number of lead and lag for the endogenous variable in a bloc
void getVariableLeadLagByBlock(const dynamic_jacob_map &dynamic_jacobian, const vector<int> &components_set, int nb_blck_sim, t_lag_lead_vector &equation_lead_lag, t_lag_lead_vector &variable_lead_lag, const vector<int> &equation_reordered, const vector<int> &variable_reordered) const;
void getVariableLeadLagByBlock(const dynamic_jacob_map_t &dynamic_jacobian, const vector<int> &components_set, int nb_blck_sim, lag_lead_vector_t &equation_lead_lag, lag_lead_vector_t &variable_lead_lag, const vector<int> &equation_reordered, const vector<int> &variable_reordered) const;
//! Print an abstract of the block structure of the model
void printBlockDecomposition(const vector<pair<int, int> > &blocks) const;
//! Determine for each block if it is linear or not
vector<bool> BlockLinear(const t_blocks_derivatives &blocks_derivatives, const vector<int> &variable_reordered) const;
vector<bool> BlockLinear(const blocks_derivatives_t &blocks_derivatives, const vector<int> &variable_reordered) const;
virtual SymbolType getTypeByDerivID(int deriv_id) const throw (UnknownDerivIDException) = 0;
virtual int getLagByDerivID(int deriv_id) const throw (UnknownDerivIDException) = 0;

24
NumericalInitialization.cc
View File

@ -50,7 +50,7 @@ InitParamStatement::writeOutput(ostream &output, const string &basename) const
}
void
InitParamStatement::fillEvalContext(eval_context_type &eval_context) const
InitParamStatement::fillEvalContext(eval_context_t &eval_context) const
{
try
{
@ -62,7 +62,7 @@ InitParamStatement::fillEvalContext(eval_context_type &eval_context) const
}
}
InitOrEndValStatement::InitOrEndValStatement(const init_values_type &init_values_arg,
InitOrEndValStatement::InitOrEndValStatement(const init_values_t &init_values_arg,
const SymbolTable &symbol_table_arg) :
init_values(init_values_arg),
symbol_table(symbol_table_arg)
@ -70,9 +70,9 @@ InitOrEndValStatement::InitOrEndValStatement(const init_values_type &init_values
}
void
InitOrEndValStatement::fillEvalContext(eval_context_type &eval_context) const
InitOrEndValStatement::fillEvalContext(eval_context_t &eval_context) const
{
for (init_values_type::const_iterator it = init_values.begin();
for (init_values_t::const_iterator it = init_values.begin();
it != init_values.end(); it++)
{
try
@ -89,7 +89,7 @@ InitOrEndValStatement::fillEvalContext(eval_context_type &eval_context) const
void
InitOrEndValStatement::writeInitValues(ostream &output) const
{
for (init_values_type::const_iterator it = init_values.begin();
for (init_values_t::const_iterator it = init_values.begin();
it != init_values.end(); it++)
{
const int symb_id = it->first;
@ -111,7 +111,7 @@ InitOrEndValStatement::writeInitValues(ostream &output) const
}
}
InitValStatement::InitValStatement(const init_values_type &init_values_arg,
InitValStatement::InitValStatement(const init_values_t &init_values_arg,
const SymbolTable &symbol_table_arg) :
InitOrEndValStatement(init_values_arg, symbol_table_arg)
{
@ -141,7 +141,7 @@ InitValStatement::writeOutputPostInit(ostream &output) const
<<"end;" << endl;
}
EndValStatement::EndValStatement(const init_values_type &init_values_arg,
EndValStatement::EndValStatement(const init_values_t &init_values_arg,
const SymbolTable &symbol_table_arg) :
InitOrEndValStatement(init_values_arg, symbol_table_arg)
{
@ -170,7 +170,7 @@ EndValStatement::writeOutput(ostream &output, const string &basename) const
writeInitValues(output);
}
HistValStatement::HistValStatement(const hist_values_type &hist_values_arg,
HistValStatement::HistValStatement(const hist_values_t &hist_values_arg,
const SymbolTable &symbol_table_arg) :
hist_values(hist_values_arg),
symbol_table(symbol_table_arg)
@ -185,7 +185,7 @@ HistValStatement::writeOutput(ostream &output, const string &basename) const
<< "%" << endl
<< "oo_.endo_simul = zeros(M_.endo_nbr,M_.maximum_lag);" << endl;
for (hist_values_type::const_iterator it = hist_values.begin();
for (hist_values_t::const_iterator it = hist_values.begin();
it != hist_values.end(); it++)
{
int symb_id = it->first.first;
@ -237,7 +237,7 @@ InitvalFileStatement::writeOutput(ostream &output, const string &basename) const
<< "initvalf('" << filename << "');" << endl;
}
HomotopyStatement::HomotopyStatement(const homotopy_values_type &homotopy_values_arg,
HomotopyStatement::HomotopyStatement(const homotopy_values_t &homotopy_values_arg,
const SymbolTable &symbol_table_arg) :
homotopy_values(homotopy_values_arg),
symbol_table(symbol_table_arg)
@ -252,7 +252,7 @@ HomotopyStatement::writeOutput(ostream &output, const string &basename) const
<< "%" << endl
<< "options_.homotopy_values = [];" << endl;
for (homotopy_values_type::const_iterator it = homotopy_values.begin();
for (homotopy_values_t::const_iterator it = homotopy_values.begin();
it != homotopy_values.end(); it++)
{
const int &symb_id = it->first;
@ -348,7 +348,7 @@ LoadParamsAndSteadyStateStatement::writeOutput(ostream &output, const string &ba
}
void
LoadParamsAndSteadyStateStatement::fillEvalContext(eval_context_type &eval_context) const
LoadParamsAndSteadyStateStatement::fillEvalContext(eval_context_t &eval_context) const
{
for (map<int, string>::const_iterator it = content.begin();
it != content.end(); it++)

28
NumericalInitialization.hh
View File

@ -42,7 +42,7 @@ public:
virtual void checkPass(ModFileStructure &mod_file_struct);
virtual void writeOutput(ostream &output, const string &basename) const;
//! Fill eval context with parameter value
void fillEvalContext(eval_context_type &eval_context) const;
void fillEvalContext(eval_context_t &eval_context) const;
};
class InitOrEndValStatement : public Statement
@ -52,15 +52,15 @@ public:
We use a vector instead of a map, since the order of declaration matters:
an initialization can depend on a previously initialized variable inside the block
*/
typedef vector<pair<int, NodeID> > init_values_type;
typedef vector<pair<int, NodeID> > init_values_t;
protected:
const init_values_type init_values;
const init_values_t init_values;
const SymbolTable &symbol_table;
public:
InitOrEndValStatement(const init_values_type &init_values_arg,
InitOrEndValStatement(const init_values_t &init_values_arg,
const SymbolTable &symbol_table_arg);
//! Fill eval context with variables values
void fillEvalContext(eval_context_type &eval_context) const;
void fillEvalContext(eval_context_t &eval_context) const;
protected:
void writeInitValues(ostream &output) const;
};
@ -68,7 +68,7 @@ protected:
class InitValStatement : public InitOrEndValStatement
{
public:
InitValStatement(const init_values_type &init_values_arg,
InitValStatement(const init_values_t &init_values_arg,
const SymbolTable &symbol_table_arg);
virtual void writeOutput(ostream &output, const string &basename) const;
//! Writes initializations for oo_.endo_simul, oo_.exo_simul and oo_.exo_det_simul
@ -78,7 +78,7 @@ public:
class EndValStatement : public InitOrEndValStatement
{
public:
EndValStatement(const init_values_type &init_values_arg,
EndValStatement(const init_values_t &init_values_arg,
const SymbolTable &symbol_table_arg);
//! Workaround for trac ticket #35
virtual void checkPass(ModFileStructure &mod_file_struct);
@ -93,12 +93,12 @@ public:
a given initialization value in a second initialization inside the block.
Maps pairs (symbol_id, lag) to NodeID
*/
typedef map<pair<int, int>, NodeID> hist_values_type;
typedef map<pair<int, int>, NodeID> hist_values_t;
private:
const hist_values_type hist_values;
const hist_values_t hist_values;
const SymbolTable &symbol_table;
public:
HistValStatement(const hist_values_type &hist_values_arg,
HistValStatement(const hist_values_t &hist_values_arg,
const SymbolTable &symbol_table_arg);
virtual void writeOutput(ostream &output, const string &basename) const;
};
@ -117,12 +117,12 @@ class HomotopyStatement : public Statement
public:
//! Stores the declarations of homotopy_setup
/*! Order matter so we use a vector. First NodeID can be NULL if no initial value given. */
typedef vector<pair<int, pair<NodeID, NodeID> > > homotopy_values_type;
typedef vector<pair<int, pair<NodeID, NodeID> > > homotopy_values_t;
private:
const homotopy_values_type homotopy_values;
const homotopy_values_t homotopy_values;
const SymbolTable &symbol_table;
public:
HomotopyStatement(const homotopy_values_type &homotopy_values_arg,
HomotopyStatement(const homotopy_values_t &homotopy_values_arg,
const SymbolTable &symbol_table_arg);
virtual void writeOutput(ostream &output, const string &basename) const;
};
@ -148,7 +148,7 @@ public:
const SymbolTable &symbol_table_arg);
virtual void writeOutput(ostream &output, const string &basename) const;
//! Fill eval context with parameters/variables values
void fillEvalContext(eval_context_type &eval_context) const;
void fillEvalContext(eval_context_t &eval_context) const;
};
#endif

12
ParsingDriver.cc
View File

@ -656,7 +656,7 @@ ParsingDriver::combine_lag_and_restriction(string *lag)
{
int current_lag = atoi(lag->c_str());
for (SvarIdentificationStatement::svar_identification_exclusion_type::const_iterator it = svar_ident_exclusion_values.begin();
for (SvarIdentificationStatement::svar_identification_exclusion_t::const_iterator it = svar_ident_exclusion_values.begin();
it != svar_ident_exclusion_values.end(); it++)
if (it->first.first == current_lag)
error("lag " + *lag + " used more than once.");
@ -1175,7 +1175,7 @@ ParsingDriver::run_identification()
void
ParsingDriver::add_mc_filename(string *filename, string *prior)
{
for (ModelComparisonStatement::filename_list_type::iterator it = filename_list.begin();
for (ModelComparisonStatement::filename_list_t::iterator it = filename_list.begin();
it != filename_list.end(); it++)
if ((*it).first == *filename)
error("model_comparison: filename " + *filename + " declared twice");
@ -1263,8 +1263,8 @@ ParsingDriver::ms_sbvar()
void
ParsingDriver::svar()
{
OptionsList::num_options_type::const_iterator it0, it1, it2;
OptionsList::vec_int_options_type::const_iterator itv;
OptionsList::num_options_t::const_iterator it0, it1, it2;
OptionsList::vec_int_options_t::const_iterator itv;
it0 = options_list.string_options.find("ms.coefficients");
it1 = options_list.string_options.find("ms.variances");
@ -1301,7 +1301,7 @@ ParsingDriver::svar()
void
ParsingDriver::markov_switching()
{
OptionsList::num_options_type::const_iterator it0, it1;
OptionsList::num_options_t::const_iterator it0, it1;
it0 = options_list.num_options.find("ms.chain");
if (it0 == options_list.num_options.end())
@ -1780,7 +1780,7 @@ ParsingDriver::add_model_var_or_external_function(string *function_name, bool in
if (numNode == NULL && unaryNode == NULL)
error("A model variable is being treated as if it were a function (i.e., takes an argument that is not an integer).");
eval_context_type ectmp;
eval_context_t ectmp;
int model_var_arg;
double model_var_arg_dbl;
if (unaryNode == NULL)

36
ParsingDriver.hh
View File

@ -107,47 +107,47 @@ private:
//! Stores options lists
OptionsList options_list;
//! Temporary storage for trend elements
ObservationTrendsStatement::trend_elements_type trend_elements;
ObservationTrendsStatement::trend_elements_t trend_elements;
//! Temporary storage for filename list of ModelComparison
ModelComparisonStatement::filename_list_type filename_list;
ModelComparisonStatement::filename_list_t filename_list;
//! Temporary storage for list of EstimationParams (from estimated_params* statements)
vector<EstimationParams> estim_params_list;
//! Temporary storage of variances from optim_weights
OptimWeightsStatement::var_weights_type var_weights;
OptimWeightsStatement::var_weights_t var_weights;
//! Temporary storage of covariances from optim_weights
OptimWeightsStatement::covar_weights_type covar_weights;
OptimWeightsStatement::covar_weights_t covar_weights;
//! Temporary storage of variances from calib_var
CalibVarStatement::calib_var_type calib_var;
CalibVarStatement::calib_var_t calib_var;
//! Temporary storage of covariances from calib_var
CalibVarStatement::calib_covar_type calib_covar;
CalibVarStatement::calib_covar_t calib_covar;
//! Temporary storage of autocorrelations from calib_var
CalibVarStatement::calib_ac_type calib_ac;
CalibVarStatement::calib_ac_t calib_ac;
//! Temporary storage for deterministic shocks
ShocksStatement::det_shocks_type det_shocks;
ShocksStatement::det_shocks_t det_shocks;
//! Temporary storage for periods of deterministic shocks
vector<pair<int, int> > det_shocks_periods;
//! Temporary storage for values of deterministic shocks
vector<NodeID> det_shocks_values;
//! Temporary storage for variances of shocks
ShocksStatement::var_and_std_shocks_type var_shocks;
ShocksStatement::var_and_std_shocks_t var_shocks;
//! Temporary storage for standard errors of shocks
ShocksStatement::var_and_std_shocks_type std_shocks;
ShocksStatement::var_and_std_shocks_t std_shocks;
//! Temporary storage for covariances of shocks
ShocksStatement::covar_and_corr_shocks_type covar_shocks;
ShocksStatement::covar_and_corr_shocks_t covar_shocks;
//! Temporary storage for correlations of shocks
ShocksStatement::covar_and_corr_shocks_type corr_shocks;
ShocksStatement::covar_and_corr_shocks_t corr_shocks;
//! Temporary storage for Sigma_e rows
SigmaeStatement::row_type sigmae_row;
SigmaeStatement::row_t sigmae_row;
//! Temporary storage for Sigma_e matrix
SigmaeStatement::matrix_type sigmae_matrix;
SigmaeStatement::matrix_t sigmae_matrix;
//! Temporary storage for initval/endval blocks
InitOrEndValStatement::init_values_type init_values;
InitOrEndValStatement::init_values_t init_values;
//! Temporary storage for histval blocks
HistValStatement::hist_values_type hist_values;
HistValStatement::hist_values_t hist_values;
//! Temporary storage for homotopy_setup blocks
HomotopyStatement::homotopy_values_type homotopy_values;
HomotopyStatement::homotopy_values_t homotopy_values;
//! Temporary storage for svar_identification blocks
SvarIdentificationStatement::svar_identification_exclusion_type svar_ident_exclusion_values;
SvarIdentificationStatement::svar_identification_exclusion_t svar_ident_exclusion_values;
//! Temporary storage for mapping the equation number to the restrictions within an svar_identification bock
map<int, vector<int> > svar_equation_restrictions;
//! Temporary storage for restrictions in an equation within an svar_identification bock

38
Shocks.cc
View File

@ -26,7 +26,7 @@ using namespace std;
#include "Shocks.hh"
AbstractShocksStatement::AbstractShocksStatement(bool mshocks_arg,
const det_shocks_type &det_shocks_arg,
const det_shocks_t &det_shocks_arg,
const SymbolTable &symbol_table_arg) :
mshocks(mshocks_arg),
det_shocks(det_shocks_arg),
@ -39,7 +39,7 @@ AbstractShocksStatement::writeDetShocks(ostream &output) const
{
int exo_det_length = 0;
for (det_shocks_type::const_iterator it = det_shocks.begin();
for (det_shocks_t::const_iterator it = det_shocks.begin();
it != det_shocks.end(); it++)
{
int id = symbol_table.getTypeSpecificID(it->first) + 1;
@ -74,11 +74,11 @@ AbstractShocksStatement::writeDetShocks(ostream &output) const
output << "M_.exo_det_length = " << exo_det_length << ";\n";
}
ShocksStatement::ShocksStatement(const det_shocks_type &det_shocks_arg,
const var_and_std_shocks_type &var_shocks_arg,
const var_and_std_shocks_type &std_shocks_arg,
const covar_and_corr_shocks_type &covar_shocks_arg,
const covar_and_corr_shocks_type &corr_shocks_arg,
ShocksStatement::ShocksStatement(const det_shocks_t &det_shocks_arg,
const var_and_std_shocks_t &var_shocks_arg,
const var_and_std_shocks_t &std_shocks_arg,
const covar_and_corr_shocks_t &covar_shocks_arg,
const covar_and_corr_shocks_t &corr_shocks_arg,
const SymbolTable &symbol_table_arg) :
AbstractShocksStatement(false, det_shocks_arg, symbol_table_arg),
var_shocks(var_shocks_arg),
@ -108,7 +108,7 @@ ShocksStatement::writeOutput(ostream &output, const string &basename) const
}
void
ShocksStatement::writeVarOrStdShock(ostream &output, var_and_std_shocks_type::const_iterator &it,
ShocksStatement::writeVarOrStdShock(ostream &output, var_and_std_shocks_t::const_iterator &it,
bool stddev) const
{
SymbolType type = symbol_table.getType(it->first);
@ -138,7 +138,7 @@ ShocksStatement::writeVarOrStdShock(ostream &output, var_and_std_shocks_type::co
void
ShocksStatement::writeVarAndStdShocks(ostream &output) const
{
var_and_std_shocks_type::const_iterator it;
var_and_std_shocks_t::const_iterator it;
for (it = var_shocks.begin(); it != var_shocks.end(); it++)
writeVarOrStdShock(output, it, false);
@ -148,7 +148,7 @@ ShocksStatement::writeVarAndStdShocks(ostream &output) const
}
void
ShocksStatement::writeCovarOrCorrShock(ostream &output, covar_and_corr_shocks_type::const_iterator &it,
ShocksStatement::writeCovarOrCorrShock(ostream &output, covar_and_corr_shocks_t::const_iterator &it,
bool corr) const
{
SymbolType type1 = symbol_table.getType(it->first.first);
@ -183,7 +183,7 @@ ShocksStatement::writeCovarOrCorrShock(ostream &output, covar_and_corr_shocks_ty
void
ShocksStatement::writeCovarAndCorrShocks(ostream &output) const
{
covar_and_corr_shocks_type::const_iterator it;
covar_and_corr_shocks_t::const_iterator it;
for (it = covar_shocks.begin(); it != covar_shocks.end(); it++)
writeCovarOrCorrShock(output, it, false);
@ -199,30 +199,30 @@ ShocksStatement::checkPass(ModFileStructure &mod_file_struct)
mod_file_struct.shocks_present = true;
// Determine if there is a calibrated measurement error
for (var_and_std_shocks_type::const_iterator it = var_shocks.begin();
for (var_and_std_shocks_t::const_iterator it = var_shocks.begin();
it != var_shocks.end(); it++)
if (symbol_table.isObservedVariable(it->first))
mod_file_struct.calibrated_measurement_errors = true;
for (var_and_std_shocks_type::const_iterator it = std_shocks.begin();
for (var_and_std_shocks_t::const_iterator it = std_shocks.begin();
it != std_shocks.end(); it++)
if (symbol_table.isObservedVariable(it->first))
mod_file_struct.calibrated_measurement_errors = true;
for (covar_and_corr_shocks_type::const_iterator it = covar_shocks.begin();
for (covar_and_corr_shocks_t::const_iterator it = covar_shocks.begin();
it != covar_shocks.end(); it++)
if (symbol_table.isObservedVariable(it->first.first)
|| symbol_table.isObservedVariable(it->first.second))
mod_file_struct.calibrated_measurement_errors = true;
for (covar_and_corr_shocks_type::const_iterator it = corr_shocks.begin();
for (covar_and_corr_shocks_t::const_iterator it = corr_shocks.begin();
it != corr_shocks.end(); it++)
if (symbol_table.isObservedVariable(it->first.first)
|| symbol_table.isObservedVariable(it->first.second))
mod_file_struct.calibrated_measurement_errors = true;
}
MShocksStatement::MShocksStatement(const det_shocks_type &det_shocks_arg,
MShocksStatement::MShocksStatement(const det_shocks_t &det_shocks_arg,
const SymbolTable &symbol_table_arg) :
AbstractShocksStatement(true, det_shocks_arg, symbol_table_arg)
{
@ -248,7 +248,7 @@ MShocksStatement::checkPass(ModFileStructure &mod_file_struct)
mod_file_struct.shocks_present = true;
}
ConditionalForecastPathsStatement::ConditionalForecastPathsStatement(const AbstractShocksStatement::det_shocks_type &paths_arg, const SymbolTable &symbol_table_arg) :
ConditionalForecastPathsStatement::ConditionalForecastPathsStatement(const AbstractShocksStatement::det_shocks_t &paths_arg, const SymbolTable &symbol_table_arg) :
paths(paths_arg),
symbol_table(symbol_table_arg),
path_length(-1)
@ -258,7 +258,7 @@ ConditionalForecastPathsStatement::ConditionalForecastPathsStatement(const Abstr
void
ConditionalForecastPathsStatement::checkPass(ModFileStructure &mod_file_struct)
{
for (AbstractShocksStatement::det_shocks_type::const_iterator it = paths.begin();
for (AbstractShocksStatement::det_shocks_t::const_iterator it = paths.begin();
it != paths.end(); it++)
{
int this_path_length = 0;
@ -285,7 +285,7 @@ ConditionalForecastPathsStatement::writeOutput(ostream &output, const string &ba
int k = 1;
for (AbstractShocksStatement::det_shocks_type::const_iterator it = paths.begin();
for (AbstractShocksStatement::det_shocks_t::const_iterator it = paths.begin();
it != paths.end(); it++)
{
output << "constrained_vars_ = strvcat(constrained_vars_, '" << it->first << "');" << endl;

34
Shocks.hh
View File

@ -39,37 +39,37 @@ public:
int period2;
NodeID value;
};
typedef map<int, vector<DetShockElement> > det_shocks_type;
typedef map<int, vector<DetShockElement> > det_shocks_t;
protected:
//! Is this statement a "mshocks" statement ? (instead of a "shocks" statement)
const bool mshocks;
const det_shocks_type det_shocks;
const det_shocks_t det_shocks;
const SymbolTable &symbol_table;
void writeDetShocks(ostream &output) const;
AbstractShocksStatement(bool mshocks_arg,
const det_shocks_type &det_shocks_arg,
const det_shocks_t &det_shocks_arg,
const SymbolTable &symbol_table_arg);
};
class ShocksStatement : public AbstractShocksStatement
{
public:
typedef map<int, NodeID> var_and_std_shocks_type;
typedef map<pair<int, int>, NodeID> covar_and_corr_shocks_type;
typedef map<int, NodeID> var_and_std_shocks_t;
typedef map<pair<int, int>, NodeID> covar_and_corr_shocks_t;
private:
const var_and_std_shocks_type var_shocks, std_shocks;
const covar_and_corr_shocks_type covar_shocks, corr_shocks;
void writeVarOrStdShock(ostream &output, var_and_std_shocks_type::const_iterator &it, bool stddev) const;
const var_and_std_shocks_t var_shocks, std_shocks;
const covar_and_corr_shocks_t covar_shocks, corr_shocks;
void writeVarOrStdShock(ostream &output, var_and_std_shocks_t::const_iterator &it, bool stddev) const;
void writeVarAndStdShocks(ostream &output) const;
void writeCovarOrCorrShock(ostream &output, covar_and_corr_shocks_type::const_iterator &it, bool corr) const;
void writeCovarOrCorrShock(ostream &output, covar_and_corr_shocks_t::const_iterator &it, bool corr) const;
void writeCovarAndCorrShocks(ostream &output) const;
public:
ShocksStatement(const det_shocks_type &det_shocks_arg,
const var_and_std_shocks_type &var_shocks_arg,
const var_and_std_shocks_type &std_shocks_arg,
const covar_and_corr_shocks_type &covar_shocks_arg,
const covar_and_corr_shocks_type &corr_shocks_arg,
ShocksStatement(const det_shocks_t &det_shocks_arg,
const var_and_std_shocks_t &var_shocks_arg,
const var_and_std_shocks_t &std_shocks_arg,
const covar_and_corr_shocks_t &covar_shocks_arg,
const covar_and_corr_shocks_t &corr_shocks_arg,
const SymbolTable &symbol_table_arg);
virtual void writeOutput(ostream &output, const string &basename) const;
virtual void checkPass(ModFileStructure &mod_file_struct);
@ -78,7 +78,7 @@ public:
class MShocksStatement : public AbstractShocksStatement
{
public:
MShocksStatement(const det_shocks_type &det_shocks_arg,
MShocksStatement(const det_shocks_t &det_shocks_arg,
const SymbolTable &symbol_table_arg);
virtual void writeOutput(ostream &output, const string &basename) const;
virtual void checkPass(ModFileStructure &mod_file_struct);
@ -87,11 +87,11 @@ public:
class ConditionalForecastPathsStatement : public Statement
{
private:
const AbstractShocksStatement::det_shocks_type paths;
const AbstractShocksStatement::det_shocks_t paths;
const SymbolTable &symbol_table;
int path_length;
public:
ConditionalForecastPathsStatement(const AbstractShocksStatement::det_shocks_type &paths_arg,
ConditionalForecastPathsStatement(const AbstractShocksStatement::det_shocks_t &paths_arg,
const SymbolTable &symbol_table_arg);
virtual void checkPass(ModFileStructure &mod_file_struct);
virtual void writeOutput(ostream &output, const string &basename) const;

10
SigmaeInitialization.cc
View File

@ -19,18 +19,18 @@
#include "SigmaeInitialization.hh"
SigmaeStatement::SigmaeStatement(const matrix_type &matrix_arg) throw (MatrixFormException) :
SigmaeStatement::SigmaeStatement(const matrix_t &matrix_arg) throw (MatrixFormException) :
matrix(matrix_arg),
matrix_form(determineMatrixForm(matrix))
{
}
SigmaeStatement::matrix_form_type
SigmaeStatement::determineMatrixForm(const matrix_type &matrix) throw (MatrixFormException)
SigmaeStatement::matrix_form_t
SigmaeStatement::determineMatrixForm(const matrix_t &matrix) throw (MatrixFormException)
{
size_t nbe;
int inc;
matrix_form_type type;
matrix_form_t type;
// Checking if first or last row has one element.
if (matrix.front().size() == 1)
{
@ -50,7 +50,7 @@ SigmaeStatement::determineMatrixForm(const matrix_type &matrix) throw (MatrixFor
// Checking if matrix is triangular (upper or lower):
// each row has one element more or less than the previous one
// and first or last one has one element.
matrix_type::const_iterator ir;
matrix_t::const_iterator ir;
for (ir = matrix.begin(), ir++; ir != matrix.end(); ir++, nbe += inc)
if (ir->size() != nbe)
throw MatrixFormException();

16
SigmaeInitialization.hh
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2003-2008 Dynare Team
* Copyright (C) 2003-2010 Dynare Team
*
* This file is part of Dynare.
*
@ -33,15 +33,15 @@ class SigmaeStatement : public Statement
{
public:
//! Matrix form (lower or upper triangular) enum
enum matrix_form_type
enum matrix_form_t
{
eLower = 0, //!< Lower triangular matrix
eUpper = 1 //!< Upper triangular matrix
};
//! Type of a matrix row
typedef vector<NodeID> row_type;
typedef vector<NodeID> row_t;
//! Type of a complete matrix
typedef vector<row_type> matrix_type;
typedef vector<row_t> matrix_t;
//! An exception indicating that a matrix is neither upper triangular nor lower triangular
class MatrixFormException
@ -49,16 +49,16 @@ public:
};
private:
//! The matrix
const matrix_type matrix;
const matrix_t matrix;
//! Matrix form (lower or upper)
const matrix_form_type matrix_form;
const matrix_form_t matrix_form;
//! Returns the type (upper or lower triangular) of a given matrix
/*! Throws an exception if it is neither upper triangular nor lower triangular */
static matrix_form_type determineMatrixForm(const matrix_type &matrix) throw (MatrixFormException);
static matrix_form_t determineMatrixForm(const matrix_t &matrix) throw (MatrixFormException);
public:
SigmaeStatement(const matrix_type &matrix_arg) throw (MatrixFormException);
SigmaeStatement(const matrix_t &matrix_arg) throw (MatrixFormException);
virtual void writeOutput(ostream &output, const string &basename) const;
};

20
Statement.cc
View File

@ -70,24 +70,24 @@ NativeStatement::writeOutput(ostream &output, const string &basename) const
void
OptionsList::writeOutput(ostream &output) const
{
for (num_options_type::const_iterator it = num_options.begin();
for (num_options_t::const_iterator it = num_options.begin();
it != num_options.end(); it++)
output << "options_." << it->first << " = " << it->second << ";" << endl;
for (paired_num_options_type::const_iterator it = paired_num_options.begin();
for (paired_num_options_t::const_iterator it = paired_num_options.begin();
it != paired_num_options.end(); it++)
output << "options_." << it->first << " = [" << it->second.first << "; "
<< it->second.second << "];" << endl;
for (string_options_type::const_iterator it = string_options.begin();
for (string_options_t::const_iterator it = string_options.begin();
it != string_options.end(); it++)
output << "options_." << it->first << " = '" << it->second << "';" << endl;
for (symbol_list_options_type::const_iterator it = symbol_list_options.begin();
for (symbol_list_options_t::const_iterator it = symbol_list_options.begin();
it != symbol_list_options.end(); it++)
it->second.writeOutput("options_." + it->first, output);
for (vec_int_options_type::const_iterator it = vector_int_options.begin();
for (vec_int_options_t::const_iterator it = vector_int_options.begin();
it != vector_int_options.end(); it++)
{
output << "options_." << it->first << " = ";
@ -109,24 +109,24 @@ OptionsList::writeOutput(ostream &output, const string &option_group) const
{
output << option_group << " = struct();" << endl;
for (num_options_type::const_iterator it = num_options.begin();
for (num_options_t::const_iterator it = num_options.begin();
it != num_options.end(); it++)
output << option_group << "." << it->first << " = " << it->second << ";" << endl;
for (paired_num_options_type::const_iterator it = paired_num_options.begin();
for (paired_num_options_t::const_iterator it = paired_num_options.begin();
it != paired_num_options.end(); it++)
output << option_group << "." << it->first << " = [" << it->second.first << "; "
<< it->second.second << "];" << endl;
for (string_options_type::const_iterator it = string_options.begin();
for (string_options_t::const_iterator it = string_options.begin();
it != string_options.end(); it++)
output << option_group << "." << it->first << " = '" << it->second << "';" << endl;
for (symbol_list_options_type::const_iterator it = symbol_list_options.begin();
for (symbol_list_options_t::const_iterator it = symbol_list_options.begin();
it != symbol_list_options.end(); it++)
it->second.writeOutput(option_group + "." + it->first, output);
for (vec_int_options_type::const_iterator it = vector_int_options.begin();
for (vec_int_options_t::const_iterator it = vector_int_options.begin();
it != vector_int_options.end(); it++)
{
output << option_group << "." << it->first << " = ";

20
Statement.hh
View File

@ -104,16 +104,16 @@ public:
class OptionsList
{
public:
typedef map<string, string> num_options_type;
typedef map<string, pair<string, string> > paired_num_options_type;
typedef map<string, string> string_options_type;
typedef map<string, SymbolList> symbol_list_options_type;
typedef map<string, vector<int> > vec_int_options_type;
num_options_type num_options;
paired_num_options_type paired_num_options;
string_options_type string_options;
symbol_list_options_type symbol_list_options;
vec_int_options_type vector_int_options;
typedef map<string, string> num_options_t;
typedef map<string, pair<string, string> > paired_num_options_t;
typedef map<string, string> string_options_t;
typedef map<string, SymbolList> symbol_list_options_t;
typedef map<string, vector<int> > vec_int_options_t;
num_options_t num_options;
paired_num_options_t paired_num_options;
string_options_t string_options;
symbol_list_options_t symbol_list_options;
vec_int_options_t vector_int_options;
void writeOutput(ostream &output) const;
void writeOutput(ostream &output, const string &option_group) const;
void clear();

84
StaticModel.cc
View File

@ -46,9 +46,9 @@ StaticModel::StaticModel(SymbolTable &symbol_table_arg,
}
void
StaticModel::compileDerivative(ofstream &code_file, int eq, int symb_id, map_idx_type &map_idx) const
StaticModel::compileDerivative(ofstream &code_file, int eq, int symb_id, map_idx_t &map_idx) const
{
first_derivatives_type::const_iterator it = first_derivatives.find(make_pair(eq, symbol_table.getID(eEndogenous, symb_id)));
first_derivatives_t::const_iterator it = first_derivatives.find(make_pair(eq, symbol_table.getID(eEndogenous, symb_id)));
if (it != first_derivatives.end())
(it->second)->compile(code_file, false, temporary_terms, map_idx, false, false);
else
@ -59,7 +59,7 @@ StaticModel::compileDerivative(ofstream &code_file, int eq, int symb_id, map_idx
}
void
StaticModel::compileChainRuleDerivative(ofstream &code_file, int eqr, int varr, int lag, map_idx_type &map_idx) const
StaticModel::compileChainRuleDerivative(ofstream &code_file, int eqr, int varr, int lag, map_idx_t &map_idx) const
{
map<pair<int, pair<int, int> >, NodeID>::const_iterator it = first_chain_rule_derivatives.find(make_pair(eqr, make_pair(varr, lag)));
if (it != first_chain_rule_derivatives.end())
@ -87,16 +87,16 @@ StaticModel::computeTemporaryTermsOrdered()
map<NodeID, pair<int, int> > first_occurence;
map<NodeID, int> reference_count;
BinaryOpNode *eq_node;
first_derivatives_type::const_iterator it;
first_chain_rule_derivatives_type::const_iterator it_chr;
first_derivatives_t::const_iterator it;
first_chain_rule_derivatives_t::const_iterator it_chr;
ostringstream tmp_s;
v_temporary_terms.clear();
map_idx.clear();
unsigned int nb_blocks = getNbBlocks();
v_temporary_terms = vector< vector<temporary_terms_type> >(nb_blocks);
v_temporary_terms = vector< vector<temporary_terms_t> >(nb_blocks);
v_temporary_terms_inuse = vector<temporary_terms_inuse_type>(nb_blocks);
v_temporary_terms_inuse = vector<temporary_terms_inuse_t>(nb_blocks);
temporary_terms.clear();
if (!global_temporary_terms)
@ -109,7 +109,7 @@ StaticModel::computeTemporaryTermsOrdered()
unsigned int block_size = getBlockSize(block);
unsigned int block_nb_mfs = getBlockMfs(block);
unsigned int block_nb_recursives = block_size - block_nb_mfs;
v_temporary_terms[block] = vector<temporary_terms_type>(block_size);
v_temporary_terms[block] = vector<temporary_terms_t>(block_size);
for (unsigned int i = 0; i < block_size; i++)
{
if (i < block_nb_recursives && isBlockEquationRenormalized(block, i))
@ -120,7 +120,7 @@ StaticModel::computeTemporaryTermsOrdered()
eq_node->computeTemporaryTerms(reference_count, temporary_terms, first_occurence, block, v_temporary_terms, i);
}
}
for (t_block_derivatives_equation_variable_laglead_nodeid::const_iterator it = blocks_derivatives[block].begin(); it != (blocks_derivatives[block]).end(); it++)
for (block_derivatives_equation_variable_laglead_nodeid_t::const_iterator it = blocks_derivatives[block].begin(); it != (blocks_derivatives[block]).end(); it++)
{
NodeID id = it->second.second;
id->computeTemporaryTerms(reference_count, temporary_terms, first_occurence, block, v_temporary_terms, block_size-1);
@ -138,7 +138,7 @@ StaticModel::computeTemporaryTermsOrdered()
unsigned int block_size = getBlockSize(block);
unsigned int block_nb_mfs = getBlockMfs(block);
unsigned int block_nb_recursives = block_size - block_nb_mfs;
v_temporary_terms[block] = vector<temporary_terms_type>(block_size);
v_temporary_terms[block] = vector<temporary_terms_t>(block_size);
for (unsigned int i = 0; i < block_size; i++)
{
if (i < block_nb_recursives && isBlockEquationRenormalized(block, i))
@ -149,7 +149,7 @@ StaticModel::computeTemporaryTermsOrdered()
eq_node->computeTemporaryTerms(reference_count, temporary_terms, first_occurence, block, v_temporary_terms, i);
}
}
for (t_block_derivatives_equation_variable_laglead_nodeid::const_iterator it = blocks_derivatives[block].begin(); it != (blocks_derivatives[block]).end(); it++)
for (block_derivatives_equation_variable_laglead_nodeid_t::const_iterator it = blocks_derivatives[block].begin(); it != (blocks_derivatives[block]).end(); it++)
{
NodeID id = it->second.second;
id->computeTemporaryTerms(reference_count, temporary_terms, first_occurence, block, v_temporary_terms, block_size-1);
@ -173,13 +173,13 @@ StaticModel::computeTemporaryTermsOrdered()
eq_node->collectTemporary_terms(temporary_terms, temporary_terms_in_use, block);
}
}
for (t_block_derivatives_equation_variable_laglead_nodeid::const_iterator it = blocks_derivatives[block].begin(); it != (blocks_derivatives[block]).end(); it++)
for (block_derivatives_equation_variable_laglead_nodeid_t::const_iterator it = blocks_derivatives[block].begin(); it != (blocks_derivatives[block]).end(); it++)
{
NodeID id = it->second.second;
id->collectTemporary_terms(temporary_terms, temporary_terms_in_use, block);
}
for (int i = 0; i < (int) getBlockSize(block); i++)
for (temporary_terms_type::const_iterator it = v_temporary_terms[block][i].begin();
for (temporary_terms_t::const_iterator it = v_temporary_terms[block][i].begin();
it != v_temporary_terms[block][i].end(); it++)
(*it)->collectTemporary_terms(temporary_terms, temporary_terms_in_use, block);
v_temporary_terms_inuse[block] = temporary_terms_in_use;
@ -193,7 +193,7 @@ StaticModel::computeTemporaryTermsMapping()
{
// Add a mapping form node ID to temporary terms order
int j = 0;
for (temporary_terms_type::const_iterator it = temporary_terms.begin();
for (temporary_terms_t::const_iterator it = temporary_terms.begin();
it != temporary_terms.end(); it++)
map_idx[(*it)->idx] = j++;
}
@ -206,7 +206,7 @@ StaticModel::writeModelEquationsOrdered_M(const string &static_basename) const
NodeID lhs = NULL, rhs = NULL;
BinaryOpNode *eq_node;
map<NodeID, int> reference_count;
temporary_terms_type local_temporary_terms;
temporary_terms_t local_temporary_terms;
ofstream output;
int nze;
vector<int> feedback_variables;
@ -270,7 +270,7 @@ StaticModel::writeModelEquationsOrdered_M(const string &static_basename) const
if (v_temporary_terms_inuse[block].size())
{
tmp_output.str("");
for (temporary_terms_inuse_type::const_iterator it = v_temporary_terms_inuse[block].begin();
for (temporary_terms_inuse_t::const_iterator it = v_temporary_terms_inuse[block].begin();
it != v_temporary_terms_inuse[block].end(); it++)
tmp_output << " T" << *it;
output << " global" << tmp_output.str() << ";\n";
@ -284,12 +284,12 @@ StaticModel::writeModelEquationsOrdered_M(const string &static_basename) const
{
if (!global_temporary_terms)
local_temporary_terms = v_temporary_terms[block][i];
temporary_terms_type tt2;
temporary_terms_t tt2;
tt2.clear();
if (v_temporary_terms[block].size())
{
output << " " << "% //Temporary variables" << endl;
for (temporary_terms_type::const_iterator it = v_temporary_terms[block][i].begin();
for (temporary_terms_t::const_iterator it = v_temporary_terms[block][i].begin();
it != v_temporary_terms[block][i].end(); it++)
{
output << " " << sps;
@ -378,7 +378,7 @@ StaticModel::writeModelEquationsOrdered_M(const string &static_basename) const
case SOLVE_FORWARD_SIMPLE:
case SOLVE_BACKWARD_COMPLETE:
case SOLVE_FORWARD_COMPLETE:
for (t_block_derivatives_equation_variable_laglead_nodeid::const_iterator it = blocks_derivatives[block].begin(); it != (blocks_derivatives[block]).end(); it++)
for (block_derivatives_equation_variable_laglead_nodeid_t::const_iterator it = blocks_derivatives[block].begin(); it != (blocks_derivatives[block]).end(); it++)
{
unsigned int eq = it->first.first;
unsigned int var = it->first.second;
@ -401,7 +401,7 @@ StaticModel::writeModelEquationsOrdered_M(const string &static_basename) const
}
void
StaticModel::writeModelEquationsCode(const string file_name, const string bin_basename, map_idx_type map_idx) const
StaticModel::writeModelEquationsCode(const string file_name, const string bin_basename, map_idx_t map_idx) const
{
ostringstream tmp_output;
@ -443,7 +443,7 @@ StaticModel::writeModelEquationsCode(const string file_name, const string bin_ba
// Add a mapping form node ID to temporary terms order
int j = 0;
for (temporary_terms_type::const_iterator it = temporary_terms.begin();
for (temporary_terms_t::const_iterator it = temporary_terms.begin();
it != temporary_terms.end(); it++)
map_idx[(*it)->idx] = j++;
compileTemporaryTerms(code_file, temporary_terms, map_idx, false, false);
@ -456,7 +456,7 @@ StaticModel::writeModelEquationsCode(const string file_name, const string bin_ba
vector<vector<pair<int, int> > > derivatives;
derivatives.resize(symbol_table.endo_nbr());
count_u = symbol_table.endo_nbr();
for (first_derivatives_type::const_iterator it = first_derivatives.begin();
for (first_derivatives_t::const_iterator it = first_derivatives.begin();
it != first_derivatives.end(); it++)
{
int deriv_id = it->first.second;
@ -511,7 +511,7 @@ StaticModel::writeModelEquationsCode(const string file_name, const string bin_ba
}
void
StaticModel::writeModelEquationsCode_Block(const string file_name, const string bin_basename, map_idx_type map_idx) const
StaticModel::writeModelEquationsCode_Block(const string file_name, const string bin_basename, map_idx_t map_idx) const
{
struct Uff_l
{
@ -588,11 +588,11 @@ StaticModel::writeModelEquationsCode_Block(const string file_name, const string
for (i = 0; i < (int) block_size; i++)
{
//The Temporary terms
temporary_terms_type tt2;
temporary_terms_t tt2;
tt2.clear();
if (v_temporary_terms[block].size())
{
for (temporary_terms_type::const_iterator it = v_temporary_terms[block][i].begin();
for (temporary_terms_t::const_iterator it = v_temporary_terms[block][i].begin();
it != v_temporary_terms[block][i].end(); it++)
{
FNUMEXPR_ fnumexpr(TemporaryTerm, (int)(map_idx.find((*it)->idx)->second));
@ -684,7 +684,7 @@ StaticModel::writeModelEquationsCode_Block(const string file_name, const string
case SOLVE_BACKWARD_COMPLETE:
case SOLVE_FORWARD_COMPLETE:
count_u = feedback_variables.size();
for (t_block_derivatives_equation_variable_laglead_nodeid::const_iterator it = blocks_derivatives[block].begin(); it != (blocks_derivatives[block]).end(); it++)
for (block_derivatives_equation_variable_laglead_nodeid_t::const_iterator it = blocks_derivatives[block].begin(); it != (blocks_derivatives[block]).end(); it++)
{
unsigned int eq = it->first.first;
unsigned int var = it->first.second;
@ -784,7 +784,7 @@ StaticModel::Write_Inf_To_Bin_File_Block(const string &static_basename, const st
unsigned int block_size = getBlockSize(num);
unsigned int block_mfs = getBlockMfs(num);
unsigned int block_recursive = block_size - block_mfs;
for (t_block_derivatives_equation_variable_laglead_nodeid::const_iterator it = blocks_derivatives[num].begin(); it != (blocks_derivatives[num]).end(); it++)
for (block_derivatives_equation_variable_laglead_nodeid_t::const_iterator it = blocks_derivatives[num].begin(); it != (blocks_derivatives[num]).end(); it++)
{
unsigned int eq = it->first.first;
unsigned int var = it->first.second;
@ -819,7 +819,7 @@ map<pair<int, pair<int, int > >, NodeID>
StaticModel::collect_first_order_derivatives_endogenous()
{
map<pair<int, pair<int, int > >, NodeID> endo_derivatives;
for (first_derivatives_type::iterator it2 = first_derivatives.begin();
for (first_derivatives_t::iterator it2 = first_derivatives.begin();
it2 != first_derivatives.end(); it2++)
{
if (getTypeByDerivID(it2->first.second) == eEndogenous)
@ -834,7 +834,7 @@ StaticModel::collect_first_order_derivatives_endogenous()
}
void
StaticModel::computingPass(const eval_context_type &eval_context, bool no_tmp_terms, bool hessian, bool block, bool bytecode)
StaticModel::computingPass(const eval_context_t &eval_context, bool no_tmp_terms, bool hessian, bool block, bool bytecode)
{
// Compute derivatives w.r. to all endogenous, and possibly exogenous and exogenous deterministic
set<int> vars;
@ -857,7 +857,7 @@ StaticModel::computingPass(const eval_context_type &eval_context, bool no_tmp_te
if (block)
{
jacob_map contemporaneous_jacobian, static_jacobian;
jacob_map_t contemporaneous_jacobian, static_jacobian;
// for each block contains pair<Size, Feddback_variable>
vector<pair<int, int> > blocks;
@ -948,7 +948,7 @@ StaticModel::writeStaticMFile(const string &func_name) const
<< endl;
// Write Jacobian w.r. to endogenous only
for (first_derivatives_type::const_iterator it = first_derivatives.begin();
for (first_derivatives_t::const_iterator it = first_derivatives.begin();
it != first_derivatives.end(); it++)
{
int eq = it->first.first;
@ -977,7 +977,7 @@ StaticModel::writeStaticMFile(const string &func_name) const
// Write Hessian w.r. to endogenous only (only if 2nd order derivatives have been computed)
int k = 0; // Keep the line of a 2nd derivative in v2
for (second_derivatives_type::const_iterator it = second_derivatives.begin();
for (second_derivatives_t::const_iterator it = second_derivatives.begin();
it != second_derivatives.end(); it++)
{
int eq = it->first.first;
@ -1195,14 +1195,14 @@ StaticModel::get_Derivatives(int block)
}
void
StaticModel::computeChainRuleJacobian(t_blocks_derivatives &blocks_derivatives)
StaticModel::computeChainRuleJacobian(blocks_derivatives_t &blocks_derivatives)
{
map<int, NodeID> recursive_variables;
unsigned int nb_blocks = getNbBlocks();
blocks_derivatives = t_blocks_derivatives(nb_blocks);
blocks_derivatives = blocks_derivatives_t(nb_blocks);
for (unsigned int block = 0; block < nb_blocks; block++)
{
t_block_derivatives_equation_variable_laglead_nodeid tmp_derivatives;
block_derivatives_equation_variable_laglead_nodeid_t tmp_derivatives;
recursive_variables.clear();
BlockSimulationType simulation_type = getBlockSimulationType(block);
int block_size = getBlockSize(block);
@ -1210,7 +1210,7 @@ StaticModel::computeChainRuleJacobian(t_blocks_derivatives &blocks_derivatives)
int block_nb_recursives = block_size - block_nb_mfs;
if (simulation_type == SOLVE_TWO_BOUNDARIES_COMPLETE || simulation_type == SOLVE_TWO_BOUNDARIES_SIMPLE)
{
blocks_derivatives.push_back(t_block_derivatives_equation_variable_laglead_nodeid(0));
blocks_derivatives.push_back(block_derivatives_equation_variable_laglead_nodeid_t(0));
for (int i = 0; i < block_nb_recursives; i++)
{
if (getBlockEquationType(block, i) == E_EVALUATE_S)
@ -1247,7 +1247,7 @@ StaticModel::computeChainRuleJacobian(t_blocks_derivatives &blocks_derivatives)
else if (simulation_type == SOLVE_BACKWARD_SIMPLE || simulation_type == SOLVE_FORWARD_SIMPLE
|| simulation_type == SOLVE_BACKWARD_COMPLETE || simulation_type == SOLVE_FORWARD_COMPLETE)
{
blocks_derivatives.push_back(t_block_derivatives_equation_variable_laglead_nodeid(0));
blocks_derivatives.push_back(block_derivatives_equation_variable_laglead_nodeid_t(0));
for (int i = 0; i < block_nb_recursives; i++)
{
if (getBlockEquationType(block, i) == E_EVALUATE_S)
@ -1291,10 +1291,10 @@ StaticModel::collect_block_first_order_derivatives()
variable_2_block[getBlockVariableID(block, i)] = block;
}
}
derivative_endo = vector<t_derivative>(nb_blocks);
derivative_endo = vector<derivative_t>(nb_blocks);
endo_max_leadlag_block = vector<pair<int, int> >(nb_blocks, make_pair(0, 0));
max_leadlag_block = vector<pair<int, int> >(nb_blocks, make_pair(0, 0));
for (first_derivatives_type::iterator it2 = first_derivatives.begin();
for (first_derivatives_t::iterator it2 = first_derivatives.begin();
it2 != first_derivatives.end(); it2++)
{
int eq = it2->first.first;
@ -1306,8 +1306,8 @@ StaticModel::collect_block_first_order_derivatives()
max_leadlag_block[block_eq] = make_pair(0, 0);
endo_max_leadlag_block[block_eq] = make_pair(0, 0);
endo_max_leadlag_block[block_eq] = make_pair(0, 0);
t_derivative tmp_derivative;
t_lag_var lag_var;
derivative_t tmp_derivative;
lag_var_t lag_var;
if (getTypeByDerivID(it2->first.second) == eEndogenous && block_eq == block_var)
{
tmp_derivative = derivative_endo[block_eq];
@ -1320,7 +1320,7 @@ StaticModel::collect_block_first_order_derivatives()
void
StaticModel::writeChainRuleDerivative(ostream &output, int eqr, int varr, int lag,
ExprNodeOutputType output_type,
const temporary_terms_type &temporary_terms) const
const temporary_terms_t &temporary_terms) const
{
map<pair<int, pair<int, int> >, NodeID>::const_iterator it = first_chain_rule_derivatives.find(make_pair(eqr, make_pair(varr, lag)));
if (it != first_chain_rule_derivatives.end())

46
StaticModel.hh
View File

@ -37,15 +37,15 @@ private:
vector<pair<int, int> > inv_deriv_id_table;
//! Temporary terms for the file containing parameters dervicatives
temporary_terms_type params_derivs_temporary_terms;
temporary_terms_t params_derivs_temporary_terms;
//! Temporary terms for block decomposed models
vector<vector<temporary_terms_type> > v_temporary_terms;
vector<vector<temporary_terms_t> > v_temporary_terms;
vector<temporary_terms_inuse_type> v_temporary_terms_inuse;
vector<temporary_terms_inuse_t> v_temporary_terms_inuse;
typedef map< pair< int, pair< int, int> >, NodeID> first_chain_rule_derivatives_type;
first_chain_rule_derivatives_type first_chain_rule_derivatives;
typedef map< pair< int, pair< int, int> >, NodeID> first_chain_rule_derivatives_t;
first_chain_rule_derivatives_t first_chain_rule_derivatives;
//! Writes static model file (standard Matlab version)
void writeStaticMFile(const string &static_basename) const;
@ -61,10 +61,10 @@ private:
void writeModelEquationsOrdered_M(const string &dynamic_basename) const;
//! Writes the code of the Block reordred structure of the model in virtual machine bytecode
void writeModelEquationsCode_Block(const string file_name, const string bin_basename, map_idx_type map_idx) const;
void writeModelEquationsCode_Block(const string file_name, const string bin_basename, map_idx_t map_idx) const;
//! Writes the code of the model in virtual machine bytecode
void writeModelEquationsCode(const string file_name, const string bin_basename, map_idx_type map_idx) const;
void writeModelEquationsCode(const string file_name, const string bin_basename, map_idx_t map_idx) const;
//! Computes jacobian and prepares for equation normalization
@ -72,9 +72,9 @@ private:
- computes the jacobian for the model w.r. to contemporaneous variables
- removes edges of the incidence matrix when derivative w.r. to the corresponding variable is too close to zero (below the cutoff)
*/
void evaluateJacobian(const eval_context_type &eval_context, jacob_map *j_m, bool dynamic);
void evaluateJacobian(const eval_context_t &eval_context, jacob_map_t *j_m, bool dynamic);
map_idx_type map_idx;
map_idx_t map_idx;
//! sorts the temporary terms in the blocks order
void computeTemporaryTermsOrdered();
@ -82,9 +82,9 @@ private:
void computeTemporaryTermsMapping();
//! Write derivative code of an equation w.r. to a variable
void compileDerivative(ofstream &code_file, int eq, int symb_id, map_idx_type &map_idx) const;
void compileDerivative(ofstream &code_file, int eq, int symb_id, map_idx_t &map_idx) const;
//! Write chain rule derivative code of an equation w.r. to a variable
void compileChainRuleDerivative(ofstream &code_file, int eq, int var, int lag, map_idx_type &map_idx) const;
void compileChainRuleDerivative(ofstream &code_file, int eq, int var, int lag, map_idx_t &map_idx) const;
//! Get the type corresponding to a derivation ID
virtual SymbolType getTypeByDerivID(int deriv_id) const throw (UnknownDerivIDException);
@ -97,7 +97,7 @@ private:
//! return a map on the block jacobian
map<pair<pair<int, pair<int, int> >, pair<int, int> >, int> get_Derivatives(int block);
//! Computes chain rule derivatives of the Jacobian w.r. to endogenous variables
void computeChainRuleJacobian(t_blocks_derivatives &blocks_derivatives);
void computeChainRuleJacobian(blocks_derivatives_t &blocks_derivatives);
//! Collect only the first derivatives
map<pair<int, pair<int, int> >, NodeID> collect_first_order_derivatives_endogenous();
@ -110,7 +110,7 @@ private:
void hessianHelper(ostream &output, int row_nb, int col_nb, ExprNodeOutputType output_type) const;
//! Write chain rule derivative of a recursive equation w.r. to a variable
void writeChainRuleDerivative(ostream &output, int eq, int var, int lag, ExprNodeOutputType output_type, const temporary_terms_type &temporary_terms) const;
void writeChainRuleDerivative(ostream &output, int eq, int var, int lag, ExprNodeOutputType output_type, const temporary_terms_t &temporary_terms) const;
//! Collecte the derivatives w.r. to endogenous of the block, to endogenous of previouys blocks and to exogenous
void collect_block_first_order_derivatives();
@ -123,29 +123,29 @@ protected:
vector<int> equation_reordered, variable_reordered, inv_equation_reordered, inv_variable_reordered;
//! Vector describing equations: BlockSimulationType, if BlockSimulationType == EVALUATE_s then a NodeID on the new normalized equation
t_equation_type_and_normalized_equation equation_type_and_normalized_equation;
equation_type_and_normalized_equation_t equation_type_and_normalized_equation;
//! for each block contains pair< Simulation_Type, pair < Block_Size, Recursive_part_Size > >
t_block_type_firstequation_size_mfs block_type_firstequation_size_mfs;
block_type_firstequation_size_mfs_t block_type_firstequation_size_mfs;
//! for all blocks derivatives description
t_blocks_derivatives blocks_derivatives;
blocks_derivatives_t blocks_derivatives;
//! The jacobian without the elements below the cutoff
dynamic_jacob_map dynamic_jacobian;
dynamic_jacob_map_t dynamic_jacobian;
//! Vector indicating if the block is linear in endogenous variable (true) or not (false)
vector<bool> blocks_linear;
//! Map the derivatives for a block pair<lag, make_pair(make_pair(eq, var)), NodeID>
typedef map<pair< int, pair<int, int> >, NodeID> t_derivative;
typedef map<pair< int, pair<int, int> >, NodeID> derivative_t;
//! Vector of derivative for each blocks
vector<t_derivative> derivative_endo, derivative_other_endo, derivative_exo, derivative_exo_det;
vector<derivative_t> derivative_endo, derivative_other_endo, derivative_exo, derivative_exo_det;
//!List for each block and for each lag-leag all the other endogenous variables and exogenous variables
typedef set<int> t_var;
typedef map<int, t_var> t_lag_var;
vector<t_lag_var> other_endo_block, exo_block, exo_det_block;
typedef set<int> var_t;
typedef map<int, var_t> lag_var_t;
vector<lag_var_t> other_endo_block, exo_block, exo_det_block;
//!Maximum lead and lag for each block on endogenous of the block, endogenous of the previous blocks, exogenous and deterministic exogenous
vector<pair<int, int> > endo_max_leadlag_block, other_endo_max_leadlag_block, exo_max_leadlag_block, exo_det_max_leadlag_block, max_leadlag_block;
@ -175,7 +175,7 @@ public:
\param eval_context evaluation context for normalization
\param no_tmp_terms if true, no temporary terms will be computed in the static files
*/
void computingPass(const eval_context_type &eval_context, bool no_tmp_terms, bool hessian, bool block, bool bytecode);
void computingPass(const eval_context_t &eval_context, bool no_tmp_terms, bool hessian, bool block, bool bytecode);
//! Adds informations for simulation in a binary file for a block decomposed model
void Write_Inf_To_Bin_File_Block(const string &static_basename, const string &bin_basename, const int &num,