2006-11-17 18:48:11 +01:00
|
|
|
#include "ParsingDriver.hh"
|
2006-12-12 12:54:30 +01:00
|
|
|
#include "Statement.hh"
|
2006-11-05 00:31:17 +01:00
|
|
|
|
2006-11-17 18:48:11 +01:00
|
|
|
ParsingDriver::ParsingDriver() : trace_scanning(false), trace_parsing(false)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2006-11-17 18:48:11 +01:00
|
|
|
ParsingDriver::~ParsingDriver()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2006-11-28 12:56:02 +01:00
|
|
|
bool
|
2007-04-30 14:09:05 +02:00
|
|
|
ParsingDriver::symbol_exists_and_is_not_modfile_local_variable(const char *s)
|
2006-11-28 12:56:02 +01:00
|
|
|
{
|
2007-04-30 14:09:05 +02:00
|
|
|
if (!mod_file->symbol_table.Exist(s))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return(mod_file->symbol_table.getType(s) != eModFileLocalVariable);
|
2006-11-28 12:56:02 +01:00
|
|
|
}
|
|
|
|
|
2006-11-17 18:48:11 +01:00
|
|
|
void
|
2006-11-22 20:01:40 +01:00
|
|
|
ParsingDriver::check_symbol_existence(const string &name)
|
|
|
|
{
|
2006-11-28 12:56:02 +01:00
|
|
|
if (!mod_file->symbol_table.Exist(name))
|
2006-11-22 20:01:40 +01:00
|
|
|
error("Unknown symbol: " + name);
|
|
|
|
}
|
|
|
|
|
2007-03-09 18:27:46 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::set_current_data_tree(DataTree *data_tree_arg)
|
2006-11-22 20:01:40 +01:00
|
|
|
{
|
2007-03-09 18:27:46 +01:00
|
|
|
data_tree = data_tree_arg;
|
|
|
|
model_tree = dynamic_cast<ModelTree *>(data_tree_arg);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ParsingDriver::reset_data_tree()
|
|
|
|
{
|
|
|
|
set_current_data_tree(&mod_file->expressions_tree);
|
2006-11-22 20:01:40 +01:00
|
|
|
}
|
|
|
|
|
2006-11-28 12:56:02 +01:00
|
|
|
ModFile *
|
2006-11-22 20:01:40 +01:00
|
|
|
ParsingDriver::parse(const string &f)
|
2006-11-17 18:48:11 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
mod_file = new ModFile();
|
|
|
|
|
|
|
|
mod_file->symbol_table.error = error;
|
|
|
|
|
|
|
|
tmp_symbol_table = new TmpSymbolTable(mod_file->symbol_table);
|
|
|
|
|
2007-03-09 18:27:46 +01:00
|
|
|
reset_data_tree();
|
|
|
|
|
2006-11-17 18:48:11 +01:00
|
|
|
file = f;
|
|
|
|
scan_begin();
|
|
|
|
yy::parser parser(*this);
|
|
|
|
parser.set_debug_level(trace_parsing);
|
|
|
|
parser.parse();
|
|
|
|
scan_end();
|
2006-12-12 12:54:30 +01:00
|
|
|
|
|
|
|
delete tmp_symbol_table;
|
|
|
|
|
2006-11-28 12:56:02 +01:00
|
|
|
return mod_file;
|
2006-11-17 18:48:11 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2006-11-22 20:01:40 +01:00
|
|
|
ParsingDriver::error(const yy::parser::location_type &l, const string &m)
|
2006-11-17 18:48:11 +01:00
|
|
|
{
|
2006-11-22 20:01:40 +01:00
|
|
|
cerr << l << ": " << m << endl;
|
2006-11-17 18:48:11 +01:00
|
|
|
exit(-1);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2006-11-22 20:01:40 +01:00
|
|
|
ParsingDriver::error(const string &m)
|
2006-11-17 18:48:11 +01:00
|
|
|
{
|
2006-11-28 15:26:06 +01:00
|
|
|
extern int yylineno;
|
|
|
|
cerr << file << ":" << yylineno << ": " << m << endl;
|
2006-11-17 18:48:11 +01:00
|
|
|
exit(-1);
|
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::declare_endogenous(string *name, string *tex_name)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-11-28 12:56:02 +01:00
|
|
|
mod_file->symbol_table.AddSymbolDeclar(*name, eEndogenous, *tex_name);
|
2006-11-22 20:01:40 +01:00
|
|
|
delete name;
|
|
|
|
delete tex_name;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::declare_exogenous(string *name, string *tex_name)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-11-28 12:56:02 +01:00
|
|
|
mod_file->symbol_table.AddSymbolDeclar(*name, eExogenous, *tex_name);
|
2006-11-22 20:01:40 +01:00
|
|
|
delete name;
|
|
|
|
delete tex_name;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::declare_exogenous_det(string *name, string *tex_name)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-11-28 12:56:02 +01:00
|
|
|
mod_file->symbol_table.AddSymbolDeclar(*name, eExogenousDet, *tex_name);
|
2006-11-22 20:01:40 +01:00
|
|
|
delete name;
|
|
|
|
delete tex_name;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::declare_parameter(string *name, string *tex_name)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-11-28 12:56:02 +01:00
|
|
|
mod_file->symbol_table.AddSymbolDeclar(*name, eParameter, *tex_name);
|
2006-11-22 20:01:40 +01:00
|
|
|
delete name;
|
|
|
|
delete tex_name;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
NodeID
|
2007-03-09 18:27:46 +01:00
|
|
|
ParsingDriver::add_constant(string *constant)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2007-03-09 18:27:46 +01:00
|
|
|
NodeID id = data_tree->AddNumConstant(*constant);
|
2006-11-22 20:01:40 +01:00
|
|
|
delete constant;
|
2007-01-09 20:00:05 +01:00
|
|
|
return id;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
NodeID
|
|
|
|
ParsingDriver::add_model_variable(string *name)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-11-22 20:01:40 +01:00
|
|
|
check_symbol_existence(*name);
|
2007-01-09 20:00:05 +01:00
|
|
|
NodeID id = model_tree->AddVariable(*name);
|
2007-02-22 00:28:16 +01:00
|
|
|
|
|
|
|
Type type = mod_file->symbol_table.getType(*name);
|
2007-04-30 14:09:05 +02:00
|
|
|
|
|
|
|
if (type == eModFileLocalVariable)
|
|
|
|
error("Variable " + *name + " not allowed inside model declaration. Its scope is only outside model.");
|
|
|
|
|
2007-11-21 00:24:01 +01:00
|
|
|
if ((type == eEndogenous) && (model_tree->mode == eSparseDLLMode || model_tree->mode == eSparseMode))
|
2007-02-22 00:28:16 +01:00
|
|
|
{
|
|
|
|
int ID = mod_file->symbol_table.getID(*name);
|
2007-03-09 18:27:46 +01:00
|
|
|
model_tree->block_triangular.fill_IM(model_tree->equation_number(), ID, 0);
|
2007-02-22 00:28:16 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
delete name;
|
|
|
|
return id;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
NodeID
|
|
|
|
ParsingDriver::add_model_variable(string *name, string *olag)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-11-22 20:01:40 +01:00
|
|
|
check_symbol_existence(*name);
|
2006-11-28 12:56:02 +01:00
|
|
|
Type type = mod_file->symbol_table.getType(*name);
|
2006-11-22 20:01:40 +01:00
|
|
|
int lag = atoi(olag->c_str());
|
2006-11-05 00:31:17 +01:00
|
|
|
|
2007-04-30 14:09:05 +02:00
|
|
|
if (type == eModFileLocalVariable)
|
|
|
|
error("Variable " + *name + " not allowed inside model declaration. Its scope is only outside model.");
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
if ((type == eExogenous) && lag != 0)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-11-22 20:01:40 +01:00
|
|
|
cout << "Warning: exogenous variable "
|
|
|
|
<< *name
|
|
|
|
<< " has lag " << lag << endl;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
2007-01-09 20:00:05 +01:00
|
|
|
NodeID id = model_tree->AddVariable(*name, lag);
|
2007-02-22 00:28:16 +01:00
|
|
|
|
2007-11-21 00:24:01 +01:00
|
|
|
if ((type == eEndogenous) && (model_tree->mode == eSparseDLLMode || model_tree->mode == eSparseMode))
|
2007-03-09 18:27:46 +01:00
|
|
|
model_tree->block_triangular.fill_IM(model_tree->equation_number(), mod_file->symbol_table.getID(*name), lag);
|
2007-02-22 00:28:16 +01:00
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
delete name;
|
|
|
|
delete olag;
|
|
|
|
return id;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2007-03-09 18:27:46 +01:00
|
|
|
NodeID
|
2006-11-22 20:01:40 +01:00
|
|
|
ParsingDriver::add_expression_variable(string *name)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2007-04-30 14:09:05 +02:00
|
|
|
// If symbol doesn't exist, then declare it as a mod file local variable
|
|
|
|
if (!mod_file->symbol_table.Exist(*name))
|
|
|
|
mod_file->symbol_table.AddSymbolDeclar(*name, eModFileLocalVariable, *name);
|
|
|
|
|
2007-03-09 18:27:46 +01:00
|
|
|
NodeID id = data_tree->AddVariable(*name);
|
2007-02-22 00:28:16 +01:00
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
delete name;
|
2007-03-09 18:27:46 +01:00
|
|
|
return id;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
2006-12-12 12:54:30 +01:00
|
|
|
ParsingDriver::periods(string *periods)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
int periods_val = atoi(periods->c_str());
|
|
|
|
mod_file->addStatement(new PeriodsStatement(periods_val));
|
|
|
|
delete periods;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2007-02-22 00:28:16 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::cutoff(string *cutoff)
|
|
|
|
{
|
2007-06-01 13:43:49 +02:00
|
|
|
double cutoff_val = atof(cutoff->c_str());
|
2007-02-22 00:28:16 +01:00
|
|
|
mod_file->addStatement(new CutoffStatement(cutoff_val));
|
|
|
|
delete cutoff;
|
|
|
|
}
|
|
|
|
|
2007-06-04 00:35:30 +02:00
|
|
|
void
|
|
|
|
ParsingDriver::markowitz(string *markowitz)
|
|
|
|
{
|
|
|
|
double markowitz_val = atof(markowitz->c_str());
|
|
|
|
mod_file->addStatement(new MarkowitzStatement(markowitz_val));
|
|
|
|
delete markowitz;
|
|
|
|
}
|
|
|
|
|
2007-11-21 00:24:01 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::simulation_method(string *simulation_method)
|
|
|
|
{
|
|
|
|
double simulation_method_val = atof(simulation_method->c_str());
|
|
|
|
mod_file->addStatement(new Simulation_MethodStatement(simulation_method_val ));
|
|
|
|
delete simulation_method;
|
|
|
|
}
|
|
|
|
|
2007-06-04 00:35:30 +02:00
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
2006-12-12 12:54:30 +01:00
|
|
|
ParsingDriver::dsample(string *arg1)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
int arg1_val = atoi(arg1->c_str());
|
|
|
|
mod_file->addStatement(new DsampleStatement(arg1_val));
|
|
|
|
delete arg1;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
2006-12-12 12:54:30 +01:00
|
|
|
ParsingDriver::dsample(string *arg1, string *arg2)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
int arg1_val = atoi(arg1->c_str());
|
|
|
|
int arg2_val = atoi(arg2->c_str());
|
|
|
|
mod_file->addStatement(new DsampleStatement(arg1_val, arg2_val));
|
|
|
|
delete arg1;
|
|
|
|
delete arg2;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2007-03-09 18:27:46 +01:00
|
|
|
ParsingDriver::init_param(string *name, NodeID rhs)
|
2006-12-12 12:54:30 +01:00
|
|
|
{
|
|
|
|
check_symbol_existence(*name);
|
|
|
|
if (mod_file->symbol_table.getType(*name) != eParameter)
|
|
|
|
error(*name + " is not a parameter");
|
|
|
|
|
2007-03-09 18:27:46 +01:00
|
|
|
mod_file->addStatement(new InitParamStatement(*name, rhs, mod_file->symbol_table));
|
2007-02-22 00:28:16 +01:00
|
|
|
|
2007-03-09 18:27:46 +01:00
|
|
|
// Update global eval context
|
|
|
|
try
|
|
|
|
{
|
|
|
|
double val = rhs->eval(mod_file->global_eval_context);
|
|
|
|
int symb_id = mod_file->symbol_table.getID(*name);
|
|
|
|
mod_file->global_eval_context[make_pair(symb_id, eParameter)] = val;
|
2007-06-01 13:43:49 +02:00
|
|
|
}
|
2007-03-09 18:27:46 +01:00
|
|
|
catch(ExprNode::EvalException &e)
|
|
|
|
{
|
|
|
|
}
|
2007-02-22 00:28:16 +01:00
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
delete name;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
2007-03-09 18:27:46 +01:00
|
|
|
ParsingDriver::init_val(string *name, NodeID rhs)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
check_symbol_existence(*name);
|
|
|
|
Type type = mod_file->symbol_table.getType(*name);
|
|
|
|
|
|
|
|
if (type != eEndogenous
|
|
|
|
&& type != eExogenous
|
|
|
|
&& type != eExogenousDet)
|
|
|
|
error("initval/endval: " + *name + " should be an endogenous or exogenous variable");
|
|
|
|
|
2007-03-09 18:27:46 +01:00
|
|
|
init_values.push_back(make_pair(*name, rhs));
|
2006-12-12 12:54:30 +01:00
|
|
|
|
2007-03-09 18:27:46 +01:00
|
|
|
// Update global evaluation context
|
|
|
|
try
|
|
|
|
{
|
|
|
|
double val = rhs->eval(mod_file->global_eval_context);
|
|
|
|
int symb_id = mod_file->symbol_table.getID(*name);
|
|
|
|
mod_file->global_eval_context[make_pair(symb_id, type)] = val;
|
|
|
|
}
|
|
|
|
catch(ExprNode::EvalException &e)
|
2007-02-22 00:28:16 +01:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2006-12-12 12:54:30 +01:00
|
|
|
delete name;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2007-02-22 00:28:16 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::init_val_filename(string *filename)
|
|
|
|
{
|
|
|
|
options_list.num_options["INITVAL_FILE"] = 1;
|
|
|
|
options_list.string_options["INITVAL_FILENAME"] = *filename;
|
|
|
|
delete filename;
|
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
2007-03-09 18:27:46 +01:00
|
|
|
ParsingDriver::hist_val(string *name, string *lag, NodeID rhs)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
check_symbol_existence(*name);
|
|
|
|
Type type = mod_file->symbol_table.getType(*name);
|
2006-11-05 00:31:17 +01:00
|
|
|
|
2006-12-12 12:54:30 +01:00
|
|
|
if (type != eEndogenous
|
|
|
|
&& type != eExogenous
|
|
|
|
&& type != eExogenousDet)
|
|
|
|
error("hist_val: " + *name + " should be an endogenous or exogenous variable");
|
2006-11-05 00:31:17 +01:00
|
|
|
|
2006-12-12 12:54:30 +01:00
|
|
|
int ilag = atoi(lag->c_str());
|
|
|
|
pair<string, int> key(*name, ilag);
|
2006-11-05 00:31:17 +01:00
|
|
|
|
2006-12-12 12:54:30 +01:00
|
|
|
if (hist_values.find(key) != hist_values.end())
|
|
|
|
error("hist_val: (" + *name + ", " + *lag + ") declared twice");
|
2006-11-05 00:31:17 +01:00
|
|
|
|
2007-03-09 18:27:46 +01:00
|
|
|
hist_values[key] = rhs;
|
2006-11-05 00:31:17 +01:00
|
|
|
|
2006-12-12 12:54:30 +01:00
|
|
|
delete name;
|
|
|
|
delete lag;
|
2007-02-22 00:28:16 +01:00
|
|
|
}
|
|
|
|
|
2007-11-26 17:31:48 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::homotopy_val(string *name, NodeID val1, NodeID val2)
|
|
|
|
{
|
|
|
|
check_symbol_existence(*name);
|
|
|
|
Type type = mod_file->symbol_table.getType(*name);
|
|
|
|
|
|
|
|
if (type != eParameter
|
|
|
|
&& type != eExogenous
|
|
|
|
&& type != eExogenousDet)
|
|
|
|
error("homotopy_val: " + *name + " should be a parameter or exogenous variable");
|
|
|
|
|
|
|
|
if (homotopy_values.find(*name) != homotopy_values.end())
|
|
|
|
error("homotopy_val: " + *name +" declared twice");
|
|
|
|
|
|
|
|
pair<NodeID, NodeID> expressions(val1, val2);
|
|
|
|
homotopy_values[*name] = expressions;
|
|
|
|
|
|
|
|
delete name;
|
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
2006-12-12 12:54:30 +01:00
|
|
|
ParsingDriver::use_dll()
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2007-03-09 18:27:46 +01:00
|
|
|
model_tree->mode = eDLLMode;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2007-02-22 00:28:16 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::sparse_dll()
|
|
|
|
{
|
2007-03-09 18:27:46 +01:00
|
|
|
model_tree->mode = eSparseDLLMode;
|
|
|
|
model_tree->block_triangular.init_incidence_matrix(mod_file->symbol_table.endo_nbr);
|
2007-02-22 00:28:16 +01:00
|
|
|
}
|
|
|
|
|
2007-11-21 00:24:01 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::sparse()
|
|
|
|
{
|
|
|
|
model_tree->mode = eSparseMode;
|
|
|
|
model_tree->block_triangular.init_incidence_matrix(mod_file->symbol_table.endo_nbr);
|
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::end_initval()
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-18 12:29:10 +01:00
|
|
|
mod_file->addStatement(new InitValStatement(init_values, mod_file->symbol_table));
|
2006-12-12 12:54:30 +01:00
|
|
|
init_values.clear();
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::end_endval()
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
mod_file->addStatement(new EndValStatement(init_values, mod_file->symbol_table));
|
|
|
|
init_values.clear();
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
2006-12-12 12:54:30 +01:00
|
|
|
ParsingDriver::end_histval()
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
mod_file->addStatement(new HistValStatement(hist_values, mod_file->symbol_table));
|
|
|
|
hist_values.clear();
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2007-11-26 17:31:48 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::end_homotopy()
|
|
|
|
{
|
|
|
|
mod_file->addStatement(new HomotopyStatement(homotopy_values, mod_file->symbol_table));
|
|
|
|
homotopy_values.clear();
|
|
|
|
}
|
|
|
|
|
2006-12-19 00:28:52 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::begin_model()
|
|
|
|
{
|
2007-03-09 18:27:46 +01:00
|
|
|
set_current_data_tree(&mod_file->model_tree);
|
2006-12-19 00:28:52 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
2006-12-12 12:54:30 +01:00
|
|
|
ParsingDriver::end_shocks()
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
mod_file->addStatement(new ShocksStatement(det_shocks, var_shocks, std_shocks,
|
|
|
|
covar_shocks, corr_shocks, mod_file->symbol_table));
|
|
|
|
det_shocks.clear();
|
|
|
|
var_shocks.clear();
|
|
|
|
std_shocks.clear();
|
|
|
|
covar_shocks.clear();
|
|
|
|
corr_shocks.clear();
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
2006-12-12 12:54:30 +01:00
|
|
|
ParsingDriver::end_mshocks()
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
mod_file->addStatement(new MShocksStatement(det_shocks, var_shocks, std_shocks,
|
|
|
|
covar_shocks, corr_shocks, mod_file->symbol_table));
|
|
|
|
det_shocks.clear();
|
|
|
|
var_shocks.clear();
|
|
|
|
std_shocks.clear();
|
|
|
|
covar_shocks.clear();
|
|
|
|
corr_shocks.clear();
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::add_det_shock(string *var)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-11-22 20:01:40 +01:00
|
|
|
check_symbol_existence(*var);
|
2006-12-12 12:54:30 +01:00
|
|
|
Type type = mod_file->symbol_table.getType(*var);
|
|
|
|
if (type != eExogenous && type != eExogenousDet)
|
|
|
|
error("shocks: shocks can only be applied to exogenous variables");
|
|
|
|
|
|
|
|
if (det_shocks.find(*var) != det_shocks.end())
|
|
|
|
error("shocks: variable " + *var + " declared twice");
|
|
|
|
|
|
|
|
if (det_shocks_periods.size() != det_shocks_values.size())
|
|
|
|
error("shocks: variable " + *var + ": number of periods is different from number of shock values");
|
|
|
|
|
|
|
|
vector<ShocksStatement::DetShockElement> v;
|
|
|
|
|
|
|
|
for(unsigned int i = 0; i < det_shocks_periods.size(); i++)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
ShocksStatement::DetShockElement dse;
|
|
|
|
dse.period1 = det_shocks_periods[i].first;
|
|
|
|
dse.period2 = det_shocks_periods[i].second;
|
|
|
|
dse.value = det_shocks_values[i];
|
|
|
|
v.push_back(dse);
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
2006-12-12 12:54:30 +01:00
|
|
|
|
|
|
|
det_shocks[*var] = v;
|
|
|
|
|
|
|
|
det_shocks_periods.clear();
|
|
|
|
det_shocks_values.clear();
|
2006-11-22 20:01:40 +01:00
|
|
|
delete var;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
2007-03-09 18:27:46 +01:00
|
|
|
ParsingDriver::add_stderr_shock(string *var, NodeID value)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-11-22 20:01:40 +01:00
|
|
|
check_symbol_existence(*var);
|
2006-12-12 12:54:30 +01:00
|
|
|
if (var_shocks.find(*var) != var_shocks.end()
|
|
|
|
|| std_shocks.find(*var) != std_shocks.end())
|
|
|
|
error("shocks: variance or stderr of shock on " + *var + " declared twice");
|
|
|
|
|
2007-03-09 18:27:46 +01:00
|
|
|
std_shocks[*var] = value;
|
2006-12-12 12:54:30 +01:00
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
delete var;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
2007-03-09 18:27:46 +01:00
|
|
|
ParsingDriver::add_var_shock(string *var, NodeID value)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-11-22 20:01:40 +01:00
|
|
|
check_symbol_existence(*var);
|
2006-12-12 12:54:30 +01:00
|
|
|
if (var_shocks.find(*var) != var_shocks.end()
|
|
|
|
|| std_shocks.find(*var) != std_shocks.end())
|
|
|
|
error("shocks: variance or stderr of shock on " + *var + " declared twice");
|
|
|
|
|
2007-03-09 18:27:46 +01:00
|
|
|
var_shocks[*var] = value;
|
2006-12-12 12:54:30 +01:00
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
delete var;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
2007-03-09 18:27:46 +01:00
|
|
|
ParsingDriver::add_covar_shock(string *var1, string *var2, NodeID value)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-11-22 20:01:40 +01:00
|
|
|
check_symbol_existence(*var1);
|
|
|
|
check_symbol_existence(*var2);
|
2006-12-12 12:54:30 +01:00
|
|
|
|
|
|
|
pair<string, string> key(*var1, *var2), key_inv(*var2, *var1);
|
|
|
|
|
|
|
|
if (covar_shocks.find(key) != covar_shocks.end()
|
|
|
|
|| covar_shocks.find(key_inv) != covar_shocks.end()
|
|
|
|
|| corr_shocks.find(key) != corr_shocks.end()
|
|
|
|
|| corr_shocks.find(key_inv) != corr_shocks.end())
|
|
|
|
error("shocks: covariance or correlation shock on variable pair (" + *var1 + ", "
|
|
|
|
+ *var2 + ") declared twice");
|
2007-06-01 13:43:49 +02:00
|
|
|
|
2007-03-09 18:27:46 +01:00
|
|
|
covar_shocks[key] = value;
|
2006-12-12 12:54:30 +01:00
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
delete var1;
|
|
|
|
delete var2;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
2007-03-09 18:27:46 +01:00
|
|
|
ParsingDriver::add_correl_shock(string *var1, string *var2, NodeID value)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-11-22 20:01:40 +01:00
|
|
|
check_symbol_existence(*var1);
|
|
|
|
check_symbol_existence(*var2);
|
2006-12-12 12:54:30 +01:00
|
|
|
|
|
|
|
pair<string, string> key(*var1, *var2), key_inv(*var2, *var1);
|
|
|
|
|
|
|
|
if (covar_shocks.find(key) != covar_shocks.end()
|
|
|
|
|| covar_shocks.find(key_inv) != covar_shocks.end()
|
|
|
|
|| corr_shocks.find(key) != corr_shocks.end()
|
|
|
|
|| corr_shocks.find(key_inv) != corr_shocks.end())
|
|
|
|
error("shocks: covariance or correlation shock on variable pair (" + *var1 + ", "
|
|
|
|
+ *var2 + ") declared twice");
|
2007-06-01 13:43:49 +02:00
|
|
|
|
2007-03-09 18:27:46 +01:00
|
|
|
corr_shocks[key] = value;
|
2006-12-12 12:54:30 +01:00
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
delete var1;
|
|
|
|
delete var2;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ParsingDriver::add_period(string *p1, string *p2)
|
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
int p1_val = atoi(p1->c_str());
|
|
|
|
int p2_val = atoi(p2->c_str());
|
2007-02-05 10:55:41 +01:00
|
|
|
det_shocks_periods.push_back(make_pair(p1_val, p2_val));
|
2006-11-22 20:01:40 +01:00
|
|
|
delete p1;
|
|
|
|
delete p2;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::add_period(string *p1)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
int p1_val = atoi(p1->c_str());
|
2007-02-05 10:55:41 +01:00
|
|
|
det_shocks_periods.push_back(make_pair(p1_val, p1_val));
|
2006-11-22 20:01:40 +01:00
|
|
|
delete p1;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2007-03-09 18:27:46 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::add_value(NodeID value)
|
|
|
|
{
|
|
|
|
det_shocks_values.push_back(value);
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2007-11-21 00:24:01 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::add_value(string *p1)
|
|
|
|
{
|
|
|
|
//int p1_val = atoi(p1->c_str());
|
|
|
|
det_shocks_values.push_back(add_constant(p1));
|
|
|
|
//delete p1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::do_sigma_e()
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
try
|
|
|
|
{
|
|
|
|
mod_file->addStatement(new SigmaeStatement(sigmae_matrix));
|
|
|
|
}
|
|
|
|
catch(SigmaeStatement::MatrixFormException &e)
|
|
|
|
{
|
|
|
|
error("Sigma_e: matrix is neither upper triangular nor lower triangular");
|
|
|
|
}
|
|
|
|
sigmae_matrix.clear();
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::end_of_row()
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
sigmae_matrix.push_back(sigmae_row);
|
|
|
|
sigmae_row.clear();
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
2007-03-09 18:27:46 +01:00
|
|
|
ParsingDriver::add_to_row_const(string *s)
|
2006-11-22 20:01:40 +01:00
|
|
|
{
|
2007-03-09 18:27:46 +01:00
|
|
|
sigmae_row.push_back(add_constant(s));
|
2006-11-22 20:01:40 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2007-03-09 18:27:46 +01:00
|
|
|
ParsingDriver::add_to_row(NodeID v)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2007-03-09 18:27:46 +01:00
|
|
|
sigmae_row.push_back(v);
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2007-11-21 00:24:01 +01:00
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::steady()
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2007-11-21 00:24:01 +01:00
|
|
|
if (/*mod_file->model_tree.mode == eSparseDLLMode || */mod_file->model_tree.mode == eSparseMode)
|
|
|
|
{
|
|
|
|
mod_file->addStatement(new SteadySparseStatement(options_list));
|
|
|
|
options_list.clear();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
mod_file->addStatement(new SteadyStatement(options_list));
|
|
|
|
options_list.clear();
|
|
|
|
}
|
|
|
|
/*mod_file->addStatement(new SteadyStatement(options_list));
|
|
|
|
options_list.clear();*/
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::option_num(const string &name_option, string *opt1, string *opt2)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
if (options_list.paired_num_options.find(name_option)
|
|
|
|
!= options_list.paired_num_options.end())
|
|
|
|
error("option " + name_option + " declared twice");
|
|
|
|
|
2007-02-05 10:55:41 +01:00
|
|
|
options_list.paired_num_options[name_option] = make_pair(*opt1, *opt2);
|
2006-11-22 20:01:40 +01:00
|
|
|
delete opt1;
|
|
|
|
delete opt2;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::option_num(const string &name_option, string *opt)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-11-22 20:01:40 +01:00
|
|
|
option_num(name_option, *opt);
|
|
|
|
delete opt;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::option_num(const string &name_option, const string &opt)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
if (options_list.num_options.find(name_option)
|
|
|
|
!= options_list.num_options.end())
|
|
|
|
error("option " + name_option + " declared twice");
|
|
|
|
|
2007-11-21 00:24:01 +01:00
|
|
|
if ((name_option == "periods") && (mod_file->model_tree.mode == eSparseDLLMode || mod_file->model_tree.mode == eSparseMode))
|
2007-02-22 00:28:16 +01:00
|
|
|
mod_file->model_tree.block_triangular.periods = atoi(opt.c_str());
|
|
|
|
else if (name_option == "cutoff")
|
2007-03-09 18:27:46 +01:00
|
|
|
mod_file->model_tree.cutoff = atof(opt.c_str());
|
2007-02-22 00:28:16 +01:00
|
|
|
|
2006-12-12 12:54:30 +01:00
|
|
|
options_list.num_options[name_option] = opt;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::option_str(const string &name_option, string *opt)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-11-22 20:01:40 +01:00
|
|
|
option_str(name_option, *opt);
|
|
|
|
delete opt;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::option_str(const string &name_option, const string &opt)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
if (options_list.string_options.find(name_option)
|
|
|
|
!= options_list.string_options.end())
|
|
|
|
error("option " + name_option + " declared twice");
|
|
|
|
|
|
|
|
options_list.string_options[name_option] = opt;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ParsingDriver::linear()
|
|
|
|
{
|
2006-12-15 12:44:58 +01:00
|
|
|
mod_file->linear = true;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::add_tmp_var(string *tmp_var1, string *tmp_var2)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
check_symbol_existence(*tmp_var1);
|
|
|
|
check_symbol_existence(*tmp_var2);
|
|
|
|
tmp_symbol_table->AddTempSymbol(*tmp_var1, *tmp_var2);
|
2006-11-22 20:01:40 +01:00
|
|
|
delete tmp_var1;
|
|
|
|
delete tmp_var2;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::add_tmp_var(string *tmp_var)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
check_symbol_existence(*tmp_var);
|
|
|
|
tmp_symbol_table->AddTempSymbol(*tmp_var);
|
2006-11-22 20:01:40 +01:00
|
|
|
delete tmp_var;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-17 18:48:11 +01:00
|
|
|
void ParsingDriver::rplot()
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
mod_file->addStatement(new RplotStatement(*tmp_symbol_table, options_list));
|
|
|
|
options_list.clear();
|
|
|
|
tmp_symbol_table->clear();
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-17 18:48:11 +01:00
|
|
|
void ParsingDriver::stoch_simul()
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
mod_file->addStatement(new StochSimulStatement(*tmp_symbol_table, options_list));
|
|
|
|
tmp_symbol_table->clear();
|
|
|
|
options_list.clear();
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2007-02-22 00:28:16 +01:00
|
|
|
void ParsingDriver::simulate()
|
|
|
|
{
|
2007-11-21 00:24:01 +01:00
|
|
|
if (mod_file->model_tree.mode == eSparseDLLMode || mod_file->model_tree.mode == eSparseMode)
|
2007-02-22 00:28:16 +01:00
|
|
|
simul_sparse();
|
|
|
|
else
|
|
|
|
simul();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ParsingDriver::simul_sparse()
|
|
|
|
{
|
2007-11-21 00:24:01 +01:00
|
|
|
mod_file->addStatement(new SimulSparseStatement(options_list, mod_file->model_tree.compiler, mod_file->model_tree.mode));
|
2007-02-22 00:28:16 +01:00
|
|
|
options_list.clear();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ParsingDriver::init_compiler(int compiler_type)
|
|
|
|
{
|
2007-03-09 18:27:46 +01:00
|
|
|
mod_file->model_tree.compiler = compiler_type;
|
2007-02-22 00:28:16 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::simul()
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
mod_file->addStatement(new SimulStatement(options_list));
|
|
|
|
options_list.clear();
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::check()
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
mod_file->addStatement(new CheckStatement(options_list));
|
|
|
|
options_list.clear();
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
2006-12-12 12:54:30 +01:00
|
|
|
ParsingDriver::add_estimated_params_element()
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
check_symbol_existence(estim_params.name);
|
|
|
|
if (estim_params.name2.size() > 0)
|
|
|
|
check_symbol_existence(estim_params.name2);
|
|
|
|
|
|
|
|
estim_params_list.push_back(estim_params);
|
|
|
|
estim_params.clear();
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
2006-12-12 12:54:30 +01:00
|
|
|
ParsingDriver::estimated_params()
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
mod_file->addStatement(new EstimatedParamsStatement(estim_params_list, mod_file->symbol_table));
|
|
|
|
estim_params_list.clear();
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
2006-12-12 12:54:30 +01:00
|
|
|
ParsingDriver::estimated_params_init()
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
mod_file->addStatement(new EstimatedParamsInitStatement(estim_params_list, mod_file->symbol_table));
|
|
|
|
estim_params_list.clear();
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
2006-12-12 12:54:30 +01:00
|
|
|
ParsingDriver::estimated_params_bounds()
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
mod_file->addStatement(new EstimatedParamsBoundsStatement(estim_params_list, mod_file->symbol_table));
|
|
|
|
estim_params_list.clear();
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::set_unit_root_vars()
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
mod_file->addStatement(new UnitRootVarsStatement(*tmp_symbol_table));
|
|
|
|
tmp_symbol_table->clear();
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::run_estimation()
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
mod_file->addStatement(new EstimationStatement(*tmp_symbol_table, options_list));
|
|
|
|
tmp_symbol_table->clear();
|
|
|
|
options_list.clear();
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-25 18:55:02 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::run_prior_analysis()
|
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
mod_file->addStatement(new PriorAnalysisStatement(*tmp_symbol_table, options_list));
|
|
|
|
tmp_symbol_table->clear();
|
|
|
|
options_list.clear();
|
2006-11-25 18:55:02 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ParsingDriver::run_posterior_analysis()
|
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
mod_file->addStatement(new PosteriorAnalysisStatement(*tmp_symbol_table, options_list));
|
|
|
|
tmp_symbol_table->clear();
|
|
|
|
options_list.clear();
|
|
|
|
}
|
|
|
|
|
2007-10-02 16:05:16 +02:00
|
|
|
void
|
|
|
|
ParsingDriver::dynare_sensitivity()
|
|
|
|
{
|
|
|
|
mod_file->addStatement(new DynareSensitivityStatement(options_list));
|
|
|
|
options_list.clear();
|
|
|
|
}
|
|
|
|
|
2006-12-12 12:54:30 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::optim_options_helper(const string &name)
|
|
|
|
{
|
|
|
|
if (options_list.string_options.find("optim_opt") == options_list.string_options.end())
|
|
|
|
options_list.string_options["optim_opt"] = "";
|
|
|
|
else
|
|
|
|
options_list.string_options["optim_opt"] += ",";
|
|
|
|
options_list.string_options["optim_opt"] += "''" + name + "'',";
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ParsingDriver::optim_options_string(string *name, string *value)
|
|
|
|
{
|
|
|
|
optim_options_helper(*name);
|
|
|
|
options_list.string_options["optim_opt"] += "''" + *value + "''";
|
|
|
|
delete name;
|
|
|
|
delete value;
|
2006-11-25 18:55:02 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
2006-12-12 12:54:30 +01:00
|
|
|
ParsingDriver::optim_options_num(string *name, string *value)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
optim_options_helper(*name);
|
|
|
|
options_list.string_options["optim_opt"] += *value;
|
|
|
|
delete name;
|
|
|
|
delete value;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::set_varobs()
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
mod_file->addStatement(new VarobsStatement(*tmp_symbol_table));
|
|
|
|
tmp_symbol_table->clear();
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
2006-12-12 12:54:30 +01:00
|
|
|
ParsingDriver::set_trends()
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
mod_file->addStatement(new ObservationTrendsStatement(trend_elements, mod_file->symbol_table));
|
|
|
|
trend_elements.clear();
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
2007-03-09 18:27:46 +01:00
|
|
|
ParsingDriver::set_trend_element(string *arg1, NodeID arg2)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
check_symbol_existence(*arg1);
|
|
|
|
if (trend_elements.find(*arg1) != trend_elements.end())
|
|
|
|
error("observation_trends: " + *arg1 + " declared twice");
|
2007-03-09 18:27:46 +01:00
|
|
|
trend_elements[*arg1] = arg2;
|
2006-11-22 20:01:40 +01:00
|
|
|
delete arg1;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
2007-03-09 18:27:46 +01:00
|
|
|
ParsingDriver::set_optim_weights(string *name, NodeID value)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
check_symbol_existence(*name);
|
|
|
|
if (mod_file->symbol_table.getType(*name) != eEndogenous)
|
|
|
|
error("optim_weights: " + *name + " isn't an endogenous variable");
|
|
|
|
if (var_weights.find(*name) != var_weights.end())
|
|
|
|
error("optim_weights: " + *name + " declared twice");
|
2007-03-09 18:27:46 +01:00
|
|
|
var_weights[*name] = value;
|
2006-12-12 12:54:30 +01:00
|
|
|
delete name;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
2007-03-09 18:27:46 +01:00
|
|
|
ParsingDriver::set_optim_weights(string *name1, string *name2, NodeID value)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
check_symbol_existence(*name1);
|
|
|
|
if (mod_file->symbol_table.getType(*name1) != eEndogenous)
|
|
|
|
error("optim_weights: " + *name1 + " isn't an endogenous variable");
|
|
|
|
|
|
|
|
check_symbol_existence(*name2);
|
|
|
|
if (mod_file->symbol_table.getType(*name2) != eEndogenous)
|
|
|
|
error("optim_weights: " + *name2 + " isn't an endogenous variable");
|
|
|
|
|
|
|
|
pair<string, string> covar_key(*name1, *name2);
|
|
|
|
|
|
|
|
if (covar_weights.find(covar_key) != covar_weights.end())
|
|
|
|
error("optim_weights: pair of variables (" + *name1 + ", " + *name2
|
|
|
|
+ ") declared twice");
|
|
|
|
|
2007-03-09 18:27:46 +01:00
|
|
|
covar_weights[covar_key] = value;
|
2006-12-12 12:54:30 +01:00
|
|
|
delete name1;
|
|
|
|
delete name2;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
2006-12-12 12:54:30 +01:00
|
|
|
ParsingDriver::optim_weights()
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
mod_file->addStatement(new OptimWeightsStatement(var_weights, covar_weights, mod_file->symbol_table));
|
|
|
|
var_weights.clear();
|
|
|
|
covar_weights.clear();
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::set_osr_params()
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
mod_file->addStatement(new OsrParamsStatement(*tmp_symbol_table));
|
|
|
|
tmp_symbol_table->clear();
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::run_osr()
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
mod_file->addStatement(new OsrStatement(*tmp_symbol_table, options_list));
|
|
|
|
tmp_symbol_table->clear();
|
|
|
|
options_list.clear();
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
2007-03-09 18:27:46 +01:00
|
|
|
ParsingDriver::set_calib_var(string *name, string *weight, NodeID expression)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
check_symbol_existence(*name);
|
|
|
|
if (mod_file->symbol_table.getType(*name) != eEndogenous
|
|
|
|
&& mod_file->symbol_table.getType(*name) != eExogenous)
|
|
|
|
error("calib_var: " + *name + " isn't an endogenous or exogenous variable");
|
|
|
|
|
|
|
|
if (calib_var.find(*name) != calib_var.end())
|
|
|
|
error("calib_var: " + *name + " declared twice");
|
|
|
|
|
2007-03-09 18:27:46 +01:00
|
|
|
calib_var[*name] = make_pair(*weight, expression);
|
2006-12-12 12:54:30 +01:00
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
delete name;
|
|
|
|
delete weight;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
2006-12-12 12:54:30 +01:00
|
|
|
ParsingDriver::set_calib_covar(string *name1, string *name2,
|
2007-03-09 18:27:46 +01:00
|
|
|
string *weight, NodeID expression)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
check_symbol_existence(*name1);
|
|
|
|
check_symbol_existence(*name2);
|
|
|
|
if (mod_file->symbol_table.getType(*name1) != mod_file->symbol_table.getType(*name2))
|
|
|
|
error("calib_var: " + *name1 + " and " + *name2 + "dont't have the same type");
|
|
|
|
if (mod_file->symbol_table.getType(*name1) != eEndogenous
|
|
|
|
&& mod_file->symbol_table.getType(*name1) != eExogenous)
|
|
|
|
error("calib_var: " + *name1 + " and " + *name2 + "aren't endogenous or exogenous variables");
|
|
|
|
|
|
|
|
pair<string, string> covar_key(*name1, *name2);
|
|
|
|
|
|
|
|
if (calib_covar.find(covar_key) != calib_covar.end())
|
|
|
|
error("calib_var: pair of variables (" + *name1 + ", " + *name2
|
|
|
|
+ ") declared twice");
|
|
|
|
|
2007-03-09 18:27:46 +01:00
|
|
|
calib_covar[covar_key] = make_pair(*weight, expression);
|
2006-12-12 12:54:30 +01:00
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
delete name1;
|
|
|
|
delete name2;
|
|
|
|
delete weight;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::set_calib_ac(string *name, string *ar,
|
2007-03-09 18:27:46 +01:00
|
|
|
string *weight, NodeID expression)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
check_symbol_existence(*name);
|
|
|
|
if (mod_file->symbol_table.getType(*name) != eEndogenous)
|
|
|
|
error("calib_var: " + *name + "isn't an endogenous variable");
|
|
|
|
|
|
|
|
int iar = atoi(ar->c_str());
|
|
|
|
pair<string, int> ac_key(*name, iar);
|
|
|
|
|
|
|
|
if (calib_ac.find(ac_key) != calib_ac.end())
|
|
|
|
error("calib_var: autocorr " + *name + "(" + *ar + ") declared twice");
|
|
|
|
|
2007-03-09 18:27:46 +01:00
|
|
|
calib_ac[ac_key] = make_pair(*weight, expression);
|
2006-12-12 12:54:30 +01:00
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
delete name;
|
|
|
|
delete ar;
|
|
|
|
delete weight;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
2006-12-12 12:54:30 +01:00
|
|
|
ParsingDriver::run_calib_var()
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
mod_file->addStatement(new CalibVarStatement(calib_var, calib_covar, calib_ac,
|
|
|
|
mod_file->symbol_table));
|
|
|
|
calib_var.clear();
|
|
|
|
calib_covar.clear();
|
|
|
|
calib_ac.clear();
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
2006-12-12 12:54:30 +01:00
|
|
|
ParsingDriver::run_calib(int covar)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
mod_file->addStatement(new CalibStatement(covar));
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
2006-12-12 12:54:30 +01:00
|
|
|
ParsingDriver::run_dynatype(string *filename, string *ext)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
mod_file->addStatement(new DynaTypeStatement(*tmp_symbol_table, *filename, *ext));
|
|
|
|
tmp_symbol_table->clear();
|
2006-11-22 20:01:40 +01:00
|
|
|
delete filename;
|
|
|
|
delete ext;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
2006-12-12 12:54:30 +01:00
|
|
|
ParsingDriver::run_dynasave(string *filename, string *ext)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
mod_file->addStatement(new DynaSaveStatement(*tmp_symbol_table, *filename, *ext));
|
|
|
|
tmp_symbol_table->clear();
|
|
|
|
delete filename;
|
|
|
|
delete ext;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::add_mc_filename(string *filename, string *prior)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
if (filename_list.find(*filename) != filename_list.end())
|
|
|
|
error("model_comparison: filename " + *filename + " declared twice");
|
|
|
|
filename_list[*filename] = *prior;
|
2006-11-22 20:01:40 +01:00
|
|
|
delete filename;
|
|
|
|
delete prior;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::run_model_comparison()
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
mod_file->addStatement(new ModelComparisonStatement(filename_list, options_list));
|
|
|
|
filename_list.clear();
|
|
|
|
options_list.clear();
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-12-19 00:28:52 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::begin_planner_objective()
|
|
|
|
{
|
2007-03-09 18:27:46 +01:00
|
|
|
set_current_data_tree(new ModelTree(mod_file->symbol_table, mod_file->num_constants));
|
2006-12-19 00:28:52 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ParsingDriver::end_planner_objective(NodeID expr)
|
|
|
|
{
|
|
|
|
// Add equation corresponding to expression
|
2007-01-09 20:00:05 +01:00
|
|
|
NodeID eq = model_tree->AddEqual(expr, model_tree->Zero);
|
|
|
|
model_tree->addEquation(eq);
|
2006-12-19 00:28:52 +01:00
|
|
|
|
|
|
|
mod_file->addStatement(new PlannerObjectiveStatement(model_tree));
|
2007-03-09 18:27:46 +01:00
|
|
|
|
|
|
|
reset_data_tree();
|
2006-12-19 00:28:52 +01:00
|
|
|
}
|
|
|
|
|
2007-01-04 15:42:27 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::ramsey_policy()
|
|
|
|
{
|
|
|
|
mod_file->addStatement(new RamseyPolicyStatement(*tmp_symbol_table, options_list));
|
|
|
|
tmp_symbol_table->clear();
|
|
|
|
options_list.clear();
|
|
|
|
}
|
|
|
|
|
2007-06-26 00:42:30 +02:00
|
|
|
void
|
|
|
|
ParsingDriver::bvar_density(string *maxnlags)
|
|
|
|
{
|
|
|
|
mod_file->addStatement(new BVARDensityStatement(atoi(maxnlags->c_str()), options_list));
|
|
|
|
options_list.clear();
|
|
|
|
delete maxnlags;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ParsingDriver::bvar_forecast(string *nlags)
|
|
|
|
{
|
|
|
|
mod_file->addStatement(new BVARForecastStatement(atoi(nlags->c_str()), options_list));
|
|
|
|
options_list.clear();
|
|
|
|
delete nlags;
|
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
NodeID
|
|
|
|
ParsingDriver::add_model_equal(NodeID arg1, NodeID arg2)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2006-12-19 00:28:52 +01:00
|
|
|
NodeID id = model_tree->AddEqual(arg1, arg2);
|
2007-01-09 20:00:05 +01:00
|
|
|
model_tree->addEquation(id);
|
2006-11-22 20:01:40 +01:00
|
|
|
return id;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-28 12:56:02 +01:00
|
|
|
NodeID
|
|
|
|
ParsingDriver::add_model_equal_with_zero_rhs(NodeID arg)
|
|
|
|
{
|
2006-12-19 00:28:52 +01:00
|
|
|
return add_model_equal(arg, model_tree->Zero);
|
2006-11-28 12:56:02 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
void
|
2007-04-30 14:09:05 +02:00
|
|
|
ParsingDriver::declare_and_init_model_local_variable(string *name, NodeID rhs)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2007-04-30 14:09:05 +02:00
|
|
|
mod_file->symbol_table.AddSymbolDeclar(*name, eModelLocalVariable, *name);
|
2007-01-09 20:00:05 +01:00
|
|
|
try
|
|
|
|
{
|
|
|
|
model_tree->AddLocalParameter(*name, rhs);
|
|
|
|
}
|
|
|
|
catch(DataTree::LocalParameterException &e)
|
|
|
|
{
|
|
|
|
error("Local parameter " + e.name + " declared twice");
|
|
|
|
}
|
2006-11-22 20:01:40 +01:00
|
|
|
delete name;
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
NodeID
|
2007-03-09 18:27:46 +01:00
|
|
|
ParsingDriver::add_plus(NodeID arg1, NodeID arg2)
|
|
|
|
{
|
|
|
|
return data_tree->AddPlus(arg1, arg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
NodeID
|
|
|
|
ParsingDriver::add_minus(NodeID arg1, NodeID arg2)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2007-03-09 18:27:46 +01:00
|
|
|
return data_tree->AddMinus(arg1, arg2);
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
NodeID
|
2007-03-09 18:27:46 +01:00
|
|
|
ParsingDriver::add_uminus(NodeID arg1)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2007-03-09 18:27:46 +01:00
|
|
|
return data_tree->AddUMinus(arg1);
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
NodeID
|
2007-03-09 18:27:46 +01:00
|
|
|
ParsingDriver::add_times(NodeID arg1, NodeID arg2)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2007-03-09 18:27:46 +01:00
|
|
|
return data_tree->AddTimes(arg1, arg2);
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
NodeID
|
2007-03-09 18:27:46 +01:00
|
|
|
ParsingDriver::add_divide(NodeID arg1, NodeID arg2)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2007-03-09 18:27:46 +01:00
|
|
|
return data_tree->AddDivide(arg1, arg2);
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2007-10-09 00:52:57 +02:00
|
|
|
NodeID
|
|
|
|
ParsingDriver::add_less(NodeID arg1, NodeID arg2)
|
|
|
|
{
|
|
|
|
return data_tree->AddLess(arg1, arg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
NodeID
|
|
|
|
ParsingDriver::add_greater(NodeID arg1, NodeID arg2)
|
|
|
|
{
|
|
|
|
return data_tree->AddGreater(arg1, arg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
NodeID
|
|
|
|
ParsingDriver::add_less_equal(NodeID arg1, NodeID arg2)
|
|
|
|
{
|
|
|
|
return data_tree->AddLessEqual(arg1, arg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
NodeID
|
|
|
|
ParsingDriver::add_greater_equal(NodeID arg1, NodeID arg2)
|
|
|
|
{
|
|
|
|
return data_tree->AddGreaterEqual(arg1, arg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
NodeID
|
|
|
|
ParsingDriver::add_equal_equal(NodeID arg1, NodeID arg2)
|
|
|
|
{
|
|
|
|
return data_tree->AddEqualEqual(arg1, arg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
NodeID
|
|
|
|
ParsingDriver::add_different(NodeID arg1, NodeID arg2)
|
|
|
|
{
|
|
|
|
return data_tree->AddDifferent(arg1, arg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
NodeID
|
2007-03-09 18:27:46 +01:00
|
|
|
ParsingDriver::add_power(NodeID arg1, NodeID arg2)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2007-03-09 18:27:46 +01:00
|
|
|
return data_tree->AddPower(arg1, arg2);
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
NodeID
|
2007-03-09 18:27:46 +01:00
|
|
|
ParsingDriver::add_exp(NodeID arg1)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2007-03-09 18:27:46 +01:00
|
|
|
return data_tree->AddExp(arg1);
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
NodeID
|
2007-03-09 18:27:46 +01:00
|
|
|
ParsingDriver::add_log(NodeID arg1)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2007-03-09 18:27:46 +01:00
|
|
|
return data_tree->AddLog(arg1);
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
NodeID
|
2007-03-09 18:27:46 +01:00
|
|
|
ParsingDriver::add_log10(NodeID arg1)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2007-03-09 18:27:46 +01:00
|
|
|
return data_tree->AddLog10(arg1);
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
NodeID
|
2007-03-09 18:27:46 +01:00
|
|
|
ParsingDriver::add_cos(NodeID arg1)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2007-03-09 18:27:46 +01:00
|
|
|
return data_tree->AddCos(arg1);
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
NodeID
|
2007-03-09 18:27:46 +01:00
|
|
|
ParsingDriver::add_sin(NodeID arg1)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2007-03-09 18:27:46 +01:00
|
|
|
return data_tree->AddSin(arg1);
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
NodeID
|
2007-03-09 18:27:46 +01:00
|
|
|
ParsingDriver::add_tan(NodeID arg1)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2007-03-09 18:27:46 +01:00
|
|
|
return data_tree->AddTan(arg1);
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
NodeID
|
2007-03-09 18:27:46 +01:00
|
|
|
ParsingDriver::add_acos(NodeID arg1)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2007-03-09 18:27:46 +01:00
|
|
|
return data_tree->AddACos(arg1);
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
NodeID
|
2007-03-09 18:27:46 +01:00
|
|
|
ParsingDriver::add_asin(NodeID arg1)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2007-03-09 18:27:46 +01:00
|
|
|
return data_tree->AddASin(arg1);
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
NodeID
|
2007-03-09 18:27:46 +01:00
|
|
|
ParsingDriver::add_atan(NodeID arg1)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2007-03-09 18:27:46 +01:00
|
|
|
return data_tree->AddATan(arg1);
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
NodeID
|
2007-03-09 18:27:46 +01:00
|
|
|
ParsingDriver::add_cosh(NodeID arg1)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2007-03-09 18:27:46 +01:00
|
|
|
return data_tree->AddCosH(arg1);
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
NodeID
|
2007-03-09 18:27:46 +01:00
|
|
|
ParsingDriver::add_sinh(NodeID arg1)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2007-03-09 18:27:46 +01:00
|
|
|
return data_tree->AddSinH(arg1);
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
NodeID
|
2007-03-09 18:27:46 +01:00
|
|
|
ParsingDriver::add_tanh(NodeID arg1)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2007-03-09 18:27:46 +01:00
|
|
|
return data_tree->AddTanH(arg1);
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
NodeID
|
2007-03-09 18:27:46 +01:00
|
|
|
ParsingDriver::add_acosh(NodeID arg1)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2007-03-09 18:27:46 +01:00
|
|
|
return data_tree->AddACosH(arg1);
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
NodeID
|
2007-03-09 18:27:46 +01:00
|
|
|
ParsingDriver::add_asinh(NodeID arg1)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2007-03-09 18:27:46 +01:00
|
|
|
return data_tree->AddASinH(arg1);
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
NodeID
|
2007-03-09 18:27:46 +01:00
|
|
|
ParsingDriver::add_atanh(NodeID arg1)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2007-03-09 18:27:46 +01:00
|
|
|
return data_tree->AddATanH(arg1);
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
NodeID
|
2007-03-09 18:27:46 +01:00
|
|
|
ParsingDriver::add_sqrt(NodeID arg1)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2007-03-09 18:27:46 +01:00
|
|
|
return data_tree->AddSqRt(arg1);
|
|
|
|
}
|
|
|
|
|
2007-10-05 21:47:27 +02:00
|
|
|
NodeID
|
|
|
|
ParsingDriver::add_max(NodeID arg1, NodeID arg2)
|
|
|
|
{
|
|
|
|
return data_tree->AddMaX(arg1,arg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
NodeID
|
|
|
|
ParsingDriver::add_min(NodeID arg1, NodeID arg2)
|
|
|
|
{
|
|
|
|
return data_tree->AddMin(arg1,arg2);
|
|
|
|
}
|
|
|
|
|
2007-11-11 16:24:50 +01:00
|
|
|
NodeID
|
|
|
|
ParsingDriver::add_normcdf(NodeID arg1, NodeID arg2, NodeID arg3)
|
|
|
|
{
|
|
|
|
return data_tree->AddNormcdf(arg1,arg2,arg3);
|
|
|
|
}
|
|
|
|
|
2007-03-09 18:27:46 +01:00
|
|
|
void
|
|
|
|
ParsingDriver::add_unknown_function_arg(NodeID arg)
|
|
|
|
{
|
|
|
|
unknown_function_args.push_back(arg);
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|
|
|
|
|
2006-11-22 20:01:40 +01:00
|
|
|
NodeID
|
2007-03-09 18:27:46 +01:00
|
|
|
ParsingDriver::add_unknown_function(string *function_name)
|
2006-11-05 00:31:17 +01:00
|
|
|
{
|
2007-10-17 11:36:56 +02:00
|
|
|
if (mod_file->symbol_table.Exist(*function_name))
|
|
|
|
{
|
|
|
|
if (mod_file->symbol_table.getType(*function_name) != eUnknownFunction)
|
|
|
|
error("Symbol " + *function_name + " is not a function name.");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
mod_file->symbol_table.AddSymbolDeclar(*function_name, eUnknownFunction, *function_name);
|
|
|
|
|
2007-03-09 18:27:46 +01:00
|
|
|
NodeID id = data_tree->AddUnknownFunction(*function_name, unknown_function_args);
|
|
|
|
unknown_function_args.clear();
|
|
|
|
return id;
|
2006-11-28 12:56:02 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ParsingDriver::add_native(const char *s)
|
|
|
|
{
|
2006-12-12 12:54:30 +01:00
|
|
|
mod_file->addStatement(new NativeStatement(s));
|
2006-11-05 00:31:17 +01:00
|
|
|
}
|