From 7ac33099f8f23b671e4a77a00216c66121ae9614 Mon Sep 17 00:00:00 2001 From: Houtan Bastani Date: Tue, 17 Apr 2018 15:17:28 +0200 Subject: [PATCH] support undiff in pac model --- src/DynamicModel.cc | 105 +++++++++++++++++++++++++++++--------------- src/DynamicModel.hh | 9 ++-- src/ExprNode.cc | 105 ++++++++++++++++++++++++++++++++++++-------- src/ExprNode.hh | 29 ++++++++---- src/ModFile.cc | 30 ++++++++----- 5 files changed, 198 insertions(+), 80 deletions(-) diff --git a/src/DynamicModel.cc b/src/DynamicModel.cc index ef1319ba..e5817e57 100644 --- a/src/DynamicModel.cc +++ b/src/DynamicModel.cc @@ -3258,6 +3258,7 @@ void DynamicModel::getVarModelVariablesFromEqTags(vector &var_model_eqtags, vector &eqnumber, vector &lhs, + vector &lhs_expr_t, vector > > &rhs, vector &nonstationary) const { @@ -3316,6 +3317,10 @@ DynamicModel::getVarModelVariablesFromEqTags(vector &var_model_eqtags, eqnumber.push_back(eqn); lhs.push_back(it->first); + lhs_set.clear(); + set lhs_expr_t_set; + equations[eqn]->get_arg1()->collectVARLHSVariable(lhs_expr_t_set); + lhs_expr_t.push_back(*(lhs_expr_t_set.begin())); equations[eqn]->get_arg2()->collectDynamicVariables(eEndogenous, rhs_set); for (it = rhs_set.begin(); it != rhs_set.end(); it++) @@ -3332,7 +3337,7 @@ DynamicModel::getVarModelVariablesFromEqTags(vector &var_model_eqtags, int DynamicModel::getVarMaxLag(StaticModel &static_model, vector &eqnumber) const { - set lhs; + vector lhs; for (vector::const_iterator it = eqnumber.begin(); it != eqnumber.end(); it++) { @@ -3344,11 +3349,11 @@ DynamicModel::getVarMaxLag(StaticModel &static_model, vector &eqnumber) con << ". A VAR may only have one endogenous variable on the LHS. " << endl; exit(EXIT_FAILURE); } - lhs.insert(*(lhs_set.begin())); + lhs.push_back(*(lhs_set.begin())); } set lhs_static; - for(set::const_iterator it = lhs.begin(); + for(vector::const_iterator it = lhs.begin(); it != lhs.end(); it++) lhs_static.insert((*it)->toStatic(static_model)); @@ -3444,23 +3449,9 @@ DynamicModel::addEquationsForVar(map > &var_model_ cout << "Accounting for var_model lags not in model block: added " << count << " auxiliary variables and equations." << endl; } -int -DynamicModel::get_undiff_max_lag(vector &eqnumber, vector &lhs) -{ - int max_lag = 0; - for (vector::const_iterator it = eqnumber.begin(); - it != eqnumber.end(); it++) - { - int max_lag_tmp = dynamic_cast(equations[*it])->get_arg2()->PacMaxLag(lhs); - if (max_lag_tmp > max_lag) - max_lag = max_lag_tmp; - } - return max_lag; -} - void -DynamicModel::undiff_lhs_for_pac(vector &lhs, vector &diff, vector &orig_diff_var, - vector &eqnumber, map &undiff, map &undiff_table) +DynamicModel::getUndiffLHSForPac(vector &lhs, vector &lhs_expr_t, vector &diff, vector &orig_diff_var, + vector &eqnumber, map &undiff, ExprNode::subst_table_t &diff_subst_table) { if (undiff.empty()) return; @@ -3486,18 +3477,12 @@ DynamicModel::undiff_lhs_for_pac(vector &lhs, vector &diff, vector::const_iterator it1 = eqnumber.begin(); - it1 != eqnumber.end(); it1++) - if (eqn == i) - { - found = true; - break; - } - else - i++; + it1 != eqnumber.end(); it1++, i++) + if (*it1 == eqn) + break; - if (!found) + if (eqnumber[i] != eqn) { cerr << "ERROR: equation not found in VAR"; exit(EXIT_FAILURE); @@ -3511,18 +3496,67 @@ DynamicModel::undiff_lhs_for_pac(vector &lhs, vector &diff, vectorsecond == aux_var) + { + node = const_cast(it1->first); + break; + } + + if (node == NULL) + { + cerr << "Unexpected error encountered." << endl; + exit(EXIT_FAILURE); + } + for (int j = it->second; j > 0; j--) - if (undiff_table.find(lhs.at(eqnumber.at(i))) == undiff_table.end()) + if (printerr) { cerr << "You are undiffing the LHS of equation #" << eqn << " " - << it->second << " times but it has only been diffed " << j - 1 << " time(s)" << endl; + << it->second << " times but it has only been diffed " << j << " time(s)" << endl; exit(EXIT_FAILURE); } else - lhs.at(eqnumber.at(i)) = undiff_table.at(lhs.at(eqnumber.at(i))); + { + node = node->undiff(); + it1 = diff_subst_table.find(node); + if (it1 == diff_subst_table.end()) + printerr = true; + } + + if (printerr) + { // we have undiffed something like diff(x), hence x is not in diff_subst_table + lhs_expr_t.at(i) = node; + lhs.at(i) = dynamic_cast(node)->get_symb_id(); + } + else + { + lhs_expr_t.at(i) = const_cast(it1->first); + lhs.at(i) = const_cast(it1->second)->get_symb_id(); + } } } +int +DynamicModel::getUndiffMaxLag(StaticModel &static_model, vector &lhs, vector &eqnumber) const +{ + set lhs_static; + for(vector::const_iterator it = lhs.begin(); + it != lhs.end(); it++) + lhs_static.insert((*it)->toStatic(static_model)); + + int max_lag = 0; + for (vector::const_iterator it = eqnumber.begin(); + it != eqnumber.end(); it++) + equations[*it]->get_arg2()->VarMaxLag(static_model, lhs_static, max_lag); + + return max_lag; +} + void DynamicModel::walkPacParameters() { @@ -5136,7 +5170,7 @@ DynamicModel::substituteAdl() } void -DynamicModel::substituteDiff(StaticModel &static_model, map &undiff_table) +DynamicModel::substituteDiff(StaticModel &static_model, ExprNode::subst_table_t &diff_subst_table) { // Find diff Nodes diff_table_t diff_table; @@ -5149,16 +5183,15 @@ DynamicModel::substituteDiff(StaticModel &static_model, map &undiff_ta // Substitute in model local variables vector neweqs; - ExprNode::subst_table_t diff_subst_table; for (map::iterator it = local_variables_table.begin(); it != local_variables_table.end(); it++) - it->second = it->second->substituteDiff(static_model, diff_table, diff_subst_table, neweqs, undiff_table); + it->second = it->second->substituteDiff(static_model, diff_table, diff_subst_table, neweqs); // Substitute in equations for (int i = 0; i < (int) equations.size(); i++) { BinaryOpNode *substeq = dynamic_cast(equations[i]-> - substituteDiff(static_model, diff_table, diff_subst_table, neweqs, undiff_table)); + substituteDiff(static_model, diff_table, diff_subst_table, neweqs)); assert(substeq != NULL); equations[i] = substeq; } diff --git a/src/DynamicModel.hh b/src/DynamicModel.hh index 13543f01..bd56dc8e 100644 --- a/src/DynamicModel.hh +++ b/src/DynamicModel.hh @@ -290,6 +290,7 @@ public: void getVarModelVariablesFromEqTags(vector &var_model_eqtags, vector &eqnumber, vector &lhs, + vector &lhs_expr_t, vector > > &rhs, vector &nonstationary) const; @@ -313,7 +314,7 @@ public: vector &nonstationary, int growth_symb_id); //! Get the max lag for the PAC VAR - int get_undiff_max_lag(vector &eqnumber, vector &lhs); + int getUndiffMaxLag(StaticModel &static_model, vector &lhs, vector &eqnumber) const; //! Substitutes pac_expectation operator void substitutePacExpectation(); @@ -406,11 +407,11 @@ public: void substituteAdl(); //! Substitutes diff operator - void substituteDiff(StaticModel &static_model, map &undiff_table); + void substituteDiff(StaticModel &static_model, ExprNode::subst_table_t &diff_subst_table); //! Table to undiff LHS variables for pac vector z - void undiff_lhs_for_pac(vector &lhs, vector &diff, vector &orig_diff_var, - vector &eqnumber, map &undiff, map &undiff_table); + void getUndiffLHSForPac(vector &lhs, vector &lhs_expr_t, vector &diff, vector &orig_diff_var, + vector &eqnumber, map &undiff, ExprNode::subst_table_t &diff_subst_table); //! Adds contents of diff_aux_equations to the back of aux_equations void combineDiffAuxEquations(); diff --git a/src/ExprNode.cc b/src/ExprNode.cc index 0b0d2b4e..a5458bef 100644 --- a/src/ExprNode.cc +++ b/src/ExprNode.cc @@ -462,6 +462,12 @@ NumConstNode::maxLag() const return 0; } +expr_t +NumConstNode::undiff() const +{ + return const_cast(this); +} + void NumConstNode::VarMaxLag(DataTree &static_datatree, set &static_lhs, int &max_lag) const { @@ -527,7 +533,7 @@ NumConstNode::findDiffNodes(DataTree &static_datatree, diff_table_t &diff_table) } expr_t -NumConstNode::substituteDiff(DataTree &static_datatree, diff_table_t &diff_table, subst_table_t &subst_table, vector &neweqs, map &undiff_table) const +NumConstNode::substituteDiff(DataTree &static_datatree, diff_table_t &diff_table, subst_table_t &subst_table, vector &neweqs) const { return const_cast(this); } @@ -1352,6 +1358,12 @@ VariableNode::maxLag() const } } +expr_t +VariableNode::undiff() const +{ + return const_cast(this); +} + void VariableNode::VarMaxLag(DataTree &static_datatree, set &static_lhs, int &max_lag) const { @@ -1383,7 +1395,8 @@ VariableNode::findDiffNodes(DataTree &static_datatree, diff_table_t &diff_table) } expr_t -VariableNode::substituteDiff(DataTree &static_datatree, diff_table_t &diff_table, subst_table_t &subst_table, vector &neweqs, map &undiff_table) const +VariableNode::substituteDiff(DataTree &static_datatree, diff_table_t &diff_table, subst_table_t &subst_table, + vector &neweqs) const { return const_cast(this); } @@ -2896,6 +2909,14 @@ UnaryOpNode::maxLag() const return arg->maxLag(); } +expr_t +UnaryOpNode::undiff() const +{ + if (op_code == oDiff) + return arg; + return arg->undiff(); +} + void UnaryOpNode::VarMaxLag(DataTree &static_datatree, set &static_lhs, int &max_lag) const { @@ -2992,11 +3013,11 @@ UnaryOpNode::findDiffNodes(DataTree &static_datatree, diff_table_t &diff_table) expr_t UnaryOpNode::substituteDiff(DataTree &static_datatree, diff_table_t &diff_table, subst_table_t &subst_table, - vector &neweqs, map &undiff_table) const + vector &neweqs) const { if (op_code != oDiff) { - expr_t argsubst = arg->substituteDiff(static_datatree, diff_table, subst_table, neweqs, undiff_table); + expr_t argsubst = arg->substituteDiff(static_datatree, diff_table, subst_table, neweqs); return buildSimilarUnaryOpNode(argsubst, datatree); } @@ -3006,7 +3027,11 @@ UnaryOpNode::substituteDiff(DataTree &static_datatree, diff_table_t &diff_table, expr_t sthis = dynamic_cast(this->toStatic(static_datatree)); diff_table_t::iterator it = diff_table.find(sthis); - assert(it != diff_table.end() && it->second[-arg->maxLag()] == this); + if (it == diff_table.end() || it->second[-arg->maxLag()] != this) + { + cerr << "Internal error encountered. Please report" << endl; + exit(EXIT_FAILURE); + } int last_arg_max_lag = 0; VariableNode *last_aux_var = NULL; @@ -3014,7 +3039,7 @@ UnaryOpNode::substituteDiff(DataTree &static_datatree, diff_table_t &diff_table, rit != it->second.rend(); rit++) { expr_t argsubst = dynamic_cast(rit->second)-> - get_arg()->substituteDiff(static_datatree, diff_table, subst_table, neweqs, undiff_table); + get_arg()->substituteDiff(static_datatree, diff_table, subst_table, neweqs); int symb_id; VariableNode *vn = dynamic_cast(argsubst); if (rit == it->second.rbegin()) @@ -3032,11 +3057,10 @@ UnaryOpNode::substituteDiff(DataTree &static_datatree, diff_table_t &diff_table, datatree.AddMinus(argsubst, argsubst->decreaseLeadsLags(1))))); subst_table[rit->second] = dynamic_cast(last_aux_var); - undiff_table[symb_id] = vn->get_symb_id(); } else { - // just add equation of form: AUX_DIFF = ORIG_AUX_DIFF(last_arg_max_lag - rit->first) + // just add equation of form: AUX_DIFF = LAST_AUX_VAR(-1) VariableNode *new_aux_var = NULL; for (int i = last_arg_max_lag; i > rit->first; i--) { @@ -4577,6 +4601,14 @@ BinaryOpNode::maxLag() const return max(arg1->maxLag(), arg2->maxLag()); } +expr_t +BinaryOpNode::undiff() const +{ + expr_t arg1subst = arg1->undiff(); + expr_t arg2subst = arg2->undiff(); + return buildSimilarBinaryOpNode(arg1subst, arg2subst, datatree); +} + int BinaryOpNode::PacMaxLag(vector &lhs) const { @@ -4727,10 +4759,11 @@ BinaryOpNode::findDiffNodes(DataTree &static_datatree, diff_table_t &diff_table) } expr_t -BinaryOpNode::substituteDiff(DataTree &static_datatree, diff_table_t &diff_table, subst_table_t &subst_table, vector &neweqs, map &undiff_table) const +BinaryOpNode::substituteDiff(DataTree &static_datatree, diff_table_t &diff_table, subst_table_t &subst_table, + vector &neweqs) const { - expr_t arg1subst = arg1->substituteDiff(static_datatree, diff_table, subst_table, neweqs, undiff_table); - expr_t arg2subst = arg2->substituteDiff(static_datatree, diff_table, subst_table, neweqs, undiff_table); + expr_t arg1subst = arg1->substituteDiff(static_datatree, diff_table, subst_table, neweqs); + expr_t arg2subst = arg2->substituteDiff(static_datatree, diff_table, subst_table, neweqs); return buildSimilarBinaryOpNode(arg1subst, arg2subst, datatree); } @@ -5511,6 +5544,15 @@ TrinaryOpNode::maxLag() const return max(arg1->maxLag(), max(arg2->maxLag(), arg3->maxLag())); } +expr_t +TrinaryOpNode::undiff() const +{ + expr_t arg1subst = arg1->undiff(); + expr_t arg2subst = arg2->undiff(); + expr_t arg3subst = arg3->undiff(); + return buildSimilarTrinaryOpNode(arg1subst, arg2subst, arg3subst, datatree); +} + void TrinaryOpNode::VarMaxLag(DataTree &static_datatree, set &static_lhs, int &max_lag) const { @@ -5620,11 +5662,12 @@ TrinaryOpNode::findDiffNodes(DataTree &static_datatree, diff_table_t &diff_table } expr_t -TrinaryOpNode::substituteDiff(DataTree &static_datatree, diff_table_t &diff_table, subst_table_t &subst_table, vector &neweqs, map &undiff_table) const +TrinaryOpNode::substituteDiff(DataTree &static_datatree, diff_table_t &diff_table, subst_table_t &subst_table, + vector &neweqs) const { - expr_t arg1subst = arg1->substituteDiff(static_datatree, diff_table, subst_table, neweqs, undiff_table); - expr_t arg2subst = arg2->substituteDiff(static_datatree, diff_table, subst_table, neweqs, undiff_table); - expr_t arg3subst = arg3->substituteDiff(static_datatree, diff_table, subst_table, neweqs, undiff_table); + expr_t arg1subst = arg1->substituteDiff(static_datatree, diff_table, subst_table, neweqs); + expr_t arg2subst = arg2->substituteDiff(static_datatree, diff_table, subst_table, neweqs); + expr_t arg3subst = arg3->substituteDiff(static_datatree, diff_table, subst_table, neweqs); return buildSimilarTrinaryOpNode(arg1subst, arg2subst, arg3subst, datatree); } @@ -5925,6 +5968,15 @@ AbstractExternalFunctionNode::maxLag() const return val; } +expr_t +AbstractExternalFunctionNode::undiff() const +{ + vector arguments_subst; + for (vector::const_iterator it = arguments.begin(); it != arguments.end(); it++) + arguments_subst.push_back((*it)->undiff()); + return buildSimilarExternalFunctionNode(arguments_subst, datatree); +} + void AbstractExternalFunctionNode::VarMaxLag(DataTree &static_datatree, set &static_lhs, int &max_lag) const { @@ -6023,11 +6075,12 @@ AbstractExternalFunctionNode::findDiffNodes(DataTree &static_datatree, diff_tabl } expr_t -AbstractExternalFunctionNode::substituteDiff(DataTree &static_datatree, diff_table_t &diff_table, subst_table_t &subst_table, vector &neweqs, map &undiff_table) const +AbstractExternalFunctionNode::substituteDiff(DataTree &static_datatree, diff_table_t &diff_table, subst_table_t &subst_table, + vector &neweqs) const { vector arguments_subst; for (vector::const_iterator it = arguments.begin(); it != arguments.end(); it++) - arguments_subst.push_back((*it)->substituteDiff(static_datatree, diff_table, subst_table, neweqs, undiff_table)); + arguments_subst.push_back((*it)->substituteDiff(static_datatree, diff_table, subst_table, neweqs)); return buildSimilarExternalFunctionNode(arguments_subst, datatree); } @@ -7434,6 +7487,12 @@ VarExpectationNode::maxLag() const return 0; } +expr_t +VarExpectationNode::undiff() const +{ + return const_cast(this); +} + void VarExpectationNode::VarMaxLag(DataTree &static_datatree, set &static_lhs, int &max_lag) const { @@ -7573,7 +7632,8 @@ VarExpectationNode::findDiffNodes(DataTree &static_datatree, diff_table_t &diff_ } expr_t -VarExpectationNode::substituteDiff(DataTree &static_datatree, diff_table_t &diff_table, subst_table_t &subst_table, vector &neweqs, map &undiff_table) const +VarExpectationNode::substituteDiff(DataTree &static_datatree, diff_table_t &diff_table, subst_table_t &subst_table, + vector &neweqs) const { return const_cast(this); } @@ -7843,6 +7903,12 @@ PacExpectationNode::maxLag() const return 0; } +expr_t +PacExpectationNode::undiff() const +{ + return const_cast(this); +} + void PacExpectationNode::VarMaxLag(DataTree &static_datatree, set &static_lhs, int &max_lag) const { @@ -7981,7 +8047,8 @@ PacExpectationNode::findDiffNodes(DataTree &static_datatree, diff_table_t &diff_ } expr_t -PacExpectationNode::substituteDiff(DataTree &static_datatree, diff_table_t &diff_table, subst_table_t &subst_table, vector &neweqs, map &undiff_table) const +PacExpectationNode::substituteDiff(DataTree &static_datatree, diff_table_t &diff_table, subst_table_t &subst_table, + vector &neweqs) const { return const_cast(this); } diff --git a/src/ExprNode.hh b/src/ExprNode.hh index e8057af1..972507a8 100644 --- a/src/ExprNode.hh +++ b/src/ExprNode.hh @@ -59,6 +59,7 @@ typedef map eval_context_t; typedef map >, int> deriv_node_temp_terms_t; //! Type for the substitution map used in the process of substitutitng diff expressions +//! diff_table[static_expr_t][lag] -> dynamic_expr_t typedef map > diff_table_t; //! Possible types of output when writing ExprNode(s) @@ -359,6 +360,8 @@ class ExprNode //! Takes account of undiffed LHS variables in calculating the max lag virtual int PacMaxLag(vector &lhs) const = 0; + virtual expr_t undiff() const = 0; + //! Returns a new expression where all the leads/lags have been shifted backwards by the same amount /*! Only acts on endogenous, exogenous, exogenous det @@ -486,7 +489,7 @@ class ExprNode //! Substitute diff operator virtual void findDiffNodes(DataTree &static_datatree, diff_table_t &diff_table) const = 0; - virtual expr_t substituteDiff(DataTree &static_datatree, diff_table_t &diff_table, subst_table_t &subst_table, vector &neweqs, map &undiff_table) const = 0; + virtual expr_t substituteDiff(DataTree &static_datatree, diff_table_t &diff_table, subst_table_t &subst_table, vector &neweqs) const = 0; //! Substitute pac_expectation operator virtual expr_t substitutePacExpectation(map &subst_table) = 0; @@ -568,6 +571,7 @@ public: virtual int maxLag() const; virtual void VarMaxLag(DataTree &static_datatree, set &static_lhs, int &max_lag) const; virtual int PacMaxLag(vector &lhs) const; + virtual expr_t undiff() const; virtual expr_t decreaseLeadsLags(int n) const; virtual expr_t substituteEndoLeadGreaterThanTwo(subst_table_t &subst_table, vector &neweqs, bool deterministic_model) const; virtual expr_t substituteEndoLagGreaterThanTwo(subst_table_t &subst_table, vector &neweqs) const; @@ -576,7 +580,7 @@ public: virtual expr_t substituteExpectation(subst_table_t &subst_table, vector &neweqs, bool partial_information_model) const; virtual expr_t substituteAdl() const; virtual void findDiffNodes(DataTree &static_datatree, diff_table_t &diff_table) const; - virtual expr_t substituteDiff(DataTree &static_datatree, diff_table_t &diff_table, subst_table_t &subst_table, vector &neweqs, map &undiff_table) const; + virtual expr_t substituteDiff(DataTree &static_datatree, diff_table_t &diff_table, subst_table_t &subst_table, vector &neweqs) const; virtual expr_t substitutePacExpectation(map &subst_table); virtual expr_t decreaseLeadsLagsPredeterminedVariables() const; virtual expr_t differentiateForwardVars(const vector &subset, subst_table_t &subst_table, vector &neweqs) const; @@ -654,6 +658,7 @@ public: virtual int maxLag() const; virtual void VarMaxLag(DataTree &static_datatree, set &static_lhs, int &max_lag) const; virtual int PacMaxLag(vector &lhs) const; + virtual expr_t undiff() const; virtual expr_t decreaseLeadsLags(int n) const; virtual expr_t substituteEndoLeadGreaterThanTwo(subst_table_t &subst_table, vector &neweqs, bool deterministic_model) const; virtual expr_t substituteEndoLagGreaterThanTwo(subst_table_t &subst_table, vector &neweqs) const; @@ -662,7 +667,7 @@ public: virtual expr_t substituteExpectation(subst_table_t &subst_table, vector &neweqs, bool partial_information_model) const; virtual expr_t substituteAdl() const; virtual void findDiffNodes(DataTree &static_datatree, diff_table_t &diff_table) const; - virtual expr_t substituteDiff(DataTree &static_datatree, diff_table_t &diff_table, subst_table_t &subst_table, vector &neweqs, map &undiff_table) const; + virtual expr_t substituteDiff(DataTree &static_datatree, diff_table_t &diff_table, subst_table_t &subst_table, vector &neweqs) const; virtual expr_t substitutePacExpectation(map &subst_table); virtual expr_t decreaseLeadsLagsPredeterminedVariables() const; virtual expr_t differentiateForwardVars(const vector &subset, subst_table_t &subst_table, vector &neweqs) const; @@ -760,6 +765,7 @@ public: virtual int maxLag() const; virtual void VarMaxLag(DataTree &static_datatree, set &static_lhs, int &max_lag) const; virtual int PacMaxLag(vector &lhs) const; + virtual expr_t undiff() const; virtual expr_t decreaseLeadsLags(int n) const; virtual expr_t substituteEndoLeadGreaterThanTwo(subst_table_t &subst_table, vector &neweqs, bool deterministic_model) const; //! Creates another UnaryOpNode with the same opcode, but with a possibly different datatree and argument @@ -770,7 +776,7 @@ public: virtual expr_t substituteExpectation(subst_table_t &subst_table, vector &neweqs, bool partial_information_model) const; virtual expr_t substituteAdl() const; virtual void findDiffNodes(DataTree &static_datatree, diff_table_t &diff_table) const; - virtual expr_t substituteDiff(DataTree &static_datatree, diff_table_t &diff_table, subst_table_t &subst_table, vector &neweqs, map &undiff_table) const; + virtual expr_t substituteDiff(DataTree &static_datatree, diff_table_t &diff_table, subst_table_t &subst_table, vector &neweqs) const; virtual expr_t substitutePacExpectation(map &subst_table); virtual expr_t decreaseLeadsLagsPredeterminedVariables() const; virtual expr_t differentiateForwardVars(const vector &subset, subst_table_t &subst_table, vector &neweqs) const; @@ -884,6 +890,7 @@ public: virtual int maxLag() const; virtual void VarMaxLag(DataTree &static_datatree, set &static_lhs, int &max_lag) const; virtual int PacMaxLag(vector &lhs) const; + virtual expr_t undiff() const; virtual expr_t decreaseLeadsLags(int n) const; virtual expr_t substituteEndoLeadGreaterThanTwo(subst_table_t &subst_table, vector &neweqs, bool deterministic_model) const; //! Creates another BinaryOpNode with the same opcode, but with a possibly different datatree and arguments @@ -894,7 +901,7 @@ public: virtual expr_t substituteExpectation(subst_table_t &subst_table, vector &neweqs, bool partial_information_model) const; virtual expr_t substituteAdl() const; virtual void findDiffNodes(DataTree &static_datatree, diff_table_t &diff_table) const; - virtual expr_t substituteDiff(DataTree &static_datatree, diff_table_t &diff_table, subst_table_t &subst_table, vector &neweqs, map &undiff_table) const; + virtual expr_t substituteDiff(DataTree &static_datatree, diff_table_t &diff_table, subst_table_t &subst_table, vector &neweqs) const; virtual expr_t substitutePacExpectation(map &subst_table); virtual expr_t decreaseLeadsLagsPredeterminedVariables() const; virtual expr_t differentiateForwardVars(const vector &subset, subst_table_t &subst_table, vector &neweqs) const; @@ -985,6 +992,7 @@ public: virtual int maxLag() const; virtual void VarMaxLag(DataTree &static_datatree, set &static_lhs, int &max_lag) const; virtual int PacMaxLag(vector &lhs) const; + virtual expr_t undiff() const; virtual expr_t decreaseLeadsLags(int n) const; virtual expr_t substituteEndoLeadGreaterThanTwo(subst_table_t &subst_table, vector &neweqs, bool deterministic_model) const; //! Creates another TrinaryOpNode with the same opcode, but with a possibly different datatree and arguments @@ -995,7 +1003,7 @@ public: virtual expr_t substituteExpectation(subst_table_t &subst_table, vector &neweqs, bool partial_information_model) const; virtual expr_t substituteAdl() const; virtual void findDiffNodes(DataTree &static_datatree, diff_table_t &diff_table) const; - virtual expr_t substituteDiff(DataTree &static_datatree, diff_table_t &diff_table, subst_table_t &subst_table, vector &neweqs, map &undiff_table) const; + virtual expr_t substituteDiff(DataTree &static_datatree, diff_table_t &diff_table, subst_table_t &subst_table, vector &neweqs) const; virtual expr_t substitutePacExpectation(map &subst_table); virtual expr_t decreaseLeadsLagsPredeterminedVariables() const; virtual expr_t differentiateForwardVars(const vector &subset, subst_table_t &subst_table, vector &neweqs) const; @@ -1088,6 +1096,7 @@ public: virtual int maxLag() const; virtual void VarMaxLag(DataTree &static_datatree, set &static_lhs, int &max_lag) const; virtual int PacMaxLag(vector &lhs) const; + virtual expr_t undiff() const; virtual expr_t decreaseLeadsLags(int n) const; virtual expr_t substituteEndoLeadGreaterThanTwo(subst_table_t &subst_table, vector &neweqs, bool deterministic_model) const; virtual expr_t substituteEndoLagGreaterThanTwo(subst_table_t &subst_table, vector &neweqs) const; @@ -1096,7 +1105,7 @@ public: virtual expr_t substituteExpectation(subst_table_t &subst_table, vector &neweqs, bool partial_information_model) const; virtual expr_t substituteAdl() const; virtual void findDiffNodes(DataTree &static_datatree, diff_table_t &diff_table) const; - virtual expr_t substituteDiff(DataTree &static_datatree, diff_table_t &diff_table, subst_table_t &subst_table, vector &neweqs, map &undiff_table) const; + virtual expr_t substituteDiff(DataTree &static_datatree, diff_table_t &diff_table, subst_table_t &subst_table, vector &neweqs) const; virtual expr_t substitutePacExpectation(map &subst_table); virtual expr_t buildSimilarExternalFunctionNode(vector &alt_args, DataTree &alt_datatree) const = 0; virtual expr_t decreaseLeadsLagsPredeterminedVariables() const; @@ -1273,6 +1282,7 @@ public: virtual int maxLag() const; virtual void VarMaxLag(DataTree &static_datatree, set &static_lhs, int &max_lag) const; virtual int PacMaxLag(vector &lhs) const; + virtual expr_t undiff() const; virtual expr_t decreaseLeadsLags(int n) const; virtual void prepareForDerivation(); virtual expr_t computeDerivative(int deriv_id); @@ -1287,7 +1297,7 @@ public: virtual expr_t substituteExpectation(subst_table_t &subst_table, vector &neweqs, bool partial_information_model) const; virtual expr_t substituteAdl() const; virtual void findDiffNodes(DataTree &static_datatree, diff_table_t &diff_table) const; - virtual expr_t substituteDiff(DataTree &static_datatree, diff_table_t &diff_table, subst_table_t &subst_table, vector &neweqs, map &undiff_table) const; + virtual expr_t substituteDiff(DataTree &static_datatree, diff_table_t &diff_table, subst_table_t &subst_table, vector &neweqs) const; virtual expr_t substitutePacExpectation(map &subst_table); virtual pair normalizeEquation(int symb_id_endo, vector > > &List_of_Op_RHS) const; virtual void compile(ostream &CompileCode, unsigned int &instruction_number, @@ -1353,6 +1363,7 @@ public: virtual int maxLag() const; virtual void VarMaxLag(DataTree &static_datatree, set &static_lhs, int &max_lag) const; virtual int PacMaxLag(vector &lhs) const; + virtual expr_t undiff() const; virtual expr_t decreaseLeadsLags(int n) const; virtual void prepareForDerivation(); virtual expr_t computeDerivative(int deriv_id); @@ -1367,7 +1378,7 @@ public: virtual expr_t substituteExpectation(subst_table_t &subst_table, vector &neweqs, bool partial_information_model) const; virtual expr_t substituteAdl() const; virtual void findDiffNodes(DataTree &static_datatree, diff_table_t &diff_table) const; - virtual expr_t substituteDiff(DataTree &static_datatree, diff_table_t &diff_table, subst_table_t &subst_table, vector &neweqs, map &undiff_table) const; + virtual expr_t substituteDiff(DataTree &static_datatree, diff_table_t &diff_table, subst_table_t &subst_table, vector &neweqs) const; virtual expr_t substitutePacExpectation(map &subst_table); virtual pair normalizeEquation(int symb_id_endo, vector > > &List_of_Op_RHS) const; virtual void compile(ostream &CompileCode, unsigned int &instruction_number, diff --git a/src/ModFile.cc b/src/ModFile.cc index b025d60a..6a037ac1 100644 --- a/src/ModFile.cc +++ b/src/ModFile.cc @@ -367,13 +367,15 @@ ModFile::transformPass(bool nostrict, bool stochastic, bool compute_xrefs, const } // Create auxiliary variable and equations for Diff operator - map undiff_table; - dynamic_model.substituteDiff(diff_static_model, undiff_table); + ExprNode::subst_table_t diff_subst_table; + dynamic_model.substituteDiff(diff_static_model, diff_subst_table); // Var Model map > var_model_info_var_expectation; map > var_model_eq_tags; - map, pair, vector > >, pair >, vector > > > + map, vector >, + pair, vector > >, + pair >, vector > > > var_model_info_pac_expectation; for (vector::const_iterator it = statements.begin(); it != statements.end(); it++) @@ -382,42 +384,46 @@ ModFile::transformPass(bool nostrict, bool stochastic, bool compute_xrefs, const if (vms != NULL) { string var_model_name; - vms->getVarModelInfoForVarExpectation(var_model_name, var_model_info_var_expectation, var_model_eq_tags); - vector eqnumber, lhs, orig_diff_var; + vms->getVarModelInfo(var_model_name, var_model_info_var_expectation, var_model_eq_tags); + vector lhs_expr_t; + vector lhs, eqnumber, orig_diff_var; vector > > rhs; vector nonstationary, diff; vector eqtags = var_model_eq_tags[var_model_name]; dynamic_model.getVarModelVariablesFromEqTags(eqtags, - eqnumber, lhs, rhs, nonstationary); + eqnumber, lhs, lhs_expr_t, rhs, nonstationary); int max_lag = original_model.getVarMaxLag(diff_static_model, eqnumber); original_model.getVarLhsDiffAndInfo(eqnumber, diff, orig_diff_var); vms->fillVarModelInfoFromEquations(eqnumber, lhs, rhs, nonstationary, diff, orig_diff_var, max_lag); var_model_info_pac_expectation[var_model_name] = - make_pair(make_pair(lhs, make_pair(diff, orig_diff_var)), make_pair(make_pair(max_lag, nonstationary), eqnumber)); + make_pair(make_pair(make_pair(lhs, lhs_expr_t), + make_pair(diff, orig_diff_var)), + make_pair(make_pair(max_lag, nonstationary), eqnumber)); } - PacModelStatement *pms = dynamic_cast(*it); if (pms != NULL) { - pair > > > > pac_model_info_pac_expectation; + pair > > > > + pac_model_info_pac_expectation; pms->getPacModelInfoForPacExpectation(pac_model_info_pac_expectation); string pac_model_name = pac_model_info_pac_expectation.first; string var_model_name = pac_model_info_pac_expectation.second.first; vector eqtags = var_model_eq_tags[var_model_name]; if (!eqtags.empty()) { - vector lhs = var_model_info_pac_expectation[var_model_name].first.first; + vector lhs = var_model_info_pac_expectation[var_model_name].first.first.first; map undiff = pac_model_info_pac_expectation.second.second.second.second; int max_lag = var_model_info_pac_expectation[var_model_name].second.first.first; vector nonstationary = var_model_info_pac_expectation[var_model_name].second.first.second; if (!undiff.empty()) { + vector lhs_expr_t = var_model_info_pac_expectation[var_model_name].first.first.second; vector diff = var_model_info_pac_expectation[var_model_name].first.second.first; vector orig_diff_var = var_model_info_pac_expectation[var_model_name].first.second.second; vector eqnumber = var_model_info_pac_expectation[var_model_name].second.second; - dynamic_model.undiff_lhs_for_pac(lhs, diff, orig_diff_var, eqnumber, undiff, undiff_table); - max_lag = dynamic_model.get_undiff_max_lag(eqnumber, lhs); + dynamic_model.getUndiffLHSForPac(lhs, lhs_expr_t, diff, orig_diff_var, eqnumber, undiff, diff_subst_table); + max_lag = original_model.getUndiffMaxLag(diff_static_model, lhs_expr_t, eqnumber); } pms->fillUndiffedLHS(lhs); dynamic_model.walkPacParameters();