StaticModel.cc 147 KB
Newer Older
sebastien's avatar
sebastien committed
1
/*
Houtan Bastani's avatar
Houtan Bastani committed
2
 * Copyright (C) 2003-2018 Dynare Team
sebastien's avatar
sebastien committed
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 *
 * This file is part of Dynare.
 *
 * Dynare is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Dynare is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Dynare.  If not, see <http://www.gnu.org/licenses/>.
 */

20
21
#include <iostream>
#include <cmath>
22
#include <cstdlib>
23
#include <cassert>
24
25
#include <cstdio>
#include <cerrno>
sebastien's avatar
sebastien committed
26
#include <algorithm>
27

28
#include "StaticModel.hh"
29
#include "DynamicModel.hh"
sebastien's avatar
sebastien committed
30

31
32
33
void
StaticModel::copyHelper(const StaticModel &m)
{
34
  auto f = [this](expr_t e) { return e->clone(*this); };
35

36
  auto convert_vector_tt = [f](vector<temporary_terms_t> vtt)
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
    {
      vector<temporary_terms_t> vtt2;
      for (const auto &tt : vtt)
        {
          temporary_terms_t tt2;
          for (const auto &it : tt)
            tt2.insert(f(it));
          vtt2.push_back(tt2);
        }
      return vtt2;
    };

  for (const auto &it : m.v_temporary_terms)
    v_temporary_terms.push_back(convert_vector_tt(it));
  for (const auto &it : m.v_temporary_terms_local)
    v_temporary_terms_local.push_back(convert_vector_tt(it));

  for (const auto &it : m.first_chain_rule_derivatives)
    first_chain_rule_derivatives[it.first] = f(it.second);

  for (const auto &it : m.equation_type_and_normalized_equation)
    equation_type_and_normalized_equation.push_back(make_pair(it.first, f(it.second)));

  for (const auto &it : m.blocks_derivatives)
    {
      block_derivatives_equation_variable_laglead_nodeid_t v;
      for (const auto &it2 : it)
        v.push_back(make_pair(it2.first, make_pair(it2.second.first, f(it2.second.second))));
      blocks_derivatives.push_back(v);
    }

  for (const auto &it : m.dynamic_jacobian)
    dynamic_jacobian[it.first] = f(it.second);

71
  auto convert_derivative_t = [f](derivative_t dt)
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
    {
      derivative_t dt2;
      for (const auto &it : dt)
        dt2[it.first] = f(it.second);
      return dt2;
    };
  for (const auto &it : m.derivative_endo)
    derivative_endo.push_back(convert_derivative_t(it));
  for (const auto &it : m.derivative_other_endo)
    derivative_other_endo.push_back(convert_derivative_t(it));
  for (const auto &it : m.derivative_exo)
    derivative_exo.push_back(convert_derivative_t(it));
  for (const auto &it : m.derivative_exo_det)
    derivative_exo_det.push_back(convert_derivative_t(it));
}

88
StaticModel::StaticModel(SymbolTable &symbol_table_arg,
89
                         NumericalConstants &num_constants_arg,
90
                         ExternalFunctionsTable &external_functions_table_arg) :
91
  ModelTree{symbol_table_arg, num_constants_arg, external_functions_table_arg}
92
93
{
}
94

95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
StaticModel::StaticModel(const StaticModel &m) :
  ModelTree {m},
  v_temporary_terms_inuse {m.v_temporary_terms_inuse},
  map_idx {m.map_idx},
  map_idx2 {m.map_idx2},
  global_temporary_terms {m.global_temporary_terms},
  block_type_firstequation_size_mfs {m.block_type_firstequation_size_mfs},
  blocks_linear {m.blocks_linear},
  other_endo_block {m.other_endo_block},
  exo_block {m.exo_block},
  exo_det_block {m.exo_det_block},
  block_col_type {m.block_col_type},
  variable_block_lead_lag {m.variable_block_lead_lag},
  equation_block {m.equation_block},
  endo_max_leadlag_block {m.endo_max_leadlag_block},
  other_endo_max_leadlag_block {m.other_endo_max_leadlag_block},
  exo_max_leadlag_block {m.exo_max_leadlag_block},
  exo_det_max_leadlag_block {m.exo_det_max_leadlag_block},
  max_leadlag_block {m.max_leadlag_block}
{
  copyHelper(m);
}

StaticModel &
StaticModel::operator=(const StaticModel &m)
{
  ModelTree::operator=(m);

  v_temporary_terms.clear();
  v_temporary_terms_local.clear();

  v_temporary_terms_inuse = m.v_temporary_terms_inuse;

  first_chain_rule_derivatives.clear();

  map_idx = m.map_idx;
  map_idx2 = m.map_idx2;
  global_temporary_terms = m.global_temporary_terms;

  equation_type_and_normalized_equation.clear();

  block_type_firstequation_size_mfs = m.block_type_firstequation_size_mfs;

  blocks_derivatives.clear();
  dynamic_jacobian.clear();

  blocks_linear = m.blocks_linear;

  derivative_endo.clear();
  derivative_other_endo.clear();
  derivative_exo.clear();
  derivative_exo_det.clear();

  other_endo_block = m.other_endo_block;
  exo_block = m.exo_block;
  exo_det_block = m.exo_det_block;
  block_col_type = m.block_col_type;
  variable_block_lead_lag = m.variable_block_lead_lag;
  equation_block = m.equation_block;
  endo_max_leadlag_block = m.endo_max_leadlag_block;
  other_endo_max_leadlag_block = m.other_endo_max_leadlag_block;
  exo_max_leadlag_block = m.exo_max_leadlag_block;
  exo_det_max_leadlag_block = m.exo_det_max_leadlag_block;
  max_leadlag_block = m.max_leadlag_block;

  copyHelper(m);

  return *this;
}

165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
StaticModel::StaticModel(const DynamicModel &m) :
  ModelTree {m.symbol_table, m.num_constants, m.external_functions_table}
{
  // Convert model local variables (need to be done first)
  for (int it : m.local_variables_vector)
    AddLocalVariable(it, m.local_variables_table.find(it)->second->toStatic(*this));

  // Convert equations
  int static_only_index = 0;
  for (int i = 0; i < static_cast<int>(m.equations.size()); i++)
    {
      // Detect if equation is marked [dynamic]
      bool is_dynamic_only = false;
      vector<pair<string, string>> eq_tags;
      for (const auto & equation_tag : equation_tags)
        if (equation_tag.first == i)
          {
            eq_tags.push_back(equation_tag.second);
            if (equation_tag.second.first == "dynamic")
              is_dynamic_only = true;
          }

      try
        {
          // If yes, replace it by an equation marked [static]
          if (is_dynamic_only)
            {
              auto tuple = m.getStaticOnlyEquationsInfo();
              auto static_only_equations = get<0>(tuple);
              auto static_only_equations_lineno = get<1>(tuple);
              auto static_only_equations_equation_tags = get<2>(tuple);

              // With C++17, rather use structured bindings, as:
              //auto [ static_only_equations, static_only_equations_lineno, static_only_equations_equation_tags ] = m.getStaticOnlyEquationsInfo();

              addEquation(static_only_equations[static_only_index]->toStatic(*this), static_only_equations_lineno[static_only_index], static_only_equations_equation_tags[static_only_index]);
              static_only_index++;
            }
          else
            addEquation(m.equations[i]->toStatic(*this), m.equations_lineno[i], eq_tags);
        }
      catch (DataTree::DivisionByZeroException)
        {
          cerr << "...division by zero error encountred when converting equation " << i << " to static" << endl;
          exit(EXIT_FAILURE);
        }
    }

  // Convert auxiliary equations
  for (auto aux_eq : m.aux_equations)
    addAuxEquation(aux_eq->toStatic(*this));
}

218
void
219
StaticModel::compileDerivative(ofstream &code_file, unsigned int &instruction_number, int eq, int symb_id, map_idx_t &map_idx, temporary_terms_t temporary_terms) const
220
{
221
222
  auto it = derivatives[1].find({ eq, getDerivID(symbol_table.getID(SymbolType::endogenous, symb_id), 0) });
  if (it != derivatives[1].end())
223
    (it->second)->compile(code_file, instruction_number, false, temporary_terms, map_idx, false, false);
224
225
226
  else
    {
      FLDZ_ fldz;
227
      fldz.write(code_file, instruction_number);
228
229
    }
}
sebastien's avatar
sebastien committed
230

231
void
232
StaticModel::compileChainRuleDerivative(ofstream &code_file, unsigned int &instruction_number, int eqr, int varr, int lag, map_idx_t &map_idx, temporary_terms_t temporary_terms) const
233
{
234
  auto it = first_chain_rule_derivatives.find({ eqr, { varr, lag } });
235
  if (it != first_chain_rule_derivatives.end())
236
    (it->second)->compile(code_file, instruction_number, false, temporary_terms, map_idx, false, false);
237
238
239
  else
    {
      FLDZ_ fldz;
240
      fldz.write(code_file, instruction_number);
241
242
243
244
245
246
    }
}

void
StaticModel::computeTemporaryTermsOrdered()
{
247
  map<expr_t, pair<int, int>> first_occurence;
248
  map<expr_t, int> reference_count;
249
  BinaryOpNode *eq_node;
250
  first_chain_rule_derivatives_t::const_iterator it_chr;
251
252
253
254
255
  ostringstream tmp_s;
  v_temporary_terms.clear();
  map_idx.clear();

  unsigned int nb_blocks = getNbBlocks();
256
257
  v_temporary_terms = vector< vector<temporary_terms_t>>(nb_blocks);
  v_temporary_terms_local = vector< vector<temporary_terms_t>>(nb_blocks);
258

259
  v_temporary_terms_inuse = vector<temporary_terms_inuse_t>(nb_blocks);
260

261
262
  map_idx2 = vector<map_idx_t>(nb_blocks);

263
  temporary_terms.clear();
264
265
266

  //local temporay terms
  for (unsigned int block = 0; block < nb_blocks; block++)
267
    {
268
269
      map<expr_t, int> reference_count_local;
      reference_count_local.clear();
270
      map<expr_t, pair<int, int>> first_occurence_local;
271
272
273
      first_occurence_local.clear();
      temporary_terms_t temporary_terms_l;
      temporary_terms_l.clear();
274

275
276
277
278
279
280
281
282
283
284
      unsigned int block_size = getBlockSize(block);
      unsigned int block_nb_mfs = getBlockMfs(block);
      unsigned int block_nb_recursives = block_size - block_nb_mfs;
      v_temporary_terms_local[block] = vector<temporary_terms_t>(block_size);

      for (unsigned int i = 0; i < block_size; i++)
        {
          if (i < block_nb_recursives && isBlockEquationRenormalized(block, i))
            getBlockEquationRenormalizedExpr(block, i)->computeTemporaryTerms(reference_count_local, temporary_terms_l, first_occurence_local, block, v_temporary_terms_local,  i);
          else
285
            {
286
287
              eq_node = (BinaryOpNode *) getBlockEquationExpr(block, i);
              eq_node->computeTemporaryTerms(reference_count_local, temporary_terms_l, first_occurence_local, block, v_temporary_terms_local,  i);
288
289
            }
        }
290
291
292
293
294
295
296
297
298
      for (block_derivatives_equation_variable_laglead_nodeid_t::const_iterator it = blocks_derivatives[block].begin(); it != (blocks_derivatives[block]).end(); it++)
        {
          expr_t id = it->second.second;
          id->computeTemporaryTerms(reference_count_local, temporary_terms_l, first_occurence_local, block, v_temporary_terms_local,  block_size-1);
        }
      set<int> temporary_terms_in_use;
      temporary_terms_in_use.clear();
      v_temporary_terms_inuse[block] = temporary_terms_in_use;
      computeTemporaryTermsMapping(temporary_terms_l, map_idx2[block]);
299
    }
300
301
302

  // global temporay terms
  for (unsigned int block = 0; block < nb_blocks; block++)
303
    {
304
305
306
307
308
309
      // Compute the temporary terms reordered
      unsigned int block_size = getBlockSize(block);
      unsigned int block_nb_mfs = getBlockMfs(block);
      unsigned int block_nb_recursives = block_size - block_nb_mfs;
      v_temporary_terms[block] = vector<temporary_terms_t>(block_size);
      for (unsigned int i = 0; i < block_size; i++)
310
        {
311
312
313
          if (i < block_nb_recursives && isBlockEquationRenormalized(block, i))
            getBlockEquationRenormalizedExpr(block, i)->computeTemporaryTerms(reference_count, temporary_terms, first_occurence, block, v_temporary_terms,  i);
          else
314
            {
315
316
              eq_node = (BinaryOpNode *) getBlockEquationExpr(block, i);
              eq_node->computeTemporaryTerms(reference_count, temporary_terms, first_occurence, block, v_temporary_terms, i);
317
318
            }
        }
319
      for (block_derivatives_equation_variable_laglead_nodeid_t::const_iterator it = blocks_derivatives[block].begin(); it != (blocks_derivatives[block]).end(); it++)
320
        {
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
          expr_t id = it->second.second;
          id->computeTemporaryTerms(reference_count, temporary_terms, first_occurence, block, v_temporary_terms, block_size-1);
        }
    }

  for (unsigned int block = 0; block < nb_blocks; block++)
    {
      // Collecte the temporary terms reordered
      unsigned int block_size = getBlockSize(block);
      unsigned int block_nb_mfs = getBlockMfs(block);
      unsigned int block_nb_recursives = block_size - block_nb_mfs;
      set<int> temporary_terms_in_use;
      for (unsigned int i = 0; i < block_size; i++)
        {
          if (i < block_nb_recursives && isBlockEquationRenormalized(block, i))
            getBlockEquationRenormalizedExpr(block, i)->collectTemporary_terms(temporary_terms, temporary_terms_in_use, block);
          else
338
            {
339
340
              eq_node = (BinaryOpNode *) getBlockEquationExpr(block, i);
              eq_node->collectTemporary_terms(temporary_terms, temporary_terms_in_use, block);
341
342
            }
        }
343
344
345
346
347
348
      for (block_derivatives_equation_variable_laglead_nodeid_t::const_iterator it = blocks_derivatives[block].begin(); it != (blocks_derivatives[block]).end(); it++)
        {
          expr_t id = it->second.second;
          id->collectTemporary_terms(temporary_terms, temporary_terms_in_use, block);
        }
      for (int i = 0; i < (int) getBlockSize(block); i++)
349
        for (auto it = v_temporary_terms[block][i].begin();
350
351
352
             it != v_temporary_terms[block][i].end(); it++)
          (*it)->collectTemporary_terms(temporary_terms, temporary_terms_in_use, block);
      v_temporary_terms_inuse[block] = temporary_terms_in_use;
353
    }
354
  computeTemporaryTermsMapping(temporary_terms, map_idx);
355
356
357
}

void
358
StaticModel::computeTemporaryTermsMapping(temporary_terms_t &temporary_terms, map_idx_t &map_idx)
359
{
360
  // Add a mapping form node ID to temporary terms order
361
  int j = 0;
362
363
  for (auto temporary_term : temporary_terms)
    map_idx[temporary_term->idx] = j++;
364
365
366
}

void
367
StaticModel::writeModelEquationsOrdered_M(const string &basename) const
368
369
370
{
  string tmp_s, sps;
  ostringstream tmp_output, tmp1_output, global_output;
371
  expr_t lhs = nullptr, rhs = nullptr;
372
  BinaryOpNode *eq_node;
373
  map<expr_t, int> reference_count;
374
  temporary_terms_t local_temporary_terms;
375
376
  ofstream  output;
  vector<int> feedback_variables;
377
  deriv_node_temp_terms_t tef_terms;
378
  ExprNodeOutputType local_output_type;
379

380
  local_output_type = ExprNodeOutputType::matlabStaticModelSparse;
381
  if (global_temporary_terms)
Sébastien Villemot's avatar
Sébastien Villemot committed
382
    local_temporary_terms = temporary_terms;
383
384
385
386
387
388
389
390
391
392
393
394
395
396

  //----------------------------------------------------------------------
  //For each block
  for (unsigned int block = 0; block < getNbBlocks(); block++)
    {
      //recursive_variables.clear();
      feedback_variables.clear();
      //For a block composed of a single equation determines wether we have to evaluate or to solve the equation
      BlockSimulationType simulation_type = getBlockSimulationType(block);
      unsigned int block_size = getBlockSize(block);
      unsigned int block_mfs = getBlockMfs(block);
      unsigned int block_recursive = block_size - block_mfs;

      tmp1_output.str("");
397
      tmp1_output << packageDir(basename + ".block") << "/static_" << block+1 << ".m";
398
      output.open(tmp1_output.str(), ios::out | ios::binary);
399
400
401
402
403
404
405
      output << "%\n";
      output << "% " << tmp1_output.str() << " : Computes static model for Dynare\n";
      output << "%\n";
      output << "% Warning : this file is generated automatically by Dynare\n";
      output << "%           from model file (.mod)\n\n";
      output << "%/\n";
      if (simulation_type == EVALUATE_BACKWARD || simulation_type == EVALUATE_FORWARD)
406
        output << "function y = static_" << block+1 << "(y, x, params)\n";
407
      else
408
        output << "function [residual, y, g1] = static_" << block+1 << "(y, x, params)\n";
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431

      BlockType block_type;
      if (simulation_type == SOLVE_FORWARD_COMPLETE || simulation_type == SOLVE_BACKWARD_COMPLETE)
        block_type = SIMULTANS;
      else if ((simulation_type == SOLVE_FORWARD_SIMPLE || simulation_type == SOLVE_BACKWARD_SIMPLE
                || simulation_type == EVALUATE_BACKWARD    || simulation_type == EVALUATE_FORWARD)
               && getBlockFirstEquation(block) < prologue)
        block_type = PROLOGUE;
      else if ((simulation_type == SOLVE_FORWARD_SIMPLE || simulation_type == SOLVE_BACKWARD_SIMPLE
                || simulation_type == EVALUATE_BACKWARD    || simulation_type == EVALUATE_FORWARD)
               && getBlockFirstEquation(block) >= equations.size() - epilogue)
        block_type = EPILOGUE;
      else
        block_type = SIMULTANS;
      output << "  % ////////////////////////////////////////////////////////////////////////" << endl
             << "  % //" << string("                     Block ").substr(int (log10(block + 1))) << block + 1 << " " << BlockType0(block_type)
             << "          //" << endl
             << "  % //                     Simulation type "
             << BlockSim(simulation_type) << "  //" << endl
             << "  % ////////////////////////////////////////////////////////////////////////" << endl;
      output << "  global options_;" << endl;
      //The Temporary terms
      if (simulation_type != EVALUATE_BACKWARD  && simulation_type != EVALUATE_FORWARD)
432
        output << " g1 = spalloc("  << block_mfs << ", " << block_mfs << ", " << derivative_endo[block].size() << ");" << endl;
433
434
435
436

      if (v_temporary_terms_inuse[block].size())
        {
          tmp_output.str("");
437
438
          for (int it : v_temporary_terms_inuse[block])
            tmp_output << " T" << it;
439
440
441
442
443
444
445
          output << "  global" << tmp_output.str() << ";\n";
        }

      if (simulation_type != EVALUATE_BACKWARD && simulation_type != EVALUATE_FORWARD)
        output << "  residual=zeros(" << block_mfs << ",1);\n";

      // The equations
Houtan Bastani's avatar
Houtan Bastani committed
446
      temporary_terms_idxs_t temporary_terms_idxs;
447
448
449
450
      for (unsigned int i = 0; i < block_size; i++)
        {
          if (!global_temporary_terms)
            local_temporary_terms = v_temporary_terms[block][i];
451
          temporary_terms_t tt2;
452
453
454
455
          tt2.clear();
          if (v_temporary_terms[block].size())
            {
              output << "  " << "% //Temporary variables" << endl;
456
              for (auto it : v_temporary_terms[block][i])
457
                {
458
                  if (dynamic_cast<AbstractExternalFunctionNode *>(it) != nullptr)
459
                    it->writeExternalFunctionOutput(output, local_output_type, tt2, {}, tef_terms);
460

461
                  output << "  " <<  sps;
462
                  it->writeOutput(output, local_output_type, local_temporary_terms, {}, tef_terms);
463
                  output << " = ";
464
                  it->writeOutput(output, local_output_type, tt2, {}, tef_terms);
465
                  // Insert current node into tt2
466
                  tt2.insert(it);
467
468
469
470
471
472
473
                  output << ";" << endl;
                }
            }

          int variable_ID = getBlockVariableID(block, i);
          int equation_ID = getBlockEquationID(block, i);
          EquationType equ_type = getBlockEquationType(block, i);
474
          string sModel = symbol_table.getName(symbol_table.getID(SymbolType::endogenous, variable_ID));
475
          eq_node = (BinaryOpNode *) getBlockEquationExpr(block, i);
476
477
478
          lhs = eq_node->get_arg1();
          rhs = eq_node->get_arg2();
          tmp_output.str("");
479
          lhs->writeOutput(tmp_output, local_output_type, local_temporary_terms, {});
480
481
482
483
484
485
486
487
488
489
490
491
          switch (simulation_type)
            {
            case EVALUATE_BACKWARD:
            case EVALUATE_FORWARD:
            evaluation:
              output << "  % equation " << getBlockEquationID(block, i)+1 << " variable : " << sModel
                     << " (" << variable_ID+1 << ") " << c_Equation_Type(equ_type) << endl;
              output << "  ";
              if (equ_type == E_EVALUATE)
                {
                  output << tmp_output.str();
                  output << " = ";
492
                  rhs->writeOutput(output, local_output_type, local_temporary_terms, {});
493
494
495
496
497
498
499
                }
              else if (equ_type == E_EVALUATE_S)
                {
                  output << "%" << tmp_output.str();
                  output << " = ";
                  if (isBlockEquationRenormalized(block, i))
                    {
500
                      rhs->writeOutput(output, local_output_type, local_temporary_terms, {});
501
502
                      output << "\n  ";
                      tmp_output.str("");
503
                      eq_node = (BinaryOpNode *) getBlockEquationRenormalizedExpr(block, i);
504
505
                      lhs = eq_node->get_arg1();
                      rhs = eq_node->get_arg2();
506
                      lhs->writeOutput(output, local_output_type, local_temporary_terms, {});
507
                      output << " = ";
508
                      rhs->writeOutput(output, local_output_type, local_temporary_terms, {});
509
510
511
512
                    }
                }
              else
                {
513
                  cerr << "Type mismatch for equation " << equation_ID+1  << "\n";
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
                  exit(EXIT_FAILURE);
                }
              output << ";\n";
              break;
            case SOLVE_BACKWARD_SIMPLE:
            case SOLVE_FORWARD_SIMPLE:
            case SOLVE_BACKWARD_COMPLETE:
            case SOLVE_FORWARD_COMPLETE:
              if (i < block_recursive)
                goto evaluation;
              feedback_variables.push_back(variable_ID);
              output << "  % equation " << equation_ID+1 << " variable : " << sModel
                     << " (" << variable_ID+1 << ") " << c_Equation_Type(equ_type) << endl;
              output << "  " << "residual(" << i+1-block_recursive << ") = (";
              goto end;
            default:
            end:
              output << tmp_output.str();
              output << ") - (";
533
              rhs->writeOutput(output, local_output_type, local_temporary_terms, {});
534
535
536
537
538
539
540
541
542
543
544
545
546
              output << ");\n";
            }
        }
      // The Jacobian if we have to solve the block
      if (simulation_type == SOLVE_BACKWARD_SIMPLE   || simulation_type == SOLVE_FORWARD_SIMPLE
          || simulation_type == SOLVE_BACKWARD_COMPLETE || simulation_type == SOLVE_FORWARD_COMPLETE)
        output << "  " << sps << "% Jacobian  " << endl;
      switch (simulation_type)
        {
        case SOLVE_BACKWARD_SIMPLE:
        case SOLVE_FORWARD_SIMPLE:
        case SOLVE_BACKWARD_COMPLETE:
        case SOLVE_FORWARD_COMPLETE:
547
          for (auto it = blocks_derivatives[block].begin(); it != (blocks_derivatives[block]).end(); it++)
548
549
550
551
552
            {
              unsigned int eq = it->first.first;
              unsigned int var = it->first.second;
              unsigned int eqr = getBlockEquationID(block, eq);
              unsigned int varr = getBlockVariableID(block, var);
553
              expr_t id = it->second.second;
554
              output << "    g1(" << eq+1-block_recursive << ", " << var+1-block_recursive << ") = ";
555
              id->writeOutput(output, local_output_type, local_temporary_terms, {});
556
              output << "; % variable=" << symbol_table.getName(symbol_table.getID(SymbolType::endogenous, varr))
557
558
559
560
561
562
563
564
                     << "(" << 0
                     << ") " << varr+1
                     << ", equation=" << eqr+1 << endl;
            }
          break;
        default:
          break;
        }
565
      output << "end" << endl;
566
567
568
      output.close();
    }
}
569
570

void
571
StaticModel::writeModelEquationsCode(const string &basename, map_idx_t map_idx) const
572
573
574
575
{

  ostringstream tmp_output;
  ofstream code_file;
576
  unsigned int instruction_number = 0;
577
578
  bool file_open = false;

579
580
581
  boost::filesystem::create_directories(basename + "/model/bytecode");

  string main_name = basename + "/model/bytecode/static.cod";
582
  code_file.open(main_name, ios::out | ios::binary | ios::ate);
583
584
  if (!code_file.is_open())
    {
585
      cerr << "Error : Can't open file \"" << main_name << "\" for writing" << endl;
586
587
588
589
590
      exit(EXIT_FAILURE);
    }
  int count_u;
  int u_count_int = 0;

591
  Write_Inf_To_Bin_File(basename + "/model/bytecode/static.bin", u_count_int, file_open, false, symbol_table.endo_nbr());
592
593
594
  file_open = true;

  //Temporary variables declaration
595
596
  FDIMST_ fdimst(temporary_terms.size());
  fdimst.write(code_file, instruction_number);
597
598
599
600
601
602
603
604
605
606
  FBEGINBLOCK_ fbeginblock(symbol_table.endo_nbr(),
                           SOLVE_FORWARD_COMPLETE,
                           0,
                           symbol_table.endo_nbr(),
                           variable_reordered,
                           equation_reordered,
                           false,
                           symbol_table.endo_nbr(),
                           0,
                           0,
607
608
                           u_count_int,
                           symbol_table.endo_nbr()
609
                           );
610
  fbeginblock.write(code_file, instruction_number);
611
612
613

  // Add a mapping form node ID to temporary terms order
  int j = 0;
614
615
  for (auto temporary_term : temporary_terms)
    map_idx[temporary_term->idx] = j++;
616
  compileTemporaryTerms(code_file, instruction_number, temporary_terms, map_idx, false, false);
617

618
  compileModelEquations(code_file, instruction_number, temporary_terms, map_idx, false, false);
619
620

  FENDEQU_ fendequ;
621
  fendequ.write(code_file, instruction_number);
622

623
624
625
626
627
628
  // Get the current code_file position and jump if eval = true
  streampos pos1 = code_file.tellp();
  FJMPIFEVAL_ fjmp_if_eval(0);
  fjmp_if_eval.write(code_file, instruction_number);
  int prev_instruction_number = instruction_number;

629
630
  vector<vector<pair<int, int>>> my_derivatives;
  my_derivatives.resize(symbol_table.endo_nbr());
631
  count_u = symbol_table.endo_nbr();
632
  for (const auto & first_derivative : derivatives[1])
633
    {
634
      int deriv_id = first_derivative.first[1];
635
      if (getTypeByDerivID(deriv_id) == SymbolType::endogenous)
636
        {
637
          expr_t d1 = first_derivative.second;
638
          unsigned int eq = first_derivative.first[0];
639
640
          int symb = getSymbIDByDerivID(deriv_id);
          unsigned int var = symbol_table.getTypeSpecificID(symb);
641
          FNUMEXPR_ fnumexpr(FirstEndoDerivative, eq, var);
642
          fnumexpr.write(code_file, instruction_number);
643
644
645
          if (!my_derivatives[eq].size())
            my_derivatives[eq].clear();
          my_derivatives[eq].emplace_back(var, count_u);
646

647
          d1->compile(code_file, instruction_number, false, temporary_terms, map_idx, false, false);
648
649

          FSTPSU_ fstpsu(count_u);
650
          fstpsu.write(code_file, instruction_number);
651
652
653
654
655
656
          count_u++;
        }
    }
  for (int i = 0; i < symbol_table.endo_nbr(); i++)
    {
      FLDR_ fldr(i);
657
      fldr.write(code_file, instruction_number);
658
      if (my_derivatives[i].size())
659
        {
660
661
          for (vector<pair<int, int>>::const_iterator it = my_derivatives[i].begin();
               it != my_derivatives[i].end(); it++)
662
            {
663
664
              FLDSU_ fldsu(it->second);
              fldsu.write(code_file, instruction_number);
665
              FLDSV_ fldsv{static_cast<int>(SymbolType::endogenous), static_cast<unsigned int>(it->first)};
666
              fldsv.write(code_file, instruction_number);
667
              FBINARY_ fbinary{static_cast<int>(BinaryOpcode::times)};
668
              fbinary.write(code_file, instruction_number);
669
              if (it != my_derivatives[i].begin())
670
                {
671
                  FBINARY_ fbinary{static_cast<int>(BinaryOpcode::plus)};
672
673
                  fbinary.write(code_file, instruction_number);
                }
674
            }
675
          FBINARY_ fbinary{static_cast<int>(BinaryOpcode::minus)};
676
          fbinary.write(code_file, instruction_number);
677
678
        }
      FSTPSU_ fstpsu(i);
679
      fstpsu.write(code_file, instruction_number);
680
    }
681
682
683
684
685
686
687
688
689
690
  // Get the current code_file position and jump = true
  streampos pos2 = code_file.tellp();
  FJMP_ fjmp(0);
  fjmp.write(code_file, instruction_number);
  // Set code_file position to previous JMPIFEVAL_ and set the number of instructions to jump
  streampos pos3 = code_file.tellp();
  code_file.seekp(pos1);
  FJMPIFEVAL_ fjmp_if_eval1(instruction_number - prev_instruction_number);
  fjmp_if_eval1.write(code_file, instruction_number);
  code_file.seekp(pos3);
691
  prev_instruction_number = instruction_number;
692
693
694
695
696
697
698

  temporary_terms_t tt2;
  tt2.clear();
  temporary_terms_t tt3;
  tt3.clear();

  // The Jacobian if we have to solve the block determinsitic bloc
699
  for (const auto & first_derivative : derivatives[1])
700
    {
701
      int deriv_id = first_derivative.first[1];
702
      if (getTypeByDerivID(deriv_id) == SymbolType::endogenous)
703
        {
704
          expr_t d1 = first_derivative.second;
705
          unsigned int eq = first_derivative.first[0];
706
707
708
709
          int symb = getSymbIDByDerivID(deriv_id);
          unsigned int var = symbol_table.getTypeSpecificID(symb);
          FNUMEXPR_ fnumexpr(FirstEndoDerivative, eq, var);
          fnumexpr.write(code_file, instruction_number);
710
711
712
          if (!my_derivatives[eq].size())
            my_derivatives[eq].clear();
          my_derivatives[eq].emplace_back(var, count_u);
713
714

          d1->compile(code_file, instruction_number, false, temporary_terms, map_idx, false, false);
715
          FSTPG2_ fstpg2(eq, var);
716
717
718
719
720
721
722
723
724
725
726
          fstpg2.write(code_file, instruction_number);
        }
    }

  // Set codefile position to previous JMP_ and set the number of instructions to jump
  pos1 = code_file.tellp();
  code_file.seekp(pos2);
  FJMP_ fjmp1(instruction_number - prev_instruction_number);
  fjmp1.write(code_file, instruction_number);
  code_file.seekp(pos1);

727
  FENDBLOCK_ fendblock;
728
  fendblock.write(code_file, instruction_number);
729
  FEND_ fend;
730
  fend.write(code_file, instruction_number);
731
732
733
734
  code_file.close();
}

void
735
StaticModel::writeModelEquationsCode_Block(const string &basename, map_idx_t map_idx, vector<map_idx_t> map_idx2) const
736
737
{
  struct Uff_l
738
  {
739
740
741
    int u, var, lag;
    Uff_l *pNext;
  };
742

743
744
745
746
747
748
749
750
751
  struct Uff
  {
    Uff_l *Ufl, *Ufl_First;
  };

  int i, v;
  string tmp_s;
  ostringstream tmp_output;
  ofstream code_file;
752
  unsigned int instruction_number = 0;
753
  expr_t lhs = nullptr, rhs = nullptr;
754
755
  BinaryOpNode *eq_node;
  Uff Uf[symbol_table.endo_nbr()];
756
  map<expr_t, int> reference_count;
757
  vector<int> feedback_variables;
758
  deriv_node_temp_terms_t tef_terms;
759
760
  bool file_open = false;

761
762
763
  boost::filesystem::create_directories(basename + "/model/bytecode");

  string main_name = basename + "/model/bytecode/static.cod";
764
  code_file.open(main_name, ios::out | ios::binary | ios::ate);
765
766
  if (!code_file.is_open())
    {
767
      cerr << "Error : Can't open file \"" << main_name << "\" for writing" << endl;
768
769
770
771
      exit(EXIT_FAILURE);
    }
  //Temporary variables declaration

772
773
  FDIMST_ fdimst(temporary_terms.size());
  fdimst.write(code_file, instruction_number);
774
775
776
777
778
779
780

  for (unsigned int block = 0; block < getNbBlocks(); block++)
    {
      feedback_variables.clear();
      if (block > 0)
        {
          FENDBLOCK_ fendblock;
781
          fendblock.write(code_file, instruction_number);
782
783
784
785
786
787
788
789
790
791
792
        }
      int count_u;
      int u_count_int = 0;
      BlockSimulationType simulation_type = getBlockSimulationType(block);
      unsigned int block_size = getBlockSize(block);
      unsigned int block_mfs = getBlockMfs(block);
      unsigned int block_recursive = block_size - block_mfs;

      if (simulation_type == SOLVE_TWO_BOUNDARIES_SIMPLE || simulation_type == SOLVE_TWO_BOUNDARIES_COMPLETE
          || simulation_type == SOLVE_BACKWARD_COMPLETE || simulation_type == SOLVE_FORWARD_COMPLETE)
        {
793
          Write_Inf_To_Bin_File_Block(basename, block, u_count_int, file_open);
794
795
796
797
798
799
800
801
802
803
804
805
806
          file_open = true;
        }

      FBEGINBLOCK_ fbeginblock(block_mfs,
                               simulation_type,
                               getBlockFirstEquation(block),
                               block_size,
                               variable_reordered,
                               equation_reordered,
                               blocks_linear[block],
                               symbol_table.endo_nbr(),
                               0,
                               0,
807
                               u_count_int,
808
                               /*symbol_table.endo_nbr()*/ block_size
809
                               );
810

811
      fbeginblock.write(code_file, instruction_number);
812

813
814
815
816
817
818
      // Get the current code_file position and jump if eval = true
      streampos pos1 = code_file.tellp();
      FJMPIFEVAL_ fjmp_if_eval(0);
      fjmp_if_eval.write(code_file, instruction_number);
      int prev_instruction_number = instruction_number;

819
820
821
      for (i = 0; i < (int) block_size; i++)
        {
          //The Temporary terms
822
          temporary_terms_t tt2;
823
824
825
          tt2.clear();
          if (v_temporary_terms[block].size())
            {
826
              for (auto it : v_temporary_terms[block][i])
827
                {
828
                  if (dynamic_cast<AbstractExternalFunctionNode *>(it) != nullptr)
829
                    it->compileExternalFunctionOutput(code_file, instruction_number, false, tt2, map_idx, false, false, tef_terms);
830

831
                  FNUMEXPR_ fnumexpr(TemporaryTerm, (int)(map_idx.find(it->idx)->second));
832
                  fnumexpr.write(code_file, instruction_number);
833
834
                  it->compile(code_file, instruction_number, false, tt2, map_idx, false, false, tef_terms);
                  FSTPST_ fstpst((int)(map_idx.find(it->idx)->second));
835
                  fstpst.write(code_file, instruction_number);
836
                  // Insert current node into tt2
837
                  tt2.insert(it);
838
839
840
                }
            }

841
          // The equations
842
843
844
845
846
847
848
849
          int variable_ID, equation_ID;
          EquationType equ_type;
          switch (simulation_type)
            {
            evaluation:
            case EVALUATE_BACKWARD:
            case EVALUATE_FORWARD:
              equ_type = getBlockEquationType(block, i);
850
851
              {
                FNUMEXPR_ fnumexpr(ModelEquation, getBlockEquationID(block, i));
852
                fnumexpr.write(code_file, instruction_number);
853
              }
854
855
              if (equ_type == E_EVALUATE)
                {
856
                  eq_node = (BinaryOpNode *) getBlockEquationExpr(block, i);
857
858
                  lhs = eq_node->get_arg1();
                  rhs = eq_node->get_arg2();
859
860
                  rhs->compile(code_file, instruction_number, false, temporary_terms, map_idx, false, false);
                  lhs->compile(code_file, instruction_number, true, temporary_terms, map_idx, false, false);
861
862
863
                }
              else if (equ_type == E_EVALUATE_S)
                {
864
                  eq_node = (BinaryOpNode *) getBlockEquationRenormalizedExpr(block, i);
865
866
                  lhs = eq_node->get_arg1();
                  rhs = eq_node->get_arg2();
867
868
                  rhs->compile(code_file, instruction_number, false, temporary_terms, map_idx, false, false);
                  lhs->compile(code_file, instruction_number, true, temporary_terms, map_idx, false, false);
869
870
871
872
873
874
875
876
877
                }
              break;
            case SOLVE_BACKWARD_COMPLETE:
            case SOLVE_FORWARD_COMPLETE:
              if (i < (int) block_recursive)
                goto evaluation;
              variable_ID = getBlockVariableID(block, i);
              equation_ID = getBlockEquationID(block, i);
              feedback_variables.push_back(variable_ID);
878
              Uf[equation_ID].Ufl = nullptr;
879
880
881
              goto end;
            default:
            end:
882
              FNUMEXPR_ fnumexpr(ModelEquation, getBlockEquationID(block, i));
883
              fnumexpr.write(code_file, instruction_number);
884
              eq_node = (BinaryOpNode *) getBlockEquationExpr(block, i);
885
886
              lhs = eq_node->get_arg1();
              rhs = eq_node->get_arg2();
887
888
              lhs->compile(code_file, instruction_number, false, temporary_terms, map_idx, false, false);
              rhs->compile(code_file, instruction_number, false, temporary_terms, map_idx, false, false);
889

890
              FBINARY_ fbinary{static_cast<int>(BinaryOpcode::minus)};
891
              fbinary.write(code_file, instruction_number);
892
893

              FSTPR_ fstpr(i - block_recursive);
894
              fstpr.write(code_file, instruction_number);
895
896
897
            }
        }
      FENDEQU_ fendequ;
898
      fendequ.write(code_file, instruction_number);
899

900
901
902
903
904
905
906
907
      // The Jacobian if we have to solve the block
      if    (simulation_type != EVALUATE_BACKWARD
             && simulation_type != EVALUATE_FORWARD)
        {
          switch (simulation_type)
            {
            case SOLVE_BACKWARD_SIMPLE:
            case SOLVE_FORWARD_SIMPLE:
908
909
              {
                FNUMEXPR_ fnumexpr(FirstEndoDerivative, 0, 0);
910
                fnumexpr.write(code_file, instruction_number);
911
              }
912
              compileDerivative(code_file, instruction_number, getBlockEquationID(block, 0), getBlockVariableID(block, 0), map_idx, temporary_terms);
913
              {
914
                FSTPG_ fstpg(0);
915
                fstpg.write(code_file, instruction_number);
916
              }
917
              break;
918

919
920
921
            case SOLVE_BACKWARD_COMPLETE:
            case SOLVE_FORWARD_COMPLETE:
              count_u = feedback_variables.size();
922
              for (auto it = blocks_derivatives[block].begin(); it != (blocks_derivatives[block]).end(); it++)
923
924
925
926
927
                {
                  unsigned int eq = it->first.first;
                  unsigned int var = it->first.second;
                  unsigned int eqr = getBlockEquationID(block, eq);
                  unsigned int varr = getBlockVariableID(block, var);
928
                  if (eq >= block_recursive && var >= block_recursive)
929
930
931
932
933
934
935
936
937
938
939
                    {
                      if (!Uf[eqr].Ufl)
                        {
                          Uf[eqr].Ufl = (Uff_l *) malloc(sizeof(Uff_l));
                          Uf[eqr].Ufl_First = Uf[eqr].Ufl;
                        }
                      else
                        {
                          Uf[eqr].Ufl->pNext = (Uff_l *) malloc(sizeof(Uff_l));
                          Uf[eqr].Ufl = Uf[eqr].Ufl->pNext;
                        }
940
                      Uf[eqr].Ufl->pNext = nullptr;
941
942
                      Uf[eqr].Ufl->u = count_u;
                      Uf[eqr].Ufl->var = varr;
943
                      FNUMEXPR_ fnumexpr(FirstEndoDerivative, eqr, varr);
944
                      fnumexpr.write(code_file, instruction_number);
945
                      compileChainRuleDerivative(code_file, instruction_number, eqr, varr, 0, map_idx, temporary_terms);
946
                      FSTPSU_ fstpsu(count_u);
947
                      fstpsu.write(code_file, instruction_number);
948
949
950
951
952
953
954
955
                      count_u++;
                    }
                }
              for (i = 0; i < (int) block_size; i++)
                {
                  if (i >= (int) block_recursive)
                    {
                      FLDR_ fldr(i-block_recursive);
956
                      fldr.write(code_file, instruction_number);
957
958

                      FLDZ_ fldz;
959
                      fldz.write(code_file, instruction_number);
960
961
962
963
964

                      v = getBlockEquationID(block, i);
                      for (Uf[v].Ufl = Uf[v].Ufl_First; Uf[v].Ufl; Uf[v].Ufl = Uf[v].Ufl->pNext)
                        {
                          FLDSU_ fldsu(Uf[v].Ufl->u);
965
                          fldsu.write(code_file, instruction_number);
966
                          FLDSV_ fldsv{static_cast<int>(SymbolType::endogenous), static_cast<unsigned int>(Uf[v].Ufl->var)};
967
                          fldsv.write(code_file, instruction_number);
968

969
                          FBINARY_ fbinary{static_cast<int>(BinaryOpcode::times)};
970
                          fbinary.write(code_file, instruction_number);
971
972

                          FCUML_ fcuml;
973
                          fcuml.write(code_file, instruction_number);
974
975
976
977
978
979
980
981
                        }
                      Uf[v].Ufl = Uf[v].Ufl_First;
                      while (Uf[v].Ufl)
                        {
                          Uf[v].Ufl_First = Uf[v].Ufl->pNext;
                          free(Uf[v].Ufl);
                          Uf[v].Ufl = Uf[v].Ufl_First;
                        }
982
                      FBINARY_ fbinary{static_cast<int>(BinaryOpcode::minus)};
983
                      fbinary.write(code_file, instruction_number);
984
985

                      FSTPSU_ fstpsu(i - block_recursive);
986
                      fstpsu.write(code_file, instruction_number);
987
988
989
990
991
992
993
994

                    }
                }
              break;
            default:
              break;
            }
        }
995
996
997
998
999
1000

      // Get the current code_file position and jump = true
      streampos pos2 = code_file.tellp();
      FJMP_ fjmp(0);
      fjmp.write(code_file, instruction_number);
      // Set code_file position to previous JMPIFEVAL_ and set the number of instructions to jump