diff --git a/src/DynamicModel.cc b/src/DynamicModel.cc
index 053481302cf37feb75526c34cd9bf136d543e5ef..34c7b21f5b946d4d55ee66486cb8a5723526eded 100644
--- a/src/DynamicModel.cc
+++ b/src/DynamicModel.cc
@@ -970,8 +970,8 @@ DynamicModel::writeModelEquationsCode(const string &basename, const map_idx_t &m
simulation_type,
0,
symbol_table.endo_nbr(),
- variable_reordered,
- equation_reordered,
+ endo_idx_block2orig,
+ eq_idx_block2orig,
false,
symbol_table.endo_nbr(),
max_endo_lag,
@@ -1247,8 +1247,8 @@ DynamicModel::writeModelEquationsCode_Block(const string &basename, const map_id
simulation_type,
getBlockFirstEquation(block),
block_size,
- variable_reordered,
- equation_reordered,
+ endo_idx_block2orig,
+ eq_idx_block2orig,
blocks_linear[block],
symbol_table.endo_nbr(),
block_max_lag,
@@ -3121,9 +3121,9 @@ DynamicModel::writeOutput(ostream &output, const string &basename, bool block_de
for (int lag = -max_endo_lag; lag < 0; lag++)
try
{
- getDerivID(symbol_table.getID(SymbolType::endogenous, variable_reordered[endoID]), lag);
- if (lag < 0 && find(state_var.begin(), state_var.end(), variable_reordered[endoID]+1) == state_var.end())
- state_var.push_back(variable_reordered[endoID]+1);
+ getDerivID(symbol_table.getID(SymbolType::endogenous, endo_idx_block2orig[endoID]), lag);
+ if (lag < 0 && find(state_var.begin(), state_var.end(), endo_idx_block2orig[endoID]+1) == state_var.end())
+ state_var.push_back(endo_idx_block2orig[endoID]+1);
}
catch (UnknownDerivIDException &e)
{
@@ -3344,19 +3344,19 @@ DynamicModel::writeOutput(ostream &output, const string &basename, bool block_de
int nb_endo = symbol_table.endo_nbr();
output << modstruct << "block_structure.variable_reordered = [";
for (int i = 0; i < nb_endo; i++)
- output << " " << variable_reordered[i]+1;
+ output << " " << endo_idx_block2orig[i]+1;
output << "];" << endl;
output << modstruct << "block_structure.equation_reordered = [";
for (int i = 0; i < nb_endo; i++)
- output << " " << equation_reordered[i]+1;
+ output << " " << eq_idx_block2orig[i]+1;
output << "];" << endl;
vector<int> variable_inv_reordered(nb_endo);
for (int i = 0; i < nb_endo; i++)
- variable_inv_reordered[variable_reordered[i]] = i;
+ variable_inv_reordered[endo_idx_block2orig[i]] = i;
for (int it : state_var)
- state_equ.push_back(equation_reordered[variable_inv_reordered[it - 1]]+1);
+ state_equ.push_back(eq_idx_block2orig[variable_inv_reordered[it - 1]]+1);
map<tuple<int, int, int>, int> lag_row_incidence;
for (const auto & [indices, d1] : derivatives[1])
@@ -4874,8 +4874,8 @@ DynamicModel::computingPass(bool jacobianExo, int derivsOrder, int paramsDerivsO
{
for (int j = 0; j < getBlockSize(i); j++)
{
- equation_block[equation_reordered[k]] = i;
- int l = variable_reordered[k];
+ equation_block[eq_idx_block2orig[k]] = i;
+ int l = endo_idx_block2orig[k];
variable_block_lead_lag[l] = { i, variable_lag_lead[l].first, variable_lag_lead[l].second };
k++;
}
@@ -5101,7 +5101,7 @@ void
DynamicModel::collect_block_first_order_derivatives()
{
//! vector for an equation or a variable indicates the block number
- vector<int> equation_2_block(equation_reordered.size()), variable_2_block(variable_reordered.size());
+ vector<int> equation_2_block(eq_idx_block2orig.size()), variable_2_block(endo_idx_block2orig.size());
int nb_blocks = getNbBlocks();
for (int block = 0; block < nb_blocks; block++)
{
diff --git a/src/DynamicModel.hh b/src/DynamicModel.hh
index 6e8efb6bbcfa67acd549485ea60be83a78d76215..b16422d569faeed26514e6bd15cec0e9a0faaacf 100644
--- a/src/DynamicModel.hh
+++ b/src/DynamicModel.hh
@@ -611,37 +611,37 @@ public:
EquationType
getBlockEquationType(int block_number, int equation_number) const override
{
- return equation_type_and_normalized_equation[equation_reordered[get<1>(block_type_firstequation_size_mfs[block_number])+equation_number]].first;
+ return equation_type_and_normalized_equation[eq_idx_block2orig[get<1>(block_type_firstequation_size_mfs[block_number])+equation_number]].first;
};
//! Return true if the equation has been normalized
bool
isBlockEquationRenormalized(int block_number, int equation_number) const override
{
- return equation_type_and_normalized_equation[equation_reordered[get<1>(block_type_firstequation_size_mfs[block_number])+equation_number]].first == EquationType::evaluate_s;
+ return equation_type_and_normalized_equation[eq_idx_block2orig[get<1>(block_type_firstequation_size_mfs[block_number])+equation_number]].first == EquationType::evaluate_s;
};
//! Return the expr_t of the equation equation_number belonging to the block block_number
expr_t
getBlockEquationExpr(int block_number, int equation_number) const override
{
- return equations[equation_reordered[get<1>(block_type_firstequation_size_mfs[block_number])+equation_number]];
+ return equations[eq_idx_block2orig[get<1>(block_type_firstequation_size_mfs[block_number])+equation_number]];
};
//! Return the expr_t of the renormalized equation equation_number belonging to the block block_number
expr_t
getBlockEquationRenormalizedExpr(int block_number, int equation_number) const override
{
- return equation_type_and_normalized_equation[equation_reordered[get<1>(block_type_firstequation_size_mfs[block_number])+equation_number]].second;
+ return equation_type_and_normalized_equation[eq_idx_block2orig[get<1>(block_type_firstequation_size_mfs[block_number])+equation_number]].second;
};
//! Return the original number of equation equation_number belonging to the block block_number
int
getBlockEquationID(int block_number, int equation_number) const override
{
- return equation_reordered[get<1>(block_type_firstequation_size_mfs[block_number])+equation_number];
+ return eq_idx_block2orig[get<1>(block_type_firstequation_size_mfs[block_number])+equation_number];
};
//! Return the original number of variable variable_number belonging to the block block_number
int
getBlockVariableID(int block_number, int variable_number) const override
{
- return variable_reordered[get<1>(block_type_firstequation_size_mfs[block_number])+variable_number];
+ return endo_idx_block2orig[get<1>(block_type_firstequation_size_mfs[block_number])+variable_number];
};
//! Return the original number of the exogenous variable varexo_number belonging to the block block_number
int
@@ -653,13 +653,13 @@ public:
int
getBlockInitialEquationID(int block_number, int equation_number) const override
{
- return inv_equation_reordered[equation_number] - get<1>(block_type_firstequation_size_mfs[block_number]);
+ return eq_idx_orig2block[equation_number] - get<1>(block_type_firstequation_size_mfs[block_number]);
};
//! Return the position of variable_number in the block number belonging to the block block_number
int
getBlockInitialVariableID(int block_number, int variable_number) const override
{
- return inv_variable_reordered[variable_number] - get<1>(block_type_firstequation_size_mfs[block_number]);
+ return endo_idx_orig2block[variable_number] - get<1>(block_type_firstequation_size_mfs[block_number]);
};
//! Return the block number containing the endogenous variable variable_number
int
diff --git a/src/ModelTree.cc b/src/ModelTree.cc
index 09c7877be0b25f7988ad3d4908d35a83ce8af863..cb43b4631dea8451b621f45567caf48e1fe05dec 100644
--- a/src/ModelTree.cc
+++ b/src/ModelTree.cc
@@ -157,10 +157,10 @@ ModelTree::ModelTree(const ModelTree &m) :
computed_derivs_order{m.computed_derivs_order},
NNZDerivatives{m.NNZDerivatives},
v_temporary_terms_inuse{m.v_temporary_terms_inuse},
- equation_reordered{m.equation_reordered},
- variable_reordered{m.variable_reordered},
- inv_equation_reordered{m.inv_equation_reordered},
- inv_variable_reordered{m.inv_variable_reordered},
+ eq_idx_block2orig{m.eq_idx_block2orig},
+ endo_idx_block2orig{m.endo_idx_block2orig},
+ eq_idx_orig2block{m.eq_idx_orig2block},
+ endo_idx_orig2block{m.endo_idx_orig2block},
map_idx{m.map_idx},
block_type_firstequation_size_mfs{m.block_type_firstequation_size_mfs},
blocks_linear{m.blocks_linear},
@@ -208,10 +208,10 @@ ModelTree::operator=(const ModelTree &m)
nonstationary_symbols_map.clear();
dynamic_jacobian.clear();
- equation_reordered = m.equation_reordered;
- variable_reordered = m.variable_reordered;
- inv_equation_reordered = m.inv_equation_reordered;
- inv_variable_reordered = m.inv_variable_reordered;
+ eq_idx_block2orig = m.eq_idx_block2orig;
+ endo_idx_block2orig = m.endo_idx_block2orig;
+ eq_idx_orig2block = m.eq_idx_orig2block;
+ endo_idx_orig2block = m.endo_idx_orig2block;
first_chain_rule_derivatives.clear();
map_idx = m.map_idx;
equation_type_and_normalized_equation.clear();
@@ -470,8 +470,8 @@ ModelTree::select_non_linear_equations_and_variables(const vector<bool> &is_equa
for (auto it : endo2eq)
if (!is_equation_linear[it])
{
- equation_reordered[i] = it;
- variable_reordered[i] = j;
+ eq_idx_block2orig[i] = it;
+ endo_idx_block2orig[i] = j;
endo2block[j] = 0;
i++;
j++;
@@ -481,13 +481,13 @@ ModelTree::select_non_linear_equations_and_variables(const vector<bool> &is_equa
n_backward(endo2eq.size(), 0), n_mixed(endo2eq.size(), 0);
for (int i = 0; i < static_cast<int>(endo2eq.size()); i++)
{
- if (variable_lag_lead[variable_reordered[i]].first != 0 && variable_lag_lead[variable_reordered[i]].second != 0)
+ if (variable_lag_lead[endo_idx_block2orig[i]].first != 0 && variable_lag_lead[endo_idx_block2orig[i]].second != 0)
n_mixed[i]++;
- else if (variable_lag_lead[variable_reordered[i]].first == 0 && variable_lag_lead[variable_reordered[i]].second != 0)
+ else if (variable_lag_lead[endo_idx_block2orig[i]].first == 0 && variable_lag_lead[endo_idx_block2orig[i]].second != 0)
n_forward[i]++;
- else if (variable_lag_lead[variable_reordered[i]].first != 0 && variable_lag_lead[variable_reordered[i]].second == 0)
+ else if (variable_lag_lead[endo_idx_block2orig[i]].first != 0 && variable_lag_lead[endo_idx_block2orig[i]].second == 0)
n_backward[i]++;
- else if (variable_lag_lead[variable_reordered[i]].first == 0 && variable_lag_lead[variable_reordered[i]].second == 0)
+ else if (variable_lag_lead[endo_idx_block2orig[i]].first == 0 && variable_lag_lead[endo_idx_block2orig[i]].second == 0)
n_static[i]++;
}
cout.flush();
@@ -531,22 +531,22 @@ ModelTree::computePrologueAndEpilogue(const jacob_map_t &static_jacobian)
const int n = equations.size();
/* Compute reverse map (eq→endo) of normalization. Also initialize
- “equation_reordered” and “variable_reordered” to the identity
+ “eq_idx_block2orig” and “endo_idx_block2orig” to the identity
permutation. */
vector<int> eq2endo(n);
- equation_reordered.resize(n);
- variable_reordered.resize(n);
+ eq_idx_block2orig.resize(n);
+ endo_idx_block2orig.resize(n);
for (int i = 0; i < n; i++)
{
int it = endo2eq[i];
eq2endo[it] = i;
- equation_reordered[i] = i;
- variable_reordered[it] = i;
+ eq_idx_block2orig[i] = i;
+ endo_idx_block2orig[it] = i;
}
/* Compute incidence matrix, equations in rows, variables in columns. Row
(resp. column) indices are to be interpreted according to
- “equation_reordered” (resp. “variable_reordered”). Stored in row-major
+ “eq_idx_block2orig” (resp. “endo_idx_block2orig”). Stored in row-major
order. */
vector<bool> IM(n*n, false);
if (cutoff == 0)
@@ -583,12 +583,12 @@ ModelTree::computePrologueAndEpilogue(const jacob_map_t &static_jacobian)
// Swap equations indexed by “new_prologue” and i
for (int j = 0; j < n; j++)
swap(IM[new_prologue * n + j], IM[i * n + j]);
- swap(equation_reordered[new_prologue], equation_reordered[i]);
+ swap(eq_idx_block2orig[new_prologue], eq_idx_block2orig[i]);
// Swap variables indexed by “new_prologue” and k (in the matching)
for (int j = 0; j < n; j++)
swap(IM[j * n + new_prologue], IM[j * n + k]);
- swap(variable_reordered[new_prologue], variable_reordered[k]);
+ swap(endo_idx_block2orig[new_prologue], endo_idx_block2orig[k]);
new_prologue++;
something_has_been_done = true;
@@ -618,11 +618,11 @@ ModelTree::computePrologueAndEpilogue(const jacob_map_t &static_jacobian)
{
for (int j = 0; j < n; j++)
swap(IM[(n - 1 - new_epilogue) * n + j], IM[k * n + j]);
- swap(equation_reordered[n - 1 - new_epilogue], equation_reordered[k]);
+ swap(eq_idx_block2orig[n - 1 - new_epilogue], eq_idx_block2orig[k]);
for (int j = 0; j < n; j++)
swap(IM[j * n + n - 1 - new_epilogue], IM[j * n + i]);
- swap(variable_reordered[n - 1 - new_epilogue], variable_reordered[i]);
+ swap(endo_idx_block2orig[n - 1 - new_epilogue], endo_idx_block2orig[i]);
new_epilogue++;
something_has_been_done = true;
@@ -642,8 +642,8 @@ ModelTree::equationTypeDetermination(const map<tuple<int, int, int>, expr_t> &fi
equation_type_and_normalized_equation.resize(equations.size());
for (int i = 0; i < static_cast<int>(equations.size()); i++)
{
- int eq = equation_reordered[i];
- int var = variable_reordered[i];
+ int eq = eq_idx_block2orig[i];
+ int var = endo_idx_block2orig[i];
expr_t lhs = equations[eq]->arg1;
EquationType Equation_Simulation_Type = EquationType::solve;
BinaryOpNode *normalized_eq = nullptr;
@@ -652,7 +652,7 @@ ModelTree::equationTypeDetermination(const map<tuple<int, int, int>, expr_t> &fi
{
expr_t derivative = it->second;
// Determine whether the equation can be evaluated rather than solved
- if (lhs->isVariableNodeEqualTo(SymbolType::endogenous, variable_reordered[i], 0)
+ if (lhs->isVariableNodeEqualTo(SymbolType::endogenous, endo_idx_block2orig[i], 0)
&& derivative->isNumConstNodeEqualTo(1))
Equation_Simulation_Type = EquationType::evaluate;
else
@@ -686,18 +686,18 @@ ModelTree::getVariableLeadLagByBlock(const vector<int> &endo2simblock, int num_s
{
if (i < prologue)
{
- variable_blck[variable_reordered[i]] = i;
- equation_blck[equation_reordered[i]] = i;
+ variable_blck[endo_idx_block2orig[i]] = i;
+ equation_blck[eq_idx_block2orig[i]] = i;
}
else if (i < static_cast<int>(endo2simblock.size()) + prologue)
{
- variable_blck[variable_reordered[i]] = endo2simblock[i-prologue] + prologue;
- equation_blck[equation_reordered[i]] = endo2simblock[i-prologue] + prologue;
+ variable_blck[endo_idx_block2orig[i]] = endo2simblock[i-prologue] + prologue;
+ equation_blck[eq_idx_block2orig[i]] = endo2simblock[i-prologue] + prologue;
}
else
{
- variable_blck[variable_reordered[i]] = i - (nb_endo - num_simblocks - prologue - epilogue);
- equation_blck[equation_reordered[i]] = i - (nb_endo - num_simblocks - prologue - epilogue);
+ variable_blck[endo_idx_block2orig[i]] = i - (nb_endo - num_simblocks - prologue - epilogue);
+ equation_blck[eq_idx_block2orig[i]] = i - (nb_endo - num_simblocks - prologue - epilogue);
}
}
for (const auto &[key, value] : dynamic_jacobian)
@@ -722,7 +722,7 @@ tuple<vector<pair<int, int>>, lag_lead_vector_t, lag_lead_vector_t,
vector<int>, vector<int>, vector<int>, vector<int>>
ModelTree::computeBlockDecompositionAndFeedbackVariablesForEachBlock(const jacob_map_t &static_jacobian, const equation_type_and_normalized_equation_t &Equation_Type, bool verbose_, bool select_feedback_variable)
{
- int nb_var = variable_reordered.size();
+ int nb_var = endo_idx_block2orig.size();
int n = nb_var - prologue - epilogue;
/* Construct the graph representing the dependencies between all
@@ -735,13 +735,13 @@ ModelTree::computeBlockDecompositionAndFeedbackVariablesForEachBlock(const jacob
for (const auto &[key, value] : cutoff == 0 ? computeSymbolicJacobian() : static_jacobian)
{
auto [eq, endo] = key;
- if (inv_equation_reordered[eq] >= prologue
- && inv_equation_reordered[eq] < nb_var - epilogue
- && inv_variable_reordered[endo] >= prologue
- && inv_variable_reordered[endo] < nb_var - epilogue
+ if (eq_idx_orig2block[eq] >= prologue
+ && eq_idx_orig2block[eq] < nb_var - epilogue
+ && endo_idx_orig2block[endo] >= prologue
+ && endo_idx_orig2block[endo] < nb_var - epilogue
&& eq != endo2eq[endo])
- add_edge(vertex(inv_equation_reordered[endo2eq[endo]]-prologue, G),
- vertex(inv_equation_reordered[eq]-prologue, G), G);
+ add_edge(vertex(eq_idx_orig2block[endo2eq[endo]]-prologue, G),
+ vertex(eq_idx_orig2block[eq]-prologue, G), G);
}
/* Identify the simultaneous blocks. Each simultaneous block is given an
@@ -765,17 +765,17 @@ ModelTree::computeBlockDecompositionAndFeedbackVariablesForEachBlock(const jacob
if (select_feedback_variable)
{
for (int i = 0; i < n; i++)
- if (Equation_Type[equation_reordered[i+prologue]].first == EquationType::solve
- || variable_lag_lead[variable_reordered[i+prologue]].second > 0
- || variable_lag_lead[variable_reordered[i+prologue]].first > 0
- || equation_lag_lead[equation_reordered[i+prologue]].second > 0
- || equation_lag_lead[equation_reordered[i+prologue]].first > 0
+ if (Equation_Type[eq_idx_block2orig[i+prologue]].first == EquationType::solve
+ || variable_lag_lead[endo_idx_block2orig[i+prologue]].second > 0
+ || variable_lag_lead[endo_idx_block2orig[i+prologue]].first > 0
+ || equation_lag_lead[eq_idx_block2orig[i+prologue]].second > 0
+ || equation_lag_lead[eq_idx_block2orig[i+prologue]].first > 0
|| mfs == 0)
add_edge(vertex(i, G), vertex(i, G), G);
}
else
for (int i = 0; i < n; i++)
- if (Equation_Type[equation_reordered[i+prologue]].first == EquationType::solve || mfs == 0)
+ if (Equation_Type[eq_idx_block2orig[i+prologue]].first == EquationType::solve || mfs == 0)
add_edge(vertex(i, G), vertex(i, G), G);
int num_blocks = prologue+num_simblocks+epilogue;
@@ -783,11 +783,11 @@ ModelTree::computeBlockDecompositionAndFeedbackVariablesForEachBlock(const jacob
vector<int> n_static(num_blocks, 0), n_forward(num_blocks, 0),
n_backward(num_blocks, 0), n_mixed(num_blocks, 0);
- const vector<int> old_equation_reordered(equation_reordered), old_variable_reordered(variable_reordered);
+ const vector<int> old_eq_idx_block2orig(eq_idx_block2orig), old_endo_idx_block2orig(endo_idx_block2orig);
for (int i = 0; i < prologue; i++)
{
- int max_lag = variable_lag_lead[old_variable_reordered[i]].first;
- int max_lead = variable_lag_lead[old_variable_reordered[i]].second;
+ int max_lag = variable_lag_lead[old_endo_idx_block2orig[i]].first;
+ int max_lead = variable_lag_lead[old_endo_idx_block2orig[i]].second;
if (max_lag != 0 && max_lead != 0)
n_mixed[i]++;
else if (max_lag == 0 && max_lead != 0)
@@ -815,12 +815,12 @@ ModelTree::computeBlockDecompositionAndFeedbackVariablesForEachBlock(const jacob
for (int j = 0; j < 4; j++)
for (int its : reordered_vertices)
{
- int max_lag = variable_lag_lead[old_variable_reordered[its+prologue]].first;
- int max_lead = variable_lag_lead[old_variable_reordered[its+prologue]].second;
+ int max_lag = variable_lag_lead[old_endo_idx_block2orig[its+prologue]].first;
+ int max_lead = variable_lag_lead[old_endo_idx_block2orig[its+prologue]].second;
auto reorder = [&]()
{
- equation_reordered[ordidx] = old_equation_reordered[its+prologue];
- variable_reordered[ordidx] = old_variable_reordered[its+prologue];
+ eq_idx_block2orig[ordidx] = old_eq_idx_block2orig[its+prologue];
+ endo_idx_block2orig[ordidx] = old_endo_idx_block2orig[its+prologue];
ordidx++;
};
if (j == 2 && max_lag != 0 && max_lead != 0)
@@ -850,12 +850,12 @@ ModelTree::computeBlockDecompositionAndFeedbackVariablesForEachBlock(const jacob
for (int fbvertex : feed_back_vertices)
{
int idx = v_index1[vertex(fbvertex, subG)];
- int max_lag = variable_lag_lead[old_variable_reordered[idx+prologue]].first;
- int max_lead = variable_lag_lead[old_variable_reordered[idx+prologue]].second;
+ int max_lag = variable_lag_lead[old_endo_idx_block2orig[idx+prologue]].first;
+ int max_lead = variable_lag_lead[old_endo_idx_block2orig[idx+prologue]].second;
auto reorder = [&]()
{
- equation_reordered[ordidx] = old_equation_reordered[idx+prologue];
- variable_reordered[ordidx] = old_variable_reordered[idx+prologue];
+ eq_idx_block2orig[ordidx] = old_eq_idx_block2orig[idx+prologue];
+ endo_idx_block2orig[ordidx] = old_endo_idx_block2orig[idx+prologue];
ordidx++;
};
if (j == 2 && max_lag != 0 && max_lead != 0)
@@ -883,8 +883,8 @@ ModelTree::computeBlockDecompositionAndFeedbackVariablesForEachBlock(const jacob
for (int i = 0; i < epilogue; i++)
{
- int max_lag = variable_lag_lead[old_variable_reordered[prologue+n+i]].first;
- int max_lead = variable_lag_lead[old_variable_reordered[prologue+n+i]].second;
+ int max_lag = variable_lag_lead[old_endo_idx_block2orig[prologue+n+i]].first;
+ int max_lead = variable_lag_lead[old_endo_idx_block2orig[prologue+n+i]].second;
if (max_lag != 0 && max_lead != 0)
n_mixed[prologue+num_simblocks+i]++;
else if (max_lag == 0 && max_lead != 0)
@@ -965,12 +965,12 @@ ModelTree::reduceBlocksAndTypeDetermination(const vector<pair<int, int>> &simblo
for (count_equ = first_count_equ; count_equ < Blck_Size+first_count_equ; count_equ++)
{
set<pair<int, int>> endos_and_lags;
- equations[equation_reordered[count_equ]]->collectEndogenous(endos_and_lags);
+ equations[eq_idx_block2orig[count_equ]]->collectEndogenous(endos_and_lags);
for (const auto &[curr_variable, curr_lag] : endos_and_lags)
{
if (linear_decomposition)
{
- if (dynamic_jacobian.find({ curr_lag, equation_reordered[count_equ], curr_variable }) != dynamic_jacobian.end())
+ if (dynamic_jacobian.find({ curr_lag, eq_idx_block2orig[count_equ], curr_variable }) != dynamic_jacobian.end())
{
if (curr_lag > Lead)
Lead = curr_lag;
@@ -980,9 +980,9 @@ ModelTree::reduceBlocksAndTypeDetermination(const vector<pair<int, int>> &simblo
}
else
{
- if (find(variable_reordered.begin()+first_count_equ, variable_reordered.begin()+(first_count_equ+Blck_Size), curr_variable)
- != variable_reordered.begin()+(first_count_equ+Blck_Size)
- && dynamic_jacobian.find({ curr_lag, equation_reordered[count_equ], curr_variable }) != dynamic_jacobian.end())
+ if (find(endo_idx_block2orig.begin()+first_count_equ, endo_idx_block2orig.begin()+(first_count_equ+Blck_Size), curr_variable)
+ != endo_idx_block2orig.begin()+(first_count_equ+Blck_Size)
+ && dynamic_jacobian.find({ curr_lag, eq_idx_block2orig[count_equ], curr_variable }) != dynamic_jacobian.end())
{
if (curr_lag > Lead)
Lead = curr_lag;
@@ -1020,8 +1020,8 @@ ModelTree::reduceBlocksAndTypeDetermination(const vector<pair<int, int>> &simblo
int l_n_mixed = n_mixed[i];
if (Blck_Size == 1)
{
- if (Equation_Type[equation_reordered[eq]].first == EquationType::evaluate
- || Equation_Type[equation_reordered[eq]].first == EquationType::evaluate_s)
+ if (Equation_Type[eq_idx_block2orig[eq]].first == EquationType::evaluate
+ || Equation_Type[eq_idx_block2orig[eq]].first == EquationType::evaluate_s)
{
if (Simulation_Type == BlockSimulationType::solveBackwardSimple)
Simulation_Type = BlockSimulationType::evaluateBackward;
@@ -1039,10 +1039,10 @@ ModelTree::reduceBlocksAndTypeDetermination(const vector<pair<int, int>> &simblo
{
for (int j = first_equation; j < first_equation+c_Size; j++)
{
- if (dynamic_jacobian.find({ -1, equation_reordered[eq], variable_reordered[j] })
+ if (dynamic_jacobian.find({ -1, eq_idx_block2orig[eq], endo_idx_block2orig[j] })
!= dynamic_jacobian.end())
is_lag = true;
- if (dynamic_jacobian.find({ +1, equation_reordered[eq], variable_reordered[j] })
+ if (dynamic_jacobian.find({ +1, eq_idx_block2orig[eq], endo_idx_block2orig[j] })
!= dynamic_jacobian.end())
is_lead = true;
}
@@ -1127,7 +1127,7 @@ ModelTree::determineLinearBlocks()
d1->collectEndogenous(endogenous);
if (endogenous.size() > 0)
for (int l = 0; l < block_size; l++)
- if (endogenous.find({ variable_reordered[first_variable_position+l], 0 }) != endogenous.end())
+ if (endogenous.find({ endo_idx_block2orig[first_variable_position+l], 0 }) != endogenous.end())
{
blocks_linear[block] = false;
goto the_end;
@@ -1142,7 +1142,7 @@ ModelTree::determineLinearBlocks()
d1->collectEndogenous(endogenous);
if (endogenous.size() > 0)
for (int l = 0; l < block_size; l++)
- if (endogenous.find({ variable_reordered[first_variable_position+l], lag }) != endogenous.end())
+ if (endogenous.find({ endo_idx_block2orig[first_variable_position+l], lag }) != endogenous.end())
{
blocks_linear[block] = false;
goto the_end;
@@ -1957,10 +1957,10 @@ void
ModelTree::initializeVariablesAndEquations()
{
for (size_t j = 0; j < equations.size(); j++)
- equation_reordered.push_back(j);
+ eq_idx_block2orig.push_back(j);
for (int j = 0; j < symbol_table.endo_nbr(); j++)
- variable_reordered.push_back(j);
+ endo_idx_block2orig.push_back(j);
}
void
@@ -2379,11 +2379,11 @@ void
ModelTree::updateReverseVariableEquationOrderings()
{
int n = equations.size();
- inv_equation_reordered.resize(n);
- inv_variable_reordered.resize(n);
+ eq_idx_orig2block.resize(n);
+ endo_idx_orig2block.resize(n);
for (int i = 0; i < n; i++)
{
- inv_variable_reordered[variable_reordered[i]] = i;
- inv_equation_reordered[equation_reordered[i]] = i;
+ endo_idx_orig2block[endo_idx_block2orig[i]] = i;
+ eq_idx_orig2block[eq_idx_block2orig[i]] = i;
}
}
diff --git a/src/ModelTree.hh b/src/ModelTree.hh
index 7cdca5f5daf4c5bd3dc36a3fb8a0b97fc3ec0151..37cdeaa84eac9a30fc549ca9da63146d55241ec3 100644
--- a/src/ModelTree.hh
+++ b/src/ModelTree.hh
@@ -171,9 +171,15 @@ protected:
//! The jacobian without the elements below the cutoff
dynamic_jacob_map_t dynamic_jacobian;
- //! vector of block reordered variables and equations
- // See also updateReverseVariableEquationOrderings()
- vector<int> equation_reordered, variable_reordered, inv_equation_reordered, inv_variable_reordered;
+ /* Maps indices of equations in the block-decomposition order into original
+ equation IDs */
+ vector<int> eq_idx_block2orig;
+ /* Maps indices of (endogenous) variables in the block-decomposition order into original
+ type-specific endogenous IDs */
+ vector<int> endo_idx_block2orig;
+ /* Maps original variable and equation indices into the block-decomposition order.
+ Set by updateReverseVariableEquationOrderings() */
+ vector<int> eq_idx_orig2block, endo_idx_orig2block;
//! Store the derivatives or the chainrule derivatives:map<tuple<equation, variable, lead_lag>, expr_t>
using first_chain_rule_derivatives_t = map<tuple<int, int, int>, expr_t>;
@@ -271,7 +277,7 @@ protected:
depending on whether the variable symbolically appears in the equation */
jacob_map_t computeSymbolicJacobian() const;
- // Update inv_{equation,variable}_reordered from {equation,variable}_reordered
+ // Compute {var,eq}_idx_orig2block from {var,eq}_idx_block2orig
void updateReverseVariableEquationOrderings();
//! Compute the matching between endogenous and variable using the jacobian contemporaneous_jacobian
diff --git a/src/StaticModel.cc b/src/StaticModel.cc
index 956ad7547991aa3346607652f81d3a4b4ca24fe4..616ec23f67c60100df635ec3441b7dcf8f9c13f4 100644
--- a/src/StaticModel.cc
+++ b/src/StaticModel.cc
@@ -507,8 +507,8 @@ StaticModel::writeModelEquationsCode(const string &basename, map_idx_t map_idx)
BlockSimulationType::solveForwardComplete,
0,
symbol_table.endo_nbr(),
- variable_reordered,
- equation_reordered,
+ endo_idx_block2orig,
+ eq_idx_block2orig,
false,
symbol_table.endo_nbr(),
0,
@@ -701,8 +701,8 @@ StaticModel::writeModelEquationsCode_Block(const string &basename, map_idx_t map
simulation_type,
getBlockFirstEquation(block),
block_size,
- variable_reordered,
- equation_reordered,
+ endo_idx_block2orig,
+ eq_idx_block2orig,
blocks_linear[block],
symbol_table.endo_nbr(),
0,
@@ -2035,11 +2035,11 @@ StaticModel::writeOutput(ostream &output, bool block) const
int nb_endo = symbol_table.endo_nbr();
output << "M_.block_structure_stat.variable_reordered = [";
for (int i = 0; i < nb_endo; i++)
- output << " " << variable_reordered[i]+1;
+ output << " " << endo_idx_block2orig[i]+1;
output << "];" << endl
<< "M_.block_structure_stat.equation_reordered = [";
for (int i = 0; i < nb_endo; i++)
- output << " " << equation_reordered[i]+1;
+ output << " " << eq_idx_block2orig[i]+1;
output << "];" << endl;
map<pair<int, int>, int> row_incidence;
@@ -2230,7 +2230,7 @@ void
StaticModel::collect_block_first_order_derivatives()
{
//! vector for an equation or a variable indicates the block number
- vector<int> equation_2_block(equation_reordered.size()), variable_2_block(variable_reordered.size());
+ vector<int> equation_2_block(eq_idx_block2orig.size()), variable_2_block(endo_idx_block2orig.size());
int nb_blocks = getNbBlocks();
for (int block = 0; block < nb_blocks; block++)
{
diff --git a/src/StaticModel.hh b/src/StaticModel.hh
index 6fd760e97ee4744c0420c0e5d406511cdb22d610..9c2f0c5a40991c5487da196445e7fa926aa86aed 100644
--- a/src/StaticModel.hh
+++ b/src/StaticModel.hh
@@ -248,37 +248,37 @@ public:
EquationType
getBlockEquationType(int block_number, int equation_number) const override
{
- return (equation_type_and_normalized_equation[equation_reordered[get<1>(block_type_firstequation_size_mfs[block_number])+equation_number]].first);
+ return (equation_type_and_normalized_equation[eq_idx_block2orig[get<1>(block_type_firstequation_size_mfs[block_number])+equation_number]].first);
};
//! Return true if the equation has been normalized
bool
isBlockEquationRenormalized(int block_number, int equation_number) const override
{
- return (equation_type_and_normalized_equation[equation_reordered[get<1>(block_type_firstequation_size_mfs[block_number])+equation_number]].first == EquationType::evaluate_s);
+ return (equation_type_and_normalized_equation[eq_idx_block2orig[get<1>(block_type_firstequation_size_mfs[block_number])+equation_number]].first == EquationType::evaluate_s);
};
//! Return the expr_t of the equation equation_number belonging to the block block_number
expr_t
getBlockEquationExpr(int block_number, int equation_number) const override
{
- return (equations[equation_reordered[get<1>(block_type_firstequation_size_mfs[block_number])+equation_number]]);
+ return (equations[eq_idx_block2orig[get<1>(block_type_firstequation_size_mfs[block_number])+equation_number]]);
};
//! Return the expr_t of the renormalized equation equation_number belonging to the block block_number
expr_t
getBlockEquationRenormalizedExpr(int block_number, int equation_number) const override
{
- return (equation_type_and_normalized_equation[equation_reordered[get<1>(block_type_firstequation_size_mfs[block_number])+equation_number]].second);
+ return (equation_type_and_normalized_equation[eq_idx_block2orig[get<1>(block_type_firstequation_size_mfs[block_number])+equation_number]].second);
};
//! Return the original number of equation equation_number belonging to the block block_number
int
getBlockEquationID(int block_number, int equation_number) const override
{
- return (equation_reordered[get<1>(block_type_firstequation_size_mfs[block_number])+equation_number]);
+ return (eq_idx_block2orig[get<1>(block_type_firstequation_size_mfs[block_number])+equation_number]);
};
//! Return the original number of variable variable_number belonging to the block block_number
int
getBlockVariableID(int block_number, int variable_number) const override
{
- return (variable_reordered[get<1>(block_type_firstequation_size_mfs[block_number])+variable_number]);
+ return (endo_idx_block2orig[get<1>(block_type_firstequation_size_mfs[block_number])+variable_number]);
};
//! Return the original number of the exogenous variable varexo_number belonging to the block block_number
int
@@ -290,13 +290,13 @@ public:
int
getBlockInitialEquationID(int block_number, int equation_number) const override
{
- return inv_equation_reordered[equation_number] - get<1>(block_type_firstequation_size_mfs[block_number]);
+ return eq_idx_orig2block[equation_number] - get<1>(block_type_firstequation_size_mfs[block_number]);
};
//! Return the position of variable_number in the block number belonging to the block block_number
int
getBlockInitialVariableID(int block_number, int variable_number) const override
{
- return inv_variable_reordered[variable_number] - get<1>(block_type_firstequation_size_mfs[block_number]);
+ return endo_idx_orig2block[variable_number] - get<1>(block_type_firstequation_size_mfs[block_number]);
};
//! Return the position of variable_number in the block number belonging to the block block_number
int