real_weighted_undirected_graph.hpp

Go to the documentation of this file.

#ifndef REAL_WEIGHTED_UNDIRECTED_GRAPH_HPP_INCLUDED
#define REAL_WEIGHTED_UNDIRECTED_GRAPH_HPP_INCLUDED

// Standard Library
#include <ctime>     // time, gmtime
#include <cstdlib>   // abort
#include <fstream>
#include <iostream>
#include <map>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <vector>
#include <utility>   // swap
// Graph C++ Library
#include "base_weighted_undirected_graph.hpp"
#include "real_weighted_undirected_vertex.hpp"

namespace gcl
{

  class real_weighted_undirected_graph : public gcl::base_weighted_undirected_graph<gcl::real_weighted_undirected_vertex>
  {
    // ============================================================================================
    // *** Member functions.
    public:
      real_weighted_undirected_graph();                   
      ~real_weighted_undirected_graph() {}                
      void read_edgelist(std::string _name);              
      void write_graph_properties(std::string _name);     
      void write_vertices_properties(std::string _name);  
      void clear();                                       
  };

} // End of namespace gcl.



// ================================================================================================
// ================================================================================================
gcl::real_weighted_undirected_graph::real_weighted_undirected_graph()
{
  clear();
}

// ================================================================================================
// ================================================================================================
void gcl::real_weighted_undirected_graph::read_edgelist(std::string _name)
{
  // Stream objects.
  std::ifstream edgelist_file;
  std::stringstream one_line;
  // String objects.
  std::string full_line, name1_str, name2_str, weight_str;
  // Integer objects.
  unsigned int node_cnt, edge_cnt, node1_int, node2_int, edge_int;
  // Double objects.
  double weight_dbl;
  // Map objects to assure the uniqueness of edges.
  std::map< std::string, unsigned int > Name2ID;
  std::map< unsigned int, std::string > ID2Name;
  std::set< std::tuple<unsigned int, unsigned int, double> > Edgelist;
  // Iterator objects.
  std::map< std::string,unsigned int >::iterator                        name_it;
  std::set< std::tuple<unsigned int, unsigned int, double> >::iterator  edge_it, edge_end;
  // Opens the stream and aborts if the operation did not succeed.
  edgelist_file.open(_name.c_str(), std::ios_base::in);
  if( !edgelist_file.is_open() )
  {
    std::cout << "Could not open file: " << _name << "." << std::endl;
    abort();
  }
  // Reads the edgelist and registers the nodes and the edges.
  node_cnt = 0;
  edge_cnt = 0;
  while( !edgelist_file.eof() )
  {
    // Reads a line of the edgelist.
    std::getline(edgelist_file,full_line); edgelist_file >> std::ws;
    one_line.str(full_line); one_line >> std::ws;
    one_line >> name1_str  >> std::ws;
    one_line >> name2_str  >> std::ws;
    one_line >> weight_str >> std::ws;
    one_line.clear();
    // Is name1 new?
    name_it = Name2ID.find(name1_str);
    if( name_it == Name2ID.end() )
    {
      Name2ID[name1_str] = node_cnt;
      ID2Name[node_cnt]  = name1_str;
      node1_int = node_cnt;
      ++node_cnt;
    }
    else
    {
      node1_int = name_it->second;
    }
    // Is name2 new?
    name_it = Name2ID.find(name2_str);
    if( name_it == Name2ID.end() )
    {
      Name2ID[name2_str] = node_cnt;
      ID2Name[node_cnt]  = name2_str;
      node2_int = node_cnt;
      ++node_cnt;
    }
    else
    {
      node2_int = name_it->second;
    }
    // Is this a new edge? (excludes self- and multi- edges).
    if(node1_int < node2_int)
    {
      std::swap(node1_int,node2_int);
    }
    if(node1_int != node2_int)
    {
      weight_dbl = std::atof(weight_str.c_str());
      edge_it = Edgelist.find( std::make_tuple(node1_int,node2_int, weight_dbl) );
      if( edge_it == Edgelist.end() )
      {
        // Registers this new edge.
        Edgelist.insert( std::make_tuple(node1_int,node2_int,weight_dbl) );
        ++edge_cnt;
      }
    }
  }
  // Sets the number of vertices and edges.
  this->set_nb_vertices(node_cnt);
  this->set_nb_edges(edge_cnt);
  // Populates the graph.
  edge_it  = Edgelist.begin();
  edge_end = Edgelist.end();
  for(unsigned int n(0), nn(this->get_nb_vertices()); n<nn; ++n)
  {
    // Sets the id of the vertex.
    (*this)(n)->set_name(ID2Name[n]); 
  }
  for(; edge_it!=edge_end; ++edge_it)
  {
    // Finds the vertices' identity.
    node1_int  = std::get<0>(*edge_it);
    node2_int  = std::get<1>(*edge_it);
    weight_dbl = std::get<2>(*edge_it);
    // Creates the edge.
    (*this)(node1_int)->neighbour_insert(gcl::weighted_edge(node2_int,weight_dbl));
    (*this)(node2_int)->neighbour_insert(gcl::weighted_edge(node1_int,weight_dbl));
  }
  // Closes the stream.
  edgelist_file.close();
}

// ================================================================================================
// ================================================================================================
void gcl::real_weighted_undirected_graph::write_graph_properties(std::string _name)
{
  // Streams objects.
  std::ofstream graph_properties_file;
  // String objects.
  std::string graph_properties_filename = _name + "_graph_properties.dat";
  // Opens the stream and aborts if the operation did not succeed.
  graph_properties_file.open(graph_properties_filename.c_str(), std::ios_base::out);
  if( !graph_properties_file.is_open() )
  {
    std::cout << "Could not open file: " << _name << "." << std::endl;
    abort();
  }
  // Gets the current date/time.
  time_t theTime = time(NULL);
  struct tm *aTime = gmtime(&theTime);
  int year    = aTime->tm_year + 1900;
  int month   = aTime->tm_mon + 1;
  int day     = aTime->tm_mday;
  int hours   = aTime->tm_hour;
  int minutes = aTime->tm_min;
  // Writes the properties of the graph.
  graph_properties_file << "==================================================================================="                       << std::endl;
  graph_properties_file << "General information."                                                                                      << std::endl;
  graph_properties_file << "type of graph:  "          << this->get_type_of_graph()                                                    << std::endl;
  graph_properties_file << "graph:          "          << _name                                                                        << std::endl;
  graph_properties_file << "computed on:    "          << year << "/";
  if(month < 10)
    graph_properties_file << "0";
  graph_properties_file << month << "/";
  if(day < 10)
    graph_properties_file << "0";
  graph_properties_file << day << " " << hours << ":";
  if(minutes < 10)
    graph_properties_file << "0";
  graph_properties_file << minutes << " UTC"                                                                                           << std::endl;
  graph_properties_file << "==================================================================================="                       << std::endl;
  graph_properties_file << "Observables (excluding zero-degree vertices)"                                                              << std::endl;
  graph_properties_file << "Number of nodes:                          " << this->get_nb_vertices()-this->get_nb_zerodegree_vertices()  << std::endl;
  graph_properties_file << "Number of edges:                           " << this->get_nb_edges()                                       << std::endl;
  graph_properties_file << "Number of wedges:                          " << this->get_nb_wedges()                                      << std::endl;
  graph_properties_file << "Number of triangles:                       " << this->get_nb_triangles()                                   << std::endl;
  graph_properties_file << "Global clustering coefficient:             " << this->get_global_clustering_coefficient()                  << std::endl;
  graph_properties_file << "Average local clustering coefficient:      " << this->get_avg_local_clustering_coefficient()               << std::endl;
  graph_properties_file << "Degree distribution"                                                                                       << std::endl;
  graph_properties_file << "  - average degree:                        " << this->get_avg_degree()                                     << std::endl;
  graph_properties_file << "  - minimum degree (excluding zero):       " << this->get_min_degree()                                     << std::endl;
  graph_properties_file << "  - maximum degree:                        " << this->get_max_degree()                                     << std::endl;
  graph_properties_file << "Strength distribution"                                                                                     << std::endl;
  graph_properties_file << "  - average strength:                      " << this->get_avg_strength()                                   << std::endl;
  graph_properties_file << "  - minimum strength:                      " << this->get_min_strength()                                   << std::endl;
  graph_properties_file << "  - maximum strength:                      " << this->get_max_strength()                                   << std::endl;
  graph_properties_file << "Weight distribution"                                                                                       << std::endl;
  graph_properties_file << "  - average weight:                        " << this->get_avg_weight()                                     << std::endl;
  graph_properties_file << "  - minimum weight:                        " << this->get_min_weight()                                     << std::endl;
  graph_properties_file << "  - maximum weight:                        " << this->get_max_weight()                                     << std::endl;
  // Closes the stream.
  graph_properties_file.close();
}

// ================================================================================================
// ================================================================================================
void gcl::real_weighted_undirected_graph::write_vertices_properties(std::string _name)
{
  // Streams objects.
  std::ofstream vertices_properties_file;
  // String objects.  
  std::string vertices_properties_filename = _name + "_vertices_properties.dat";
  // Opens the stream and aborts if the operation did not succeed.
  vertices_properties_file.open(vertices_properties_filename.c_str(), std::ios_base::out);
  if( !vertices_properties_file.is_open() )
  {
    std::cout << "Could not open file: " << _name << "." << std::endl;
    abort();
  }
  // Writes the properties of each vertex.
  vertices_properties_file.precision(8);
  for(unsigned int n(0), nn(this->get_nb_vertices()); n<nn; ++n)
  {
    vertices_properties_file << std::fixed << (*this)(n)->get_name()                          << "  ";
    vertices_properties_file << std::fixed << (*this)(n)->get_degree()                        << "  ";
    vertices_properties_file << std::fixed << (*this)(n)->get_strength()                      << "  ";
    vertices_properties_file << std::fixed << (*this)(n)->get_nb_triangles()                  << "  ";
    vertices_properties_file << std::fixed << (*this)(n)->get_local_clustering_coefficient()  << std::endl;
  }
  // Closes the stream.
  vertices_properties_file.close();
}

// ================================================================================================
// ================================================================================================
void gcl::real_weighted_undirected_graph::clear()
{
  // Reintializes the variables inherited from the class base_undirected_graph.
  base_undirected_graph_clear();
  // Sets the type of the graph.
  this->set_type_of_graph("Real undirected graph");
}



#endif // REAL_WEIGHTED_UNDIRECTED_GRAPH_HPP_INCLUDED