base_weighted_undirected_graph.hpp

Go to the documentation of this file.

#ifndef BASE_WEIGHTED_UNDIRECTED_GRAPH_HPP_INCLUDED
#define BASE_WEIGHTED_UNDIRECTED_GRAPH_HPP_INCLUDED

// Standard Library
#include <algorithm> // set_intersection
#include <cstdlib>   // abort
#include <iostream>
#include <list>
#include <set>
#include <string>
#include <vector>
// Graph C++ Library
#include "base_undirected_graph.hpp"

namespace gcl
{

  template <class VertexType>
  class base_weighted_undirected_graph : public gcl::base_undirected_graph<VertexType>
  {
    // ============================================================================================
    // *** Information about the graph.
    private:
      // std::vector<double> strength_distribution;                      ///< Distribution of the strength of vertices.
      double min_strength;                                            
      double max_strength;                                            
      double avg_strength;                                            
      // std::vector<double> weight_distribution;                        ///< Distribution of the weights of edges.
      double min_weight;                                              
      double max_weight;                                              
      double avg_weight;                                              
    // ============================================================================================
    // *** Member functions.
    public:
      base_weighted_undirected_graph() {}                             
      virtual ~base_weighted_undirected_graph() {}                    
      double  get_min_strength();                                     
      double  get_max_strength();                                     
      double  get_avg_strength();                                     
      double  get_min_weight();                                       
      double  get_max_weight();                                       
      double  get_avg_weight();                                       
      void write_edgelist(std::string _name);                         
      void analyse_structural_properties();                           
      void survey_strength_distribution();                            
      void survey_weight_distribution();                              
      virtual void write_graph_properties(std::string _name) = 0;     
      virtual void write_vertices_properties(std::string _name) = 0;  
    protected:
      void base_weighted_undirected_graph_clear();                    
  };

} // End of namespace gcl.



// ================================================================================================
// ================================================================================================
template <class VertexType>
double gcl::base_weighted_undirected_graph<VertexType>::get_min_strength()
{
  return min_strength;
}

// ================================================================================================
// ================================================================================================
template <class VertexType>
double gcl::base_weighted_undirected_graph<VertexType>::get_max_strength()
{
  return max_strength;
}

// ================================================================================================
// ================================================================================================
template <class VertexType>
double gcl::base_weighted_undirected_graph<VertexType>::get_avg_strength()
{
  return avg_strength;
}

// ================================================================================================
// ================================================================================================
template <class VertexType>
double gcl::base_weighted_undirected_graph<VertexType>::get_min_weight()
{
  return min_weight;
}

// ================================================================================================
// ================================================================================================
template <class VertexType>
double gcl::base_weighted_undirected_graph<VertexType>::get_max_weight()
{
  return max_weight;
}

// ================================================================================================
// ================================================================================================
template <class VertexType>
double gcl::base_weighted_undirected_graph<VertexType>::get_avg_weight()
{
  return avg_weight;
}

// ================================================================================================
// ================================================================================================
template <class VertexType>
void gcl::base_weighted_undirected_graph<VertexType>::write_edgelist(std::string _name)
{
  // Stream objects.
  std::ofstream edgelist_file;
  // String objects.
  std::string edgelist_filename = _name + "_edgelist.dat";
  std::string node1_str;
  // Operator objects.
  typename VertexType::iterator it, end;
  // Opens the stream and aborts if the operation did not succeed.
  edgelist_file.open(edgelist_filename.c_str(), std::ios_base::out);
  if( !edgelist_file.is_open() )
  {
    std::cout << "Could not open file: " << edgelist_filename << "." << std::endl;
    abort();
  }
  // Writes each edges in the format "node1 node2". Each edge appears once.
  for(unsigned int node1(0), node2, nn(this->get_nb_vertices()); node1<nn; ++node1)
  {
    // Browses the neighbours of node1.
    it  = (*this)(node1)->neighbour_begin();
    end = (*this)(node1)->neighbour_end();
    node1_str = (*this)(node1)->get_name();
    for(; it!=end; ++it)
    {
      node2 = it->id;
      if(node1 < node2) // Ensures that undirected edges appear only once (excludes self-edges).
      {
        edgelist_file << node1_str << "  " << (*this)(node2)->get_name() << "  " << it->weight << std::endl;
      }
    }
  }
  // Closes the stream.
  edgelist_file.close();
}

// ================================================================================================
// ================================================================================================
template <class VertexType>
void gcl::base_weighted_undirected_graph<VertexType>::analyse_structural_properties()
{
  // Degree distributions (in- and out- degrees).
  this->survey_degrees_distribution();
  // Identifies the triangles.
  this->survey_triangles();
  // Computes the clustering coefficients.
  this->compute_clustering_coefficients();
  // Surveys the strength distribution.
  this->survey_strength_distribution();
  // Surveys the weight distribution.
  this->survey_weight_distribution();
}

// ================================================================================================
// ================================================================================================
template <class VertexType>
void gcl::base_weighted_undirected_graph<VertexType>::survey_strength_distribution()
{
  // Double objects.
  double s;
  // Resizes and sets the initial values of min_strength, max_strength and avg_strength.
  min_strength = this->get_nb_vertices();
  max_strength = 0;
  avg_strength = 0;
  // Sets the average, maximal and minimal strength.
  for(unsigned int n(0), nn(this->get_nb_vertices()); n<nn; ++n)
  {
    // Gets the strength of the vertex n.
    s = (*this)(n)->get_strength();
    // Average strength (1 of 2). 
    avg_strength += s;
    // Maximal and minimal strength.
    if(s < min_strength)
      min_strength = s;
    if(s > max_strength)
      max_strength = s;
  }
  // Average strength (2 of 2).
  avg_strength /= this->get_nb_vertices();
}

// ================================================================================================
// ================================================================================================
template <class VertexType>
void gcl::base_weighted_undirected_graph<VertexType>::survey_weight_distribution()
{
  // Double objects.
  double w;
  // Iterator objects.
  typename VertexType::iterator it, end;
  // Resizes and sets the initial values of min_weight, max_weight and avg_weight.
  min_weight = this->get_nb_vertices();
  max_weight = 0;
  avg_weight = 0;
  // Sets the average, maximal and minimal weight.
  for(unsigned int v1(0), v2, nn(this->get_nb_vertices()); v1<nn; ++v1)
  {
    // Sets the iterator objects.
    it  = (*this)(v1)->neighbour_begin();
    end = (*this)(v1)->neighbour_end();
    // Loops over all neighbours of vertex n.
    for(; it!=end; ++it)
    {
      // Gets the id of the neighbour.
      v2 = it->id;
      // Considers the edge only if v2 > v1 (ensures to count each edge only once).
      if( v2 > v1 )
      {
        // Gets the weight of the edge.
        w = it->weight;
        // Average weight (1 of 2). 
        avg_weight += w;
        // Maximal and minimal weight.
        if(w < min_weight)
          min_weight = w;
        if(w > max_weight)
          max_weight = w;
      }
    }
  }
  // Average weight (2 of 2).
  avg_weight /= this->get_nb_edges();
}

// ================================================================================================
// ================================================================================================
template <class VertexType>
void gcl::base_weighted_undirected_graph<VertexType>::base_weighted_undirected_graph_clear()
{
  // Resets the variables inherited from base_graph.
  this->base_undirected_graph_clear();
  // Resets the strength distribution and related quantities.
  // strength_distribution.clear();
  min_strength = 0;
  max_strength = 0;
  avg_strength = 0;
  // Resets the weight distribution and related quantities.
  // weight_distribution.clear();
  min_weight = 0;
  max_weight = 0;
  avg_weight = 0;
}



#endif // BASE_WEIGHTED_UNDIRECTED_GRAPH_HPP_INCLUDED