699 lines
20 KiB
C++
699 lines
20 KiB
C++
/*! \file
|
|
\version 1.0
|
|
\date 04/09/2004
|
|
\par This file implements the parser class methodes.
|
|
*/
|
|
//------------------------------------------------------------------------------
|
|
#include "ModelParameters.h"
|
|
#include "SymbolTable.h"
|
|
#include "Expression.h"
|
|
#include "NumericalInitialization.h"
|
|
#include "ModelTree.h"
|
|
#include "VariableTable.h"
|
|
#include "Shocks.h"
|
|
#include "SigmaeInitialization.h"
|
|
#include "ComputingTasks.h"
|
|
#include "TmpSymbolTable.h"
|
|
#include "DynareParser.h"
|
|
|
|
string dynare::parser::file_name = "";
|
|
void dynare::parser::set_file_name(string fname)
|
|
{
|
|
file_name = fname;
|
|
}
|
|
|
|
void dynare::parser::setoutput(ostringstream* ostr)
|
|
{
|
|
output = ostr;
|
|
numerical_initialization.setOutput(ostr);
|
|
shocks.setOutput(ostr);
|
|
sigmae.setOutput(ostr);
|
|
computing_tasks.setOutput(ostr);
|
|
}
|
|
|
|
dynare::Objects* dynare::parser::add_endogenous(Objects* obj, Objects* tex_name)
|
|
{
|
|
//cout << "add_endogenous \n";
|
|
|
|
obj->ID = (NodeID) symbol_table.AddSymbolDeclar(obj->symbol,eEndogenous, tex_name->symbol);
|
|
obj->type = eEndogenous;
|
|
return (obj);
|
|
}
|
|
dynare::Objects* dynare::parser::add_exogenous(Objects* obj, Objects* tex_name)
|
|
{
|
|
obj->ID = (NodeID) symbol_table.AddSymbolDeclar(obj->symbol,eExogenous, tex_name->symbol);
|
|
obj->type = eExogenous;
|
|
return (obj);
|
|
}
|
|
dynare::Objects* dynare::parser::add_exogenous_det(Objects* obj, Objects* tex_name)
|
|
{
|
|
obj->ID = (NodeID) symbol_table.AddSymbolDeclar(obj->symbol,eExogenousDet, tex_name->symbol);
|
|
obj->type = eExogenousDet;
|
|
return (obj);
|
|
}
|
|
dynare::Objects* dynare::parser::add_parameter(Objects* obj, Objects* tex_name)
|
|
{
|
|
obj->ID = (NodeID) symbol_table.AddSymbolDeclar(obj->symbol,eParameter, tex_name->symbol);
|
|
obj->type = eParameter;
|
|
return (obj);
|
|
}
|
|
dynare::Objects* dynare::parser::add_constant(Objects* obj)
|
|
{
|
|
obj->ID = (NodeID) num_constants.AddConstant(obj->symbol);
|
|
obj->type = eNumericalConstant;
|
|
return obj;
|
|
}
|
|
dynare::Objects* dynare::parser::add_model_constant(Objects* constant)
|
|
{
|
|
constant = add_constant(constant);
|
|
NodeID id = model_tree.AddTerminal(constant->ID, eNumericalConstant);
|
|
return new Objects("", id, eTempResult);
|
|
}
|
|
dynare::Objects* dynare::parser::add_variable(Objects* var)
|
|
{
|
|
//cout << "add_variable1 : " << var->symbol << endl;
|
|
var = get_symbol(var);
|
|
if((var->type == eEndogenous) || (var->type == eExogenous))
|
|
variable_table.AddVariable(var->symbol,0);
|
|
//cout << "add_model_token : " << var->ID << endl;
|
|
NodeID id = model_tree.AddTerminal(var->symbol);
|
|
return new Objects("", id, eTempResult);
|
|
}
|
|
dynare::Objects* dynare::parser::add_variable(Objects* var,Objects* olag)
|
|
{
|
|
//cout << "add_variable2\n";
|
|
|
|
var = get_symbol(var);
|
|
int lag = atoi((olag->symbol).c_str());
|
|
//cout << "symbol = " << olag->symbol << endl;
|
|
//cout << "lag = " << lag << endl;
|
|
if ((var->type == eEndogenous) || (var->type == eExogenous))
|
|
variable_table.AddVariable(var->symbol,lag);
|
|
//cout << "add_model_token : " << var->ID << endl;
|
|
NodeID id = model_tree.AddTerminal(var->symbol,lag);
|
|
return new Objects("", id, eTempResult);
|
|
}
|
|
dynare::Objects* dynare::parser::get_symbol(Objects* obj)
|
|
{
|
|
if (!symbol_table.Exist(obj->symbol))
|
|
{
|
|
string msg = "Unknown symbol : "+obj->symbol;
|
|
error(msg.c_str());
|
|
}
|
|
obj->ID = (NodeID) symbol_table.getID(obj->symbol);
|
|
obj->type = symbol_table.getType(obj->symbol);
|
|
return obj;
|
|
}
|
|
dynare::Objects* dynare::parser::translate_symbol(Objects* obj)
|
|
{
|
|
if (!symbol_table.Exist(obj->symbol))
|
|
{
|
|
string msg = "Unknown symbol : "+obj->symbol;
|
|
error(msg.c_str());
|
|
}
|
|
obj->ID = (NodeID) symbol_table.getID(obj->symbol);
|
|
obj->type = symbol_table.getType(obj->symbol);
|
|
ostringstream symbol;
|
|
if (obj->type == eEndogenous)
|
|
{
|
|
symbol << "oo_.steady_state(" << (int)obj->ID+1 << ")";
|
|
obj->symbol = symbol.str();
|
|
}
|
|
else if (obj->type == eExogenous)
|
|
{
|
|
symbol << "oo_.exo_steady_state(" << (int)obj->ID+1 << ")";
|
|
obj->symbol = symbol.str();
|
|
}
|
|
else if (obj->type == eExogenousDet)
|
|
{
|
|
symbol << "oo_.exo_det_steady_state(" << (int)obj->ID+1 << ")";
|
|
obj->symbol = symbol.str();
|
|
}
|
|
else if (obj->type == eParameter)
|
|
{
|
|
symbol << "M_.params(" << (int)obj->ID+1 << ")";
|
|
obj->symbol = symbol.str();
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
dynare::Objects* dynare::parser::add_expression_token( Objects* arg1, Objects* arg2, Objects* op)
|
|
{
|
|
int id = expression.AddToken((int) arg1->ID,arg1->type,
|
|
(int) arg2->ID,arg2->type,
|
|
op->opcode);
|
|
//cout << "after add_expression_token\n";
|
|
return new Objects("", (NodeID) id, eTempResult);
|
|
}
|
|
dynare::Objects* dynare::parser::add_expression_token( Objects* arg1, Objects* op)
|
|
{
|
|
int id;
|
|
if (op->opcode != NAME)
|
|
{
|
|
id = expression.AddToken((int) arg1->ID,arg1->type,
|
|
op->opcode);
|
|
}
|
|
else
|
|
{
|
|
id = expression.AddToken((int) arg1->ID,arg1->type,
|
|
op->symbol);
|
|
}
|
|
|
|
//cout << "after add_expression_token\n";
|
|
return new Objects("", (NodeID) id, eTempResult);
|
|
}
|
|
dynare::Objects* dynare::parser::get_expression(Objects* exp)
|
|
{
|
|
if (exp->type == eTempResult)
|
|
{
|
|
expression.set();
|
|
string exp = expression.get();
|
|
expression.clear();
|
|
return new Objects(exp);
|
|
}
|
|
else
|
|
return exp;
|
|
}
|
|
dynare::Objects* dynare::parser::cat(Objects* string1, Objects* string2)
|
|
{
|
|
dynare::Objects* result = new dynare::Objects;
|
|
result->symbol = string1->symbol+string2->symbol;
|
|
return result;
|
|
}
|
|
void dynare::parser::init_param(Objects* lhs, Objects* rhs)
|
|
{
|
|
numerical_initialization.SetConstant(lhs->symbol, rhs->symbol);
|
|
}
|
|
void dynare::parser::init_param(Objects* lhs)
|
|
{
|
|
//cout << "Befor set\n";
|
|
expression.set();
|
|
numerical_initialization.SetConstant(lhs->symbol, expression.get());
|
|
expression.clear();
|
|
}
|
|
void dynare::parser::init_val(Objects* lhs, Objects* rhs)
|
|
{
|
|
numerical_initialization.SetInit(lhs->symbol, rhs->symbol);
|
|
}
|
|
void dynare::parser::hist_val(Objects* lhs, Objects* slag, Objects* rhs)
|
|
{
|
|
int lag = atoi((slag->symbol).c_str());
|
|
numerical_initialization.SetHist(lhs->symbol, lag, rhs->symbol);
|
|
}
|
|
void dynare::parser::hist_val(Objects* lhs, Objects* slag)
|
|
{
|
|
int lag = atoi((slag->symbol).c_str());
|
|
expression.set();
|
|
numerical_initialization.SetHist(lhs->symbol, lag, expression.get());
|
|
expression.clear();
|
|
}
|
|
void dynare::parser::use_dll(void)
|
|
{
|
|
// Seetting variable momber offset to use C outputs
|
|
model_tree.offset = 0;
|
|
}
|
|
void dynare::parser::check_model(void)
|
|
{
|
|
symbol_table.clean();
|
|
}
|
|
void dynare::parser::finish(void)
|
|
{
|
|
|
|
string model_file_name(file_name);
|
|
|
|
// Setting flags to compute what is necessary
|
|
if (order == 1 || linear == 1)
|
|
{
|
|
model_tree.computeJacobianExo = true;
|
|
model_tree.computeJacobian = false;
|
|
}
|
|
else if (order != -1 && linear != -1)
|
|
{
|
|
model_tree.computeHessian = true;
|
|
model_tree.computeJacobianExo = true;
|
|
}
|
|
// Removing extension chars
|
|
model_file_name.erase(model_file_name.size()-4,4);
|
|
model_tree.ModelInitialization();
|
|
|
|
if ( model_tree.computeHessian )
|
|
{
|
|
model_tree.derive(2);
|
|
}
|
|
else
|
|
{
|
|
model_tree.derive(1);
|
|
}
|
|
|
|
cout << "Processing outputs ...\n";
|
|
model_tree.setStaticModel();
|
|
model_tree.setDynamicModel();
|
|
|
|
if (model_tree.offset == 0)
|
|
{
|
|
model_tree.OpenCFiles(model_file_name+"_static", model_file_name+"_dynamic");
|
|
model_tree.SaveCFiles();
|
|
}
|
|
else
|
|
{
|
|
model_tree.OpenMFiles(model_file_name+"_static", model_file_name+"_dynamic");
|
|
model_tree.SaveMFiles();
|
|
}
|
|
|
|
|
|
}
|
|
void dynare::parser::begin_initval(void)
|
|
{
|
|
numerical_initialization.BeginInitval();
|
|
}
|
|
void dynare::parser::end_initval(void)
|
|
{
|
|
numerical_initialization.EndInitval();
|
|
}
|
|
void dynare::parser::begin_endval(void)
|
|
{
|
|
numerical_initialization.BeginEndval();
|
|
}
|
|
void dynare::parser::end_endval(void)
|
|
{
|
|
numerical_initialization.EndEndval();
|
|
}
|
|
void dynare::parser::begin_histval(void)
|
|
{
|
|
numerical_initialization.BeginHistval();
|
|
}
|
|
void dynare::parser::begin_shocks(void)
|
|
{
|
|
shocks.BeginShocks();
|
|
}
|
|
void dynare::parser::add_det_shock(Objects* var)
|
|
{
|
|
if (!symbol_table.Exist(var->symbol))
|
|
{
|
|
string msg = "Unknown symbol : "+var->symbol;
|
|
error(msg.c_str());
|
|
}
|
|
int id = symbol_table.getID(var->symbol);
|
|
shocks.AddShock(eDeterministic, id);
|
|
}
|
|
void dynare::parser::add_stderr_shock(Objects* var, Objects* value)
|
|
{
|
|
if (!symbol_table.Exist(var->symbol))
|
|
{
|
|
string msg = "Unknown symbol : "+var->symbol;
|
|
error(msg.c_str());
|
|
}
|
|
int id = symbol_table.getID(var->symbol);
|
|
shocks.AddShock(eSTDerror, id, 0, value->symbol);
|
|
}
|
|
void dynare::parser::add_var_shock(Objects* var, Objects* value)
|
|
{
|
|
if (!symbol_table.Exist(var->symbol))
|
|
{
|
|
string msg = "Unknown symbol : "+var->symbol;
|
|
error(msg.c_str());
|
|
}
|
|
int id = symbol_table.getID(var->symbol);
|
|
shocks.AddShock(eVariance, id, 0, value->symbol);
|
|
}
|
|
void dynare::parser::add_covar_shock(Objects* var1, Objects* var2, Objects* value)
|
|
{
|
|
if (!symbol_table.Exist(var1->symbol))
|
|
{
|
|
string msg = "Unknown symbol : "+var1->symbol;
|
|
error(msg.c_str());
|
|
}
|
|
if (!symbol_table.Exist(var2->symbol))
|
|
{
|
|
string msg = "Unknown symbol : "+var2->symbol;
|
|
error(msg.c_str());
|
|
}
|
|
int id1 = symbol_table.getID(var1->symbol);
|
|
int id2 = symbol_table.getID(var2->symbol);
|
|
shocks.AddShock(eCovariance, id1, id2, value->symbol);
|
|
}
|
|
void dynare::parser::add_correl_shock(Objects* var1, Objects* var2, Objects* value)
|
|
{
|
|
if (!symbol_table.Exist(var1->symbol))
|
|
{
|
|
string msg = "Unknown symbol : "+var1->symbol;
|
|
error(msg.c_str());
|
|
}
|
|
if (!symbol_table.Exist(var2->symbol))
|
|
{
|
|
string msg = "Unknown symbol : "+var2->symbol;
|
|
error(msg.c_str());
|
|
}
|
|
int id1 = symbol_table.getID(var1->symbol);
|
|
int id2 = symbol_table.getID(var2->symbol);
|
|
shocks.AddShock(eCorrelation, id1, id2, value->symbol);
|
|
}
|
|
void dynare::parser::add_period(Objects* p1, Objects* p2)
|
|
{
|
|
shocks.AddPeriod(p1->symbol, p2->symbol);
|
|
}
|
|
void dynare::parser::add_period(Objects* p1)
|
|
{
|
|
shocks.AddPeriod(p1->symbol, p1->symbol);
|
|
}
|
|
void dynare::parser::add_value(Objects* value)
|
|
{
|
|
shocks.AddValue(value->symbol);
|
|
}
|
|
void dynare::parser::do_sigma_e(void)
|
|
{
|
|
sigmae.set();
|
|
}
|
|
void dynare::parser::end_of_row(void)
|
|
{
|
|
sigmae.EndOfRow();
|
|
}
|
|
void dynare::parser::add_to_row(Objects* s)
|
|
{
|
|
sigmae.AddExpression(s->symbol);
|
|
}
|
|
void dynare::parser::steady(void)
|
|
{
|
|
computing_tasks.setSteady();
|
|
model_tree.computeJacobian = true;
|
|
}
|
|
void dynare::parser::option_num(string name_option, Objects* opt)
|
|
{
|
|
computing_tasks.setOption(name_option, opt->symbol);
|
|
if (name_option == "order")
|
|
order = atoi((opt->symbol).c_str());
|
|
else if (name_option == "linear")
|
|
linear = atoi((opt->symbol).c_str());
|
|
}
|
|
void dynare::parser::option_num(string name_option, Objects* opt1, Objects* opt2)
|
|
{
|
|
computing_tasks.setOption(name_option, opt1->symbol, opt2->symbol);
|
|
}
|
|
void dynare::parser::option_num(string name_option, string opt)
|
|
{
|
|
computing_tasks.setOption(name_option, opt);
|
|
if (name_option == "order")
|
|
order = atoi(opt.c_str());
|
|
else if (name_option == "linear")
|
|
linear = atoi(opt.c_str());
|
|
}
|
|
void dynare::parser::option_str(string name_option, Objects* opt)
|
|
{
|
|
opt->symbol = "'"+opt->symbol;
|
|
opt->symbol += "'";
|
|
computing_tasks.setOption(name_option, opt->symbol);
|
|
}
|
|
void dynare::parser::option_str(string name_option, string opt)
|
|
{
|
|
opt = "'"+opt;
|
|
opt += "'";
|
|
computing_tasks.setOption(name_option, opt);
|
|
}
|
|
void dynare::parser::add_tmp_var(Objects* tmp_var1, Objects* tmp_var2)
|
|
{
|
|
tmp_symbol_table.AddTempSymbol(tmp_var1->symbol, tmp_var2->symbol);
|
|
}
|
|
void dynare::parser::add_tmp_var(Objects* tmp_var)
|
|
{
|
|
tmp_symbol_table.AddTempSymbol(tmp_var->symbol);
|
|
}
|
|
// dynare::Objects* get_tmp_var(string)
|
|
// {
|
|
// //string str = tmp_symbol_table.get
|
|
// }
|
|
void dynare::parser::rplot()
|
|
{
|
|
tmp_symbol_table.set("var_list_");
|
|
string tmp = tmp_symbol_table.get();
|
|
computing_tasks.runRplot(tmp);
|
|
}
|
|
void dynare::parser::stoch_simul()
|
|
{
|
|
// If order and linear not set, then set them to default values
|
|
if (order == -1)
|
|
{
|
|
order = 2;
|
|
}
|
|
if (linear == -1)
|
|
{
|
|
linear = 0;
|
|
}
|
|
|
|
tmp_symbol_table.set("var_list_");
|
|
string tmp = tmp_symbol_table.get();
|
|
computing_tasks.setStochSimul(tmp);
|
|
}
|
|
void dynare::parser::simul()
|
|
{
|
|
computing_tasks.setSimul();
|
|
model_tree.computeJacobian = true;
|
|
}
|
|
void dynare::parser::check()
|
|
{
|
|
computing_tasks.setCheck();
|
|
model_tree.computeJacobian = true;
|
|
}
|
|
void dynare::parser::estimation_init()
|
|
{
|
|
computing_tasks.EstimParams = &estim_params;
|
|
computing_tasks.setEstimationInit();
|
|
model_tree.computeJacobianExo = true;
|
|
}
|
|
void dynare::parser::set_estimated_elements(void)
|
|
{
|
|
computing_tasks.setEstimatedElements();
|
|
}
|
|
void dynare::parser::set_unit_root_vars()
|
|
{
|
|
tmp_symbol_table.set("options_.unit_root_vars");
|
|
*output << tmp_symbol_table.get();
|
|
}
|
|
void dynare::parser::run_estimation()
|
|
{
|
|
tmp_symbol_table.set("var_list_");
|
|
string tmp = tmp_symbol_table.get();
|
|
computing_tasks.runEstimation(tmp);
|
|
}
|
|
void dynare::parser::optim_options(Objects* str1, Objects* str2, int task)
|
|
{
|
|
computing_tasks.setOptimOptions(str1->symbol, str2->symbol, task);
|
|
}
|
|
void dynare::parser::optim_options(int task)
|
|
{
|
|
computing_tasks.setOptimOptions("", "", task);
|
|
}
|
|
void dynare::parser::set_varobs()
|
|
{
|
|
tmp_symbol_table.set("options_.varobs");
|
|
*output << tmp_symbol_table.get();
|
|
}
|
|
void dynare::parser::set_trend_init()
|
|
{
|
|
*output << "options_.trend_coeff_ = {};\n";
|
|
}
|
|
void dynare::parser::set_trend_element(Objects* arg1, Objects* arg2)
|
|
{
|
|
computing_tasks.set_trend_element(arg1->symbol, arg2->symbol);
|
|
}
|
|
void dynare::parser::begin_optim_weights(void)
|
|
{
|
|
computing_tasks.BeginOptimWeights();
|
|
}
|
|
void dynare::parser::set_optim_weights(Objects* arg1, Objects* arg2)
|
|
{
|
|
computing_tasks.setOptimWeights(arg1->symbol, arg2->symbol);
|
|
}
|
|
void dynare::parser::set_optim_weights(Objects* arg1, Objects* arg2, Objects* arg3)
|
|
{
|
|
computing_tasks.setOptimWeights(arg1->symbol, arg2->symbol, arg3->symbol);
|
|
}
|
|
void dynare::parser::set_osr_params(void)
|
|
{
|
|
tmp_symbol_table.set("osr_params_");
|
|
string tmp = tmp_symbol_table.get();
|
|
computing_tasks.setOsrParams(tmp);
|
|
}
|
|
void dynare::parser::run_osr(void)
|
|
{
|
|
tmp_symbol_table.set("var_list_");
|
|
string tmp = tmp_symbol_table.get();
|
|
computing_tasks.runOsr(tmp);
|
|
}
|
|
void dynare::parser::set_olr_inst(void)
|
|
{
|
|
tmp_symbol_table.set("options_.olr_inst");
|
|
string tmp = tmp_symbol_table.get();
|
|
computing_tasks.setOlrInst(tmp);
|
|
}
|
|
void dynare::parser::run_olr(void)
|
|
{
|
|
tmp_symbol_table.set("var_list_");
|
|
string tmp = tmp_symbol_table.get();
|
|
computing_tasks.runOlr(tmp);
|
|
}
|
|
void dynare::parser::begin_calib_var(void)
|
|
{
|
|
computing_tasks.BeginCalibVar();
|
|
}
|
|
void dynare::parser::set_calib_var(Objects* name, Objects* weight, Objects* expression)
|
|
{
|
|
Objects* exp = get_expression(expression);
|
|
computing_tasks.setCalibVar(name->symbol,weight->symbol,exp->symbol);
|
|
}
|
|
void dynare::parser::set_calib_var(Objects* name1, Objects* name2, Objects* weight, Objects* expression)
|
|
{
|
|
Objects* exp = get_expression(expression);
|
|
computing_tasks.setCalibVar(name1->symbol,name2->symbol,weight->symbol,exp->symbol);
|
|
}
|
|
void dynare::parser::set_calib_ac(Objects* name, Objects* ar, Objects* weight, Objects* expression)
|
|
{
|
|
Objects* exp = get_expression(expression);
|
|
computing_tasks.setCalibAc(name->symbol,ar->symbol,weight->symbol,exp->symbol);
|
|
}
|
|
void dynare::parser::run_calib(int flag)
|
|
{
|
|
computing_tasks.runCalib(flag);
|
|
}
|
|
void dynare::parser::run_dynatype(Objects* filename, Objects* ext)
|
|
{
|
|
tmp_symbol_table.set("var_list_");
|
|
string tmp = tmp_symbol_table.get();
|
|
computing_tasks.runDynatype(filename->symbol,ext->symbol,tmp);
|
|
}
|
|
void dynare::parser::run_dynasave(Objects* filename, Objects* ext)
|
|
{
|
|
tmp_symbol_table.set("var_list_");
|
|
string tmp = tmp_symbol_table.get();
|
|
computing_tasks.runDynasave(filename->symbol,ext->symbol,tmp);
|
|
}
|
|
void dynare::parser::begin_model_comparison(void)
|
|
{
|
|
computing_tasks.beginModelComparison();
|
|
}
|
|
void dynare::parser::add_mc_filename(Objects* filename, Objects* prior)
|
|
{
|
|
computing_tasks.addMcFilename(filename->symbol, prior->symbol);
|
|
}
|
|
void dynare::parser::run_model_comparison(void)
|
|
{
|
|
computing_tasks.runModelComparison();
|
|
}
|
|
dynare::Objects* dynare::parser::add_equal(Objects* arg1, Objects* arg2)
|
|
{
|
|
NodeID id = model_tree.AddEqual(arg1->ID, arg2->ID);
|
|
model_parameters.eq_nbr++;
|
|
return new Objects("", id, eTempResult);
|
|
}
|
|
|
|
dynare::Objects* dynare::parser::add_plus(Objects* arg1, Objects* arg2)
|
|
{
|
|
NodeID id = model_tree.AddPlus(arg1->ID, arg2->ID);
|
|
return new Objects("", id, eTempResult);
|
|
}
|
|
|
|
dynare::Objects* dynare::parser::add_minus(Objects* arg1, Objects* arg2)
|
|
{
|
|
NodeID id = model_tree.AddMinus(arg1->ID, arg2->ID);
|
|
return new Objects("", id, eTempResult);
|
|
}
|
|
dynare::Objects* dynare::parser::add_uminus(Objects* arg1)
|
|
{
|
|
NodeID id = model_tree.AddUMinus(arg1->ID);
|
|
return new Objects("", id, eTempResult);
|
|
}
|
|
dynare::Objects* dynare::parser::add_times(Objects* arg1, Objects* arg2)
|
|
{
|
|
NodeID id = model_tree.AddTimes(arg1->ID, arg2->ID);
|
|
return new Objects("", id, eTempResult);
|
|
}
|
|
dynare::Objects* dynare::parser::add_divide(Objects* arg1, Objects* arg2)
|
|
{
|
|
NodeID id = model_tree.AddDivide(arg1->ID, arg2->ID);
|
|
return new Objects("", id, eTempResult);
|
|
}
|
|
dynare::Objects* dynare::parser::add_power(Objects* arg1, Objects* arg2)
|
|
{
|
|
NodeID id = model_tree.AddPower(arg1->ID, arg2->ID);
|
|
return new Objects("", id, eTempResult);
|
|
}
|
|
dynare::Objects* dynare::parser::add_exp(Objects* arg1)
|
|
{
|
|
NodeID id = model_tree.AddExp(arg1->ID);
|
|
return new Objects("", id, eTempResult);
|
|
}
|
|
dynare::Objects* dynare::parser::add_log(Objects* arg1)
|
|
{
|
|
NodeID id = model_tree.AddLog(arg1->ID);
|
|
return new Objects("", id, eTempResult);
|
|
}
|
|
dynare::Objects* dynare::parser::add_log10(Objects* arg1)
|
|
{
|
|
NodeID id = model_tree.AddLog10(arg1->ID);
|
|
return new Objects("", id, eTempResult);
|
|
}
|
|
dynare::Objects* dynare::parser::add_cos(Objects* arg1)
|
|
{
|
|
NodeID id = model_tree.AddCos(arg1->ID);
|
|
return new Objects("", id, eTempResult);
|
|
}
|
|
dynare::Objects* dynare::parser::add_sin(Objects* arg1)
|
|
{
|
|
NodeID id = model_tree.AddSin(arg1->ID);
|
|
return new Objects("", id, eTempResult);
|
|
}
|
|
dynare::Objects* dynare::parser::add_tan(Objects* arg1)
|
|
{
|
|
NodeID id = model_tree.AddTan(arg1->ID);
|
|
return new Objects("", id, eTempResult);
|
|
}
|
|
dynare::Objects* dynare::parser::add_acos(Objects* arg1)
|
|
{
|
|
NodeID id = model_tree.AddACos(arg1->ID);
|
|
return new Objects("", id, eTempResult);
|
|
}
|
|
dynare::Objects* dynare::parser::add_asin(Objects* arg1)
|
|
{
|
|
NodeID id = model_tree.AddASin(arg1->ID);
|
|
return new Objects("", id, eTempResult);
|
|
}
|
|
dynare::Objects* dynare::parser::add_atan(Objects* arg1)
|
|
{
|
|
NodeID id = model_tree.AddATan(arg1->ID);
|
|
return new Objects("", id, eTempResult);
|
|
}
|
|
dynare::Objects* dynare::parser::add_cosh(Objects* arg1)
|
|
{
|
|
NodeID id = model_tree.AddCosH(arg1->ID);
|
|
return new Objects("", id, eTempResult);
|
|
}
|
|
dynare::Objects* dynare::parser::add_sinh(Objects* arg1)
|
|
{
|
|
NodeID id = model_tree.AddSinH(arg1->ID);
|
|
return new Objects("", id, eTempResult);
|
|
}
|
|
dynare::Objects* dynare::parser::add_tanh(Objects* arg1)
|
|
{
|
|
NodeID id = model_tree.AddTanH(arg1->ID);
|
|
return new Objects("", id, eTempResult);
|
|
}
|
|
dynare::Objects* dynare::parser::add_acosh(Objects* arg1)
|
|
{
|
|
NodeID id = model_tree.AddACosH(arg1->ID);
|
|
return new Objects("", id, eTempResult);
|
|
}
|
|
dynare::Objects* dynare::parser::add_asinh(Objects* arg1)
|
|
{
|
|
NodeID id = model_tree.AddASinH(arg1->ID);
|
|
return new Objects("", id, eTempResult);
|
|
}
|
|
dynare::Objects* dynare::parser::add_atanh(Objects* arg1)
|
|
{
|
|
NodeID id = model_tree.AddATanH(arg1->ID);
|
|
return new Objects("", id, eTempResult);
|
|
}
|
|
dynare::Objects* dynare::parser::add_sqrt(Objects* arg1)
|
|
{
|
|
NodeID id = model_tree.AddSqRt(arg1->ID);
|
|
return new Objects("", id, eTempResult);
|
|
}
|