.. _program_listing_file_lib_printing.cpp:

Program Listing for File printing.cpp
=====================================

|exhale_lsh| :ref:`Return to documentation for file <file_lib_printing.cpp>` (``lib/printing.cpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #include "AnalysisGraph.hpp"
   #include <boost/range/algorithm/for_each.hpp>
   
   using namespace std;
   using fmt::print;
   
   
   /*
    ============================================================================
    Public: Printing
    ============================================================================
   */
   
   void AnalysisGraph::print_nodes() {
     print("Vertex IDs and their names in the CAG\n");
     print("Vertex ID : Name\n");
     print("--------- : ----\n");
     for_each(this->node_indices(), [&](int v) {
       cout << v << "         " << this->graph[v].name << endl;
     });
   
     print("Independent nodes\n");
     for (int v : this->head_nodes) {
       cout << v << "         " << this->graph[v].name << endl;
     }
   
     print("Dependent nodes\n");
     for (int v : this->body_nodes) {
       cout << v << "         " << this->graph[v].name << endl;
     }
   }
   
   void AnalysisGraph::print_edges() {
     for_each(edges(), [&](auto e) {
       cout << "(" << (*this)[boost::source(e, this->graph)].name << ", "
            << (*this)[boost::target(e, this->graph)].name << ")" << " - "
            << (this->graph[e].is_frozen()
                           ? "Frozen at " + to_string(this->graph[e].get_theta())
                           : "Free") << endl;
     });
   }
   
   void AnalysisGraph::print_name_to_vertex() {
     for (auto [name, vert] : this->name_to_vertex) {
       cout << name << " -> " << vert << endl;
     }
     cout << endl;
   }
   
   void AnalysisGraph::print_indicators() {
     cout << "-----Indicators-----\n";
     cout << "Indicators attached to nodes\n";
     for (int v : this->node_indices()) {
       cout << v << ":" << (*this)[v].name << endl;
       for (auto [name, vert] : (*this)[v].nameToIndexMap) {
         cout << "\t"
              << "indicator " << vert << ": " << name << endl;
       }
     }
   
     cout << "\nIndicators in CAG \n";
     for (string ind : this->indicators_in_CAG) {
         cout << "indicator: " << ind << endl;
     }
   }
   
   void AnalysisGraph::print_A_beta_factors() {
     int num_verts = this->num_vertices();
   
     for (int row = 0; row < num_verts; ++row) {
       for (int col = 0; col < num_verts; ++col) {
         cout << endl << "Printing cell: (" << row << ", " << col << ") " << endl;
         if (this->A_beta_factors[row][col]) {
           this->A_beta_factors[row][col]->print_beta2product();
         }
       }
     }
   }
   
   void AnalysisGraph::print_latent_state(const Eigen::VectorXd& v) {
     for (int i=0; i < this->num_vertices(); i++){
       cout << (*this)[i].name << " " << v[2*i] << endl;
     }
   }
   
   void AnalysisGraph::print_all_paths() {
     int num_verts = this->num_vertices();
   
   //  if (this->A_beta_factors.size() != num_verts ||
   //      this->A_beta_factors[0].size() != num_verts) {
   //    this->find_all_paths();
   //  }
     this->find_all_paths();
   
     cout << "All the simple paths of:" << endl;
   
     for (int row = 0; row < num_verts; ++row) {
       for (int col = 0; col < num_verts; ++col) {
         if (this->A_beta_factors[row][col]) {
           this->A_beta_factors[row][col]->print_paths();
         }
       }
     }
   }
   
   // Given an edge (source, target vertex ids - i.e. a β ≡ ∂target/∂source),
   // print all the transition matrix cells that are dependent on it.
   void AnalysisGraph::print_cells_affected_by_beta(int source, int target) {
     typedef multimap<pair<int, int>, pair<int, int>>::iterator MMapIterator;
   
     pair<int, int> beta = make_pair(source, target);
   
     pair<MMapIterator, MMapIterator> beta_dept_cells =
         this->beta2cell.equal_range(beta);
   
     cout << endl
          << "Cells of A affected by beta_(" << source << ", " << target << ")"
          << endl;
   
     for (MMapIterator it = beta_dept_cells.first; it != beta_dept_cells.second;
          it++) {
       cout << "(" << it->second.first * 2 << ", " << it->second.second * 2 + 1
            << ") ";
     }
     cout << endl;
   }
   
   void AnalysisGraph::print_training_range() {
       std::cout << "ID         : " << this->id << std::endl;
       std::cout << "Start year : " << this->training_range.first.first << std::endl;
       std::cout << "Start month: " << this->training_range.first.second << std::endl;
       std::cout << "End year   : " << this->training_range.second.first << std::endl;
       std::cout << "End month  : " << this->training_range.second.second << std::endl;
   }
   
   void AnalysisGraph::print_MAP_estimate() {
       if (this->MAP_sample_number < 0) {
           cout << "\n\nModel " << this->id << " is not trained.\n";
           cout << "\tCould not print the MAP estimate.\n\n";
           return;
       }
   
       cout << "\n\nMAP estimate sample number: " << this->MAP_sample_number << endl;
       cout << "\n\nMAP log-likelihood: " << this->log_likelihood_MAP << endl;
   
       cout << "\nInitial derivatives:\n";
       for (int v = 0; v < this->num_vertices(); v++) {
           Node &n = (*this)[v];
           cout << this->initial_latent_state_collection
                             [this->MAP_sample_number](2 * v + 1);
           cout << " : " << n.name << endl;
       }
   
       cout << "\nEdge weights:\n";
       for (EdgeDescriptor e : this->edges()) {
           cout <<this->graph[e].sampled_thetas[this->MAP_sample_number];
           cout << " : (" << (*this)[boost::source(e, this->graph)].name << ", "
                << (*this)[boost::target(e, this->graph)].name << ")" << " - "
                << (this->graph[e].is_frozen()
                        ? "Frozen at " + to_string(this->graph[e].get_theta())
                        : "Free") << endl;
       }
   }