.. _program_listing_file_lib_format_output.cpp:

Program Listing for File format_output.cpp
==========================================

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

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

.. code-block:: cpp

   #include "AnalysisGraph.hpp"
   
   CredibleIntervals
   AnalysisGraph::get_credible_interval(Predictions preds) {
     CredibleIntervals cis;
       // The calculation of the 95% confidence interval about the median is
       // taken from:
       // https://www.ucl.ac.uk/child-health/short-courses-events/ \
       //     about-statistical-courses/research-methods-and-statistics/chapter-8-content-8
       int n = this->res;
       int lower_rank = int((n - 1.96 * sqrt(n)) / 2);
       int upper_rank = int((2 + n + 1.96 * sqrt(n)) / 2);
       int middle = n / 2;
       bool n_is_odd = (n % 2 == 1);
   
       lower_rank = lower_rank < 0 ? 0 : lower_rank;
       upper_rank = upper_rank >= n ? n-1 : upper_rank;
   
       for (auto [ind_name, ind_preds] : preds) {
           std::unordered_map<std::string, std::vector<double>> ind_cis;
   
           for (int ts = 0; ts < this->pred_timesteps; ts++) {
   
               sort(ind_preds[ts].begin(), ind_preds[ts].end());
               double median_value = n_is_odd ? ind_preds[ts][middle]
                   : (ind_preds[ts][middle] + ind_preds[ts][middle - 1]) / 2.0;
               double lower_limit = ind_preds[ts][lower_rank];
               double upper_limit = ind_preds[ts][upper_rank];
   
               ind_cis["Median"].push_back(median_value);
               ind_cis["Upper 95% CI"].push_back(upper_limit);
               ind_cis["Lower 95% CI"].push_back(lower_limit);
           }
           cis[ind_name] = ind_cis;
       }
       return cis;
   }
   
   CompleteState AnalysisGraph::get_complete_state() {
       ConceptIndicators concept_indicators;
       Edges edges;
       Adjectives adjectives;
       Polarities polarities;
       Thetas thetas;
       Derivatives derivatives;
       Predictions predictions;
       Data data_set;
   
       for (int v : this->node_indices()) {
           for (auto [ind_name, vert] : (*this)[v].nameToIndexMap) {
               concept_indicators[(*this)[v].name].push_back(ind_name);
           }
       }
   
       for (auto e : this->edges()) {
           const Node& s = this->source(e);
           const Node& t = this->target(e);
   
           const Statement& stmt_0 = this->graph[e].evidence[0];
           const Event& subject = stmt_0.subject;
           const Event& object = stmt_0.object;
   
           std::string subj_adjective = subject.adjective;
           std::string obj_adjective = object.adjective;
   
           int subj_polarity = subject.polarity;
           int obj_polarity = object.polarity;
   
           edges.push_back(std::make_pair(s.name, t.name));
           adjectives.push_back(std::make_pair(subj_adjective, obj_adjective));
           polarities.push_back(std::make_pair(subj_polarity, obj_polarity));
   
           std::unordered_map<std::string, std::vector<double>> prior;
           std::unordered_map<std::string, std::vector<double>> sampled_thetas;
           prior["Prior"] = this->graph[e].kde.dataset;
           sampled_thetas["Sampled Thetas"] = this->graph[e].sampled_thetas;
   
   //        thetas.push_back(std::make_pair(this->graph[e].kde.dataset, this->graph[e].sampled_thetas));
           thetas.push_back(std::make_tuple(this->graph[e].kde.dataset, this->graph[e].sampled_thetas, this->graph[e].kde.log_prior_hist));
       }
   
       for (auto [vert_name, vert_id] : this->name_to_vertex) {
           for (int samp = 0; samp < this->res; samp++) {
               derivatives[vert_name].push_back(this->initial_latent_state_collection[samp](vert_id * 2 + 1));
           }
       }
       /*
       int year = this->training_range.first.first;
       int month = this->training_range.first.second;
       int num_data_points =
           this->calculate_num_timesteps(this->training_range.first.first,
                   this->training_range.first.second,
                   this->training_range.second.first,
                   this->training_range.second.second);
       std::vector<std::string> data_range;
   
       for (int t = 0; t < num_data_points ; t++) {
           data_range.push_back(std::to_string(year) + "-" + std::to_string(month));
   
           if (month == 12) {
               year++;
               month = 1;
           }
           else {
               month++;
           }
       }
       */
       for (auto [vert_name, vert_id] : this->name_to_vertex) {
           for (auto [ind_name, ind_id] : (*this)[vert_id].nameToIndexMap) {
               std::unordered_map<int, std::vector<double>> preds;
               std::unordered_map<std::string, std::vector<double>> data;
   
               for (int ts = 0; ts < this->pred_timesteps; ts++) {
                   for (int samp = 0; samp < this->res; samp++) {
                       preds[ts].push_back(this-> 
                               predicted_observed_state_sequences[samp][ts][vert_id]
                               [ind_id]);
                   }
               }
               predictions[ind_name] = preds;
   
               //for (int ts = 0; ts < this->n_timesteps; ts++) {
               for (int ts = 0; ts < this->observed_state_sequence.size(); ts++) {
                   if (this->observed_state_sequence[ts][vert_id].empty()) {
                       // This concept has no indicator specified in the create-model
                       // call
                       continue;
                   }
                   for (double obs : this->observed_state_sequence[ts][vert_id][ind_id]) {
                       data["Time Step"].push_back(ts);
                       data["Data"].push_back(obs);
                   }
               }
               data_set[ind_name] = data;
           }
       }
   
       //std::vector<long> data_range(this->n_timesteps);
       std::vector<long> data_range(this->observed_state_sequence.size());
       double timestep = 0;
       //for (int ts = 0; ts < this->n_timesteps; ts++) {
       for (int ts = 0; ts < this->observed_state_sequence.size(); ts++) {
           timestep += this->modeling_timestep_gaps[ts];
           //data_range[ts] = this->train_start_epoch +
           //                timestep * this->num_modeling_timesteps_per_one_observation_timestep;
           data_range[ts] = timestep;
       }
   
       std::vector<double> prediction_range(this->pred_timesteps);
   
       for (int ts = 0; ts < this->pred_timesteps; ts++) {
         //prediction_range[ts] = this->train_start_epoch + (this->pred_start_timestep + ts * this->delta_t) * this->num_modeling_timesteps_per_one_observation_timestep;
         prediction_range[ts] = this->pred_start_timestep + ts * this->delta_t;
       }
   
       CredibleIntervals cis = get_credible_interval(predictions);
   
       //return std::make_tuple(concept_indicators, edges, adjectives, polarities, thetas, derivatives, data_range, data_set, this->pred_range, predictions, cis);
       return std::make_tuple(concept_indicators, edges, adjectives, polarities, thetas, derivatives, data_range, data_set, prediction_range, predictions, cis, this->log_likelihoods, this->n_kde_kernels);
   }