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

preprocessor: VAR restrictions

issue#70
Houtan Bastani 2017-05-04 18:06:50 +02:00
parent 33f659a866
commit 1a1e2c1810
8 changed files with 436 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

139
ComputingTasks.cc
View File

@ -236,6 +236,145 @@ VarModelStatement::createVarModelMFunction(ostream &output, const map<string, se
output << ");" << endl;
}
VarRestrictionsStatement::VarRestrictionsStatement(const string &var_model_name_arg,
const map<int, map<int, SymbolList> > &exclusion_restrictions_arg,
const equation_restrictions_t &equation_restrictions_arg,
const crossequation_restrictions_t &crossequation_restrictions_arg,
const map<pair<int, int>, double> &covariance_number_restriction_arg,
const map<pair<int, int>, pair<int, int> > &covariance_pair_restriction_arg) :
var_model_name(var_model_name_arg),
exclusion_restrictions(exclusion_restrictions_arg),
equation_restrictions(equation_restrictions_arg),
crossequation_restrictions(crossequation_restrictions_arg),
covariance_number_restriction(covariance_number_restriction_arg),
covariance_pair_restriction(covariance_pair_restriction_arg)
{
}
void
VarRestrictionsStatement::writeOutput(ostream &output, const string &basename, bool minimal_workspace) const
{
output << "nvarrest = 1;" << endl
<< "if isfield(M_.var, 'restrictions')" << endl
<< " nvarrest = length(M_.var.restrictions);" << endl
<< "end" << endl
<< "M_.var.restrictions{nvarrest}.name = '" << var_model_name << "';" << endl;
// Exclusion Restrictions
int idx = 1;
for (map<int, map<int, SymbolList> >::const_iterator it = exclusion_restrictions.begin();
it != exclusion_restrictions.end(); it++, idx++)
{
output << "M_.var.restrictions{nvarrest}.exclusion_restrictions{" << idx<< "}.lag = "
<< it->first << ";" << endl
<< "M_.var.restrictions{nvarrest}.exclusion_restrictions{" << it->first << "}.restrictions = [";
for (map<int, SymbolList>::const_iterator it1 = it->second.begin();
it1 != it->second.end(); it1++)
{
if (it1 != it->second.begin())
output << " ";
output << "{" << it1->first + 1 << " ";
it1->second.write(output);
output << "};";
}
output << "];" << endl;
}
// Equation Restrictions
idx = 1;
for (equation_restrictions_t::const_iterator it = equation_restrictions.begin();
it != equation_restrictions.end(); it++, idx++)
{
output << "M_.var.restrictions{nvarrest}.equation_restriction{" << idx << "}.eqsymb_id = "
<< it->first + 1 << ";" << endl
<< "M_.var.restrictions{nvarrest}.equation_restriction{" << idx << "}.val = "
<< it->second.second << ";" << endl;
var_restriction_eq_crosseq_t ls = it->second.first.first;
output << "M_.var.restrictions{nvarrest}.equation_restriction{" << idx << "}.lssymb_id = "
<< ls.first.first + 1 << ";" << endl
<< "M_.var.restrictions{nvarrest}.equation_restriction{" << idx << "}.lslag = "
<< ls.first.second.second << ";" << endl
<< "M_.var.restrictions{nvarrest}.equation_restriction{" << idx << "}.lscoeff = ";
ls.second->writeOutput(output);
output << ";" << endl;
var_restriction_eq_crosseq_t rs = it->second.first.second;
if (rs.first.first >= 0)
{
output << "M_.var.restrictions{nvarrest}.equation_restriction{" << idx << "}.rssymb_id = "
<< rs.first.first + 1 << ";" << endl
<< "M_.var.restrictions{nvarrest}.equation_restriction{" << idx << "}.rslag = "
<< rs.first.second.second << ";" << endl
<< "M_.var.restrictions{nvarrest}.equation_restriction{" << idx << "}.rscoeff = ";
rs.second->writeOutput(output);
output << ";" << endl;
}
}
// Cross Equation Restrictions
idx = 1;
for (crossequation_restrictions_t::const_iterator it = crossequation_restrictions.begin();
it != crossequation_restrictions.end(); it++, idx++)
{
output << "M_.var.restrictions{nvarrest}.crossequation_restriction{" << idx << "}.eqsymb_id1 = "
<< it->first.first + 1 << ";" << endl
<< "M_.var.restrictions{nvarrest}.crossequation_restriction{" << idx << "}.eqsymb_id2 = "
<< it->first.second + 1 << ";" << endl
<< "M_.var.restrictions{nvarrest}.crossequation_restriction{" << idx << "}.val = "
<< it->second.second << ";" << endl;
var_restriction_eq_crosseq_t ls = it->second.first.first;
output << "M_.var.restrictions{nvarrest}.crossequation_restriction{" << idx << "}.lssymb_id1 = "
<< ls.first.first + 1 << ";" << endl
<< "M_.var.restrictions{nvarrest}.crossequation_restriction{" << idx << "}.lssymb_id2 = "
<< ls.first.second.first + 1 << ";" << endl
<< "M_.var.restrictions{nvarrest}.crossequation_restriction{" << idx << "}.lslag = "
<< ls.first.second.second << ";" << endl
<< "M_.var.restrictions{nvarrest}.crossequation_restriction{" << idx << "}.lscoeff = ";
ls.second->writeOutput(output);
output << ";" << endl;
var_restriction_eq_crosseq_t rs = it->second.first.second;
if (rs.first.first >= 0)
{
output << "M_.var.restrictions{nvarrest}.crossequation_restriction{" << idx << "}.rssymb_id1 = "
<< rs.first.first + 1 << ";" << endl
<< "M_.var.restrictions{nvarrest}.crossequation_restriction{" << idx << "}.rssymb_id2 = "
<< rs.first.second.first + 1 << ";" << endl
<< "M_.var.restrictions{nvarrest}.crossequation_restriction{" << idx << "}.rslag = "
<< rs.first.second.second << ";" << endl
<< "M_.var.restrictions{nvarrest}.crossequation_restriction{" << idx << "}.rscoeff = ";
rs.second->writeOutput(output);
output << ";" << endl;
}
}
// Covariance Const Restrictions
idx = 1;
for (map<pair<int, int>, double>::const_iterator it = covariance_number_restriction.begin();
it != covariance_number_restriction.end(); it++, idx++)
output << "M_.var.restrictions{nvarrest}.covariance_const_restriction{" << idx << "}.symb_id1 = "
<< it->first.first << ";" << endl
<< "M_.var.restrictions{nvarrest}.covariance_const_restriction{" << idx << "}.symb_id2 = "
<< it->first.second << ";" << endl
<< "M_.var.restrictions{nvarrest}.covariance_const_restriction{" << idx << "}.val = "
<< it->second << ";" << endl;
// Covariance Pair Restrictions
idx = 1;
for (map<pair<int, int>, pair<int, int> >::const_iterator it = covariance_pair_restriction.begin();
it != covariance_pair_restriction.end(); it++, idx++)
output << "M_.var.restrictions{nvarrest}.covariance_pair_restriction{" << idx << "}.symb_id11 = "
<< it->first.first << ";" << endl
<< "M_.var.restrictions{nvarrest}.covariance_pair_restriction{" << idx << "}.symb_id12 = "
<< it->first.second << ";" << endl
<< "M_.var.restrictions{nvarrest}.covariance_pair_restriction{" << idx << "}.symb_id21 = "
<< it->second.first << ";" << endl
<< "M_.var.restrictions{nvarrest}.covariance_pair_restriction{" << idx << "}.symb_id22 = "
<< it->second.second << ";" << endl;
}
StochSimulStatement::StochSimulStatement(const SymbolList &symbol_list_arg,
const OptionsList &options_list_arg) :
symbol_list(symbol_list_arg),

22
ComputingTasks.hh
View File

@ -126,6 +126,28 @@ public:
void createVarModelMFunction(ostream &output, const map<string, set<int> > &var_expectation_functions_to_write) const;
};
class VarRestrictionsStatement : public Statement
{
private:
typedef pair<pair<int, pair<int, int> >, expr_t> var_restriction_eq_crosseq_t;
const string &var_model_name;
const map<int, map<int, SymbolList> > exclusion_restrictions;
typedef map<int, pair<pair<var_restriction_eq_crosseq_t, var_restriction_eq_crosseq_t>, double> > equation_restrictions_t;
const equation_restrictions_t equation_restrictions;
typedef map<pair<int, int>, pair<pair<var_restriction_eq_crosseq_t, var_restriction_eq_crosseq_t>, double> > crossequation_restrictions_t;
const crossequation_restrictions_t crossequation_restrictions;
const map<pair<int, int>, double> covariance_number_restriction;
const map<pair<int, int>, pair<int, int> > covariance_pair_restriction;
public:
VarRestrictionsStatement(const string &var_model_name_arg,
const map<int, map<int, SymbolList> > &exclusion_restrictions_arg,
const equation_restrictions_t &equation_restrictions_arg,
const crossequation_restrictions_t &crossequation_restrictions_arg,
const map<pair<int, int>, double> &covariance_number_restriction_arg,
const map<pair<int, int>, pair<int, int> > &covariance_pair_restriction_arg);
virtual void writeOutput(ostream &output, const string &basename, bool minimal_workspace) const;
};
class ForecastStatement : public Statement
{
private:

88
DynareBison.yy
View File

@ -130,7 +130,7 @@ class ParsingDriver;
%token <string_val> TEX_NAME
%token UNIFORM_PDF UNIT_ROOT_VARS USE_DLL USEAUTOCORR GSA_SAMPLE_FILE USE_UNIVARIATE_FILTERS_IF_SINGULARITY_IS_DETECTED
%token VALUES VAR VAREXO VAREXO_DET VAROBS VAREXOBS PREDETERMINED_VARIABLES VAR_EXPECTATION PLOT_SHOCK_DECOMPOSITION
%token WRITE_LATEX_DYNAMIC_MODEL WRITE_LATEX_STATIC_MODEL WRITE_LATEX_ORIGINAL_MODEL
%token WRITE_LATEX_DYNAMIC_MODEL WRITE_LATEX_STATIC_MODEL WRITE_LATEX_ORIGINAL_MODEL CROSSEQUATIONS COVARIANCE
%token XLS_SHEET XLS_RANGE LMMCP OCCBIN BANDPASS_FILTER COLORMAP VAR_MODEL QOQ YOY AOA
%left COMMA
%left EQUAL_EQUAL EXCLAMATION_EQUAL
@ -180,7 +180,7 @@ class ParsingDriver;
%type <node_val> expression expression_or_empty
%type <node_val> equation hand_side
%type <string_val> non_negative_number signed_number signed_integer date_str
%type <string_val> filename symbol vec_of_vec_value vec_value_list date_expr
%type <string_val> filename symbol vec_of_vec_value vec_value_list date_expr number
%type <string_val> vec_value_1 vec_value signed_inf signed_number_w_inf
%type <string_val> range vec_value_w_inf vec_value_1_w_inf
%type <string_val> integer_range signed_integer_range sub_sampling_options list_sub_sampling_option
@ -225,6 +225,7 @@ statement : parameters
| set_time
| data
| var_model
| restrictions
| prior
| prior_eq
| subsamples
@ -371,6 +372,85 @@ var_model_options : o_var_name
| o_var_method
;
restrictions : RESTRICTIONS '(' symbol ')' ';' { driver.begin_VAR_restrictions(); }
restrictions_list END ';' { driver.end_VAR_restrictions($3); }
;
restrictions_list : restrictions_list restriction
| restriction
;
restriction : EXCLUSION LAG INT_NUMBER ';' restriction_exclusion_equation_list
{ driver.add_VAR_exclusion_restriction($3); }
| RESTRICTION EQUATION '(' symbol ')' restriction_equation_equality ';'
{ driver.add_VAR_restriction_equation_or_crossequation_final($4, NULL); }
| RESTRICTION CROSSEQUATIONS '(' symbol COMMA symbol ')' restriction_crossequation_equality ';'
{ driver.add_VAR_restriction_equation_or_crossequation_final($4, $6); }
| RESTRICTION COVARIANCE '(' symbol COMMA symbol ')' EQUAL number ';'
{ driver.add_VAR_covariance_number_restriction($4, $6, $9); }
| RESTRICTION COVARIANCE '(' symbol COMMA symbol ')' EQUAL '(' symbol COMMA symbol ')' ';'
{ driver.add_VAR_covariance_pair_restriction($4, $6, $10, $12); }
;
restriction_equation_equality : restriction_equation_equality_side PLUS restriction_equation_equality_side EQUAL number
{ driver.add_VAR_restriction_equation_or_crossequation($5); }
| restriction_equation_equality_side MINUS restriction_equation_equality_side EQUAL number
{
driver.multiply_arg2_by_neg_one();
driver.add_VAR_restriction_equation_or_crossequation($5);
}
| restriction_equation_equality_side EQUAL number
{ driver.add_VAR_restriction_equation_or_crossequation($3); }
;
restriction_equation_equality_side : coeff_def TIMES expression
{ driver.add_VAR_restriction_eq_or_crosseq($3); }
| coeff_def DIVIDE expression
{
string *onestr = new string("1");
expr_t one = driver.add_non_negative_constant(onestr);
driver.add_VAR_restriction_eq_or_crosseq(driver.add_divide(one, $3));
}
;
coeff_def : COEFF '(' symbol COMMA INT_NUMBER ')'
{ driver.add_VAR_restriction_coeff($3, NULL, $5); }
;
restriction_crossequation_equality : restriction_crossequation_equality_side PLUS restriction_crossequation_equality_side EQUAL number
{ driver.add_VAR_restriction_equation_or_crossequation($5); }
| restriction_crossequation_equality_side MINUS restriction_crossequation_equality_side EQUAL number
{
driver.multiply_arg2_by_neg_one();
driver.add_VAR_restriction_equation_or_crossequation($5);
}
| restriction_crossequation_equality_side EQUAL number
{ driver.add_VAR_restriction_equation_or_crossequation($3); }
;
restriction_crossequation_equality_side : coeff_def1 TIMES expression
{ driver.add_VAR_restriction_eq_or_crosseq($3); }
| coeff_def1 DIVIDE expression
{
string *onestr = new string("1");
expr_t one = driver.add_non_negative_constant(onestr);
driver.add_VAR_restriction_eq_or_crosseq(driver.add_divide(one, $3));
}
;
coeff_def1 : COEFF '(' symbol COMMA symbol COMMA INT_NUMBER ')'
{ driver.add_VAR_restriction_coeff($3, $5, $7); }
;
restriction_exclusion_equation_list : restriction_exclusion_equation_list restriction_exclusion_equation
| restriction_exclusion_equation
;
restriction_exclusion_equation : EQUATION '(' symbol ')' symbol_list ';'
{ driver.add_VAR_restriction_exclusion_equation($3); }
;
nonstationary_var_list : nonstationary_var_list symbol
{ driver.declare_nonstationary_var($2); }
| nonstationary_var_list COMMA symbol
@ -3572,6 +3652,10 @@ symbol : NAME
| DR
| PRIOR
;
number : INT_NUMBER
| FLOAT_NUMBER
;
%%
void

3
DynareFlex.ll
View File

@ -208,6 +208,7 @@ DATE -?[0-9]+([YyAa]|[Mm]([1-9]|1[0-2])|[Qq][1-4]|[Ww]([1-9]{1}|[1-4][0-9]|5[0-2
<INITIAL>moment_calibration {BEGIN DYNARE_BLOCK; return token::MOMENT_CALIBRATION;}
<INITIAL>irf_calibration {BEGIN DYNARE_BLOCK; return token::IRF_CALIBRATION;}
<INITIAL>ramsey_constraints {BEGIN DYNARE_BLOCK; return token::RAMSEY_CONSTRAINTS;}
<INITIAL>restrictions {BEGIN DYNARE_BLOCK; return token::RESTRICTIONS;}
/* For the semicolon after an "end" keyword */
<INITIAL>; {return Dynare::parser::token_type (yytext[0]);}
@ -369,6 +370,8 @@ DATE -?[0-9]+([YyAa]|[Mm]([1-9]|1[0-2])|[Qq][1-4]|[Ww]([1-9]{1}|[1-4][0-9]|5[0-2
<DYNARE_STATEMENT>restriction_fname {return token::RESTRICTION_FNAME;}
<DYNARE_STATEMENT>nlags {return token::NLAGS;}
<DYNARE_STATEMENT>restrictions {return token::RESTRICTIONS;}
<DYNARE_BLOCK>crossequations {return token::CROSSEQUATIONS;}
<DYNARE_BLOCK>covariance {return token::COVARIANCE;}
<DYNARE_STATEMENT>cross_restrictions {return token::CROSS_RESTRICTIONS;}
<DYNARE_STATEMENT>contemp_reduced_form {return token::CONTEMP_REDUCED_FORM;}
<DYNARE_STATEMENT>real_pseudo_forecast {return token::REAL_PSEUDO_FORECAST;}

143
ParsingDriver.cc
View File

@ -481,6 +481,149 @@ ParsingDriver::end_nonstationary_var(bool log_deflator, expr_t deflator)
reset_data_tree();
}
void
ParsingDriver::begin_VAR_restrictions()
{
clear_VAR_storage();
}
void
ParsingDriver::end_VAR_restrictions(string *var_model_name)
{
mod_file->addStatement(new VarRestrictionsStatement(*var_model_name,
exclusion_restrictions,
equation_restrictions,
crossequation_restrictions,
covariance_number_restriction,
covariance_pair_restriction));
clear_VAR_storage();
}
void
ParsingDriver::clear_VAR_storage()
{
exclusion_restriction.clear();
exclusion_restrictions.clear();
symbol_list.clear();
var_restriction_eq_or_crosseq.clear();
equation_restrictions.clear();
crossequation_restrictions.clear();
covariance_number_restriction.clear();
covariance_pair_restriction.clear();
}
void
ParsingDriver::add_VAR_exclusion_restriction(string *lagstr)
{
int lag = atoi(lagstr->c_str());
map<int, map<int, SymbolList> >::iterator it = exclusion_restrictions.find(lag);
if (it == exclusion_restrictions.end())
exclusion_restrictions[lag] = exclusion_restriction;
else
for (map<int, SymbolList>::const_iterator it1 = exclusion_restriction.begin();
it1 != exclusion_restriction.end(); it1++)
it->second[it1->first] = it1->second;
exclusion_restriction.clear();
delete lagstr;
}
void
ParsingDriver::add_VAR_restriction_coeff(string *name1, string *name2, string *lagstr)
{
int symb_id1 = mod_file->symbol_table.getID(*name1);
int symb_id2 = name2 == NULL ? -1 : mod_file->symbol_table.getID(*name2);
int lag = atoi(lagstr->c_str());
var_restriction_coeff = make_pair(symb_id1, make_pair(symb_id2, lag));
delete name1;
if (name2 != NULL)
delete name2;
delete lagstr;
}
void
ParsingDriver::add_VAR_restriction_eq_or_crosseq(expr_t expr)
{
var_restriction_eq_or_crosseq.push_back(make_pair(var_restriction_coeff, expr));
}
void
ParsingDriver::add_VAR_restriction_equation_or_crossequation(string *numberstr)
{
assert(var_restriction_eq_or_crosseq.size() > 0 && var_restriction_eq_or_crosseq.size() < 3);
double number = atof(numberstr->c_str());
if (var_restriction_eq_or_crosseq.size() == 1)
var_restriction_equation_or_crossequation = make_pair(make_pair(var_restriction_eq_or_crosseq[0],
make_pair(make_pair(-1, make_pair(-1, -1)), (expr_t)NULL)),
number);
else
var_restriction_equation_or_crossequation = make_pair(make_pair(var_restriction_eq_or_crosseq[0],
var_restriction_eq_or_crosseq[1]),
number);
var_restriction_eq_or_crosseq.clear();
}
void
ParsingDriver::multiply_arg2_by_neg_one()
{
assert(var_restriction_eq_or_crosseq.size() == 2);
expr_t exprtm1 = add_times(var_restriction_eq_or_crosseq[1].second,
add_uminus(add_non_negative_constant(new string("-1"))));
var_restriction_eq_or_crosseq[1] = make_pair(var_restriction_eq_or_crosseq[1].first, exprtm1);
}
void
ParsingDriver::add_VAR_restriction_equation_or_crossequation_final(string *name1, string *name2)
{
int symb_id1 = mod_file->symbol_table.getID(*name1);
if (name2 == NULL)
equation_restrictions[symb_id1] = var_restriction_equation_or_crossequation;
else
{
int symb_id2 = name2 == NULL ? -1 : mod_file->symbol_table.getID(*name2);
crossequation_restrictions[make_pair(symb_id1, symb_id2)] = var_restriction_equation_or_crossequation;
delete name2;
}
delete name1;
}
void
ParsingDriver::add_VAR_restriction_exclusion_equation(string *name)
{
int symb_id = mod_file->symbol_table.getID(*name);
exclusion_restriction[symb_id] = symbol_list;
symbol_list.clear();
delete name;
}
void
ParsingDriver::add_VAR_covariance_number_restriction(string *name1, string *name2, string *valuestr)
{
int symb_id1 = mod_file->symbol_table.getID(*name1);
int symb_id2 = mod_file->symbol_table.getID(*name2);
double value = atof(valuestr->c_str());
covariance_number_restriction[make_pair(symb_id1, symb_id2)] = value;
delete name1;
delete name2;
delete valuestr;
}
void
ParsingDriver::add_VAR_covariance_pair_restriction(string *name11, string *name12, string *name21, string *name22)
{
int symb_id11 = mod_file->symbol_table.getID(*name11);
int symb_id12 = mod_file->symbol_table.getID(*name12);
int symb_id21 = mod_file->symbol_table.getID(*name21);
int symb_id22 = mod_file->symbol_table.getID(*name22);
covariance_pair_restriction[make_pair(symb_id11, symb_id12)] = make_pair(symb_id21, symb_id22);
delete name11;
delete name12;
delete name21;
delete name22;
}
void
ParsingDriver::periods(string *periods)
{

29
ParsingDriver.hh
View File

@ -238,6 +238,8 @@ private:
ostringstream model_errors;
//! Used by VAR restrictions
void clear_VAR_storage();
public:
ParsingDriver(WarningConsolidation &warnings_arg, bool nostrict_arg) : warnings(warnings_arg), nostrict(nostrict_arg), model_error_encountered(false) { };
@ -260,6 +262,21 @@ public:
//! Temporary storage for the prior shape
PriorDistributions prior_shape;
//! VAR restrictions
//! > exclusion restrictions
map<int, SymbolList> exclusion_restriction;
map<int, map<int, SymbolList> > exclusion_restrictions;
//! > equation and crossequation restrictions
pair<int, pair<int, int> > var_restriction_coeff;
typedef pair<pair<int, pair<int, int> >, expr_t> var_restriction_eq_crosseq_t;
vector<var_restriction_eq_crosseq_t> var_restriction_eq_or_crosseq;
pair<pair<var_restriction_eq_crosseq_t, var_restriction_eq_crosseq_t>, double> var_restriction_equation_or_crossequation;
map<int, pair<pair<var_restriction_eq_crosseq_t, var_restriction_eq_crosseq_t>, double> > equation_restrictions;
map<pair<int, int>, pair<pair<var_restriction_eq_crosseq_t, var_restriction_eq_crosseq_t>, double> > crossequation_restrictions;
//! > covariance restrictions
map<pair<int, int>, double> covariance_number_restriction;
map<pair<int, int>, pair<int, int> > covariance_pair_restriction;
//! Error handler with explicit location
void error(const Dynare::parser::location_type &l, const string &m) __attribute__ ((noreturn));
//! Error handler using saved location
@ -763,6 +780,18 @@ public:
void perfect_foresight_setup();
void perfect_foresight_solver();
void prior_posterior_function(bool prior_func);
//! VAR Restrictions
void begin_VAR_restrictions();
void end_VAR_restrictions(string *var_model_name);
void add_VAR_exclusion_restriction(string *lagstr);
void add_VAR_restriction_exclusion_equation(string *name);
void add_VAR_restriction_coeff(string *name1, string *name2, string *lagstr);
void add_VAR_restriction_eq_or_crosseq(expr_t expr);
void add_VAR_restriction_equation_or_crossequation(string *numberstr);
void multiply_arg2_by_neg_one();
void add_VAR_restriction_equation_or_crossequation_final(string *name1, string *name2);
void add_VAR_covariance_number_restriction(string *name1, string *name2, string *valuestr);
void add_VAR_covariance_pair_restriction(string *name11, string *name12, string *name21, string *name22);
};
#endif // ! PARSING_DRIVER_HH

14
SymbolList.cc
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2003-2014 Dynare Team
* Copyright (C) 2003-2017 Dynare Team
*
* This file is part of Dynare.
*
@ -28,7 +28,15 @@ SymbolList::addSymbol(const string &symbol)
void
SymbolList::writeOutput(const string &varname, ostream &output) const
{
output << varname << " = char(";
output << varname << " = ";
write(output);
output << ";" << endl;
}
void
SymbolList::write(ostream &output) const
{
output << " char(";
for (vector<string>::const_iterator it = symbols.begin();
it != symbols.end(); ++it)
{
@ -36,7 +44,7 @@ SymbolList::writeOutput(const string &varname, ostream &output) const
output << ",";
output << "'" << *it << "'";
}
output << ");" << endl;
output << ")";
}
void

4
SymbolList.hh
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2003-2011 Dynare Team
* Copyright (C) 2003-2017 Dynare Team
*
* This file is part of Dynare.
*
@ -39,6 +39,8 @@ public:
//! Output content in Matlab format
/*! Creates a string array for Matlab, stored in variable "varname" */
void writeOutput(const string &varname, ostream &output) const;
//! Output content in Matlab format without preceding varname of writeOutput
void write(ostream &output) const;
//! Clears all content
void clear();
//! Get a copy of the string vector