Ticket #8250: bgl_in_edges.cpp

// Copyright (C) 2007-2008 The Trustees of Indiana University.

// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)

#include <boost/config.hpp>
#include <boost/throw_exception.hpp>
#include <boost/mpl/print.hpp>
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/iteration_macros.hpp>
#include <boost/test/minimal.hpp>
#include <boost/graph/graphviz.hpp>
#include <boost/graph/graphml.hpp>
#include <boost/graph/erdos_renyi_generator.hpp>
#include <boost/graph/random.hpp>
#include <boost/random/uniform_real.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/property_map/property_map.hpp>
#include <string>
#include <iostream>

#include <boost/graph/iteration_macros.hpp>
#include <boost/graph/rmat_graph_generator.hpp>
#include <boost/random/linear_congruential.hpp>

#include <boost/graph/metis.hpp>

#ifdef BOOST_NO_EXCEPTIONS
void
boost::throw_exception(std::exception const& ex)
{
    std::cout << ex.what() << std::endl;
    abort();
}
#endif

using namespace boost;
using namespace std;

/// VertexProperties structure to be attached to each vertex
struct VertexProperties {
  VertexProperties() {
        cash = 100;
        goods = 10;
        price = 0.1;
 }


  double cash;
  double goods;
  double price;

};

struct EdgeProperties {

  EdgeProperties() {
        cash = 0;
        goods = 0;
        index = 0;
  }

  EdgeProperties(size_t i, double c, double g) : index(i), cash(c), goods(g) { }

public:
  std::size_t index;
  double cash;
  double goods;



};


  double lambda = 0.2;
  double mu = 0.3;
  double tau = 10;
  double eps = 0.01;

typedef boost::adjacency_list<vecS,
                       vecS,
                       bidirectionalS, VertexProperties, EdgeProperties> Graph;


typedef graph_traits<Graph>::vertex_descriptor Vertex;
typedef graph_traits<Graph>::edge_descriptor Edge;



template<typename GMap, typename PMap, typename Graph>
class Remover
{
public:
        Remover(const double min, const GMap& egoods, const PMap& price, const Graph& graph)
        : m_min(min), m_egoods(egoods), m_price(price), m_graph(graph) {}

        template<typename ED>
        bool operator()(ED w) const {
                return m_price[target(w, m_graph)] > tau * m_min || m_egoods[w] < eps;
        }

private:
        const Graph&    m_graph;
        const GMap&     m_egoods;
        const PMap&     m_price;
        const double    m_min;
};

template<typename Graph>
class Remover_1
{
public:
        Remover_1(const Graph& graph)
        : m_graph(graph) {}

        template<typename ED>
        bool operator()(ED w) const {
                return target(w, m_graph) == source(w, m_graph);
        }

private:
        const Graph&    m_graph;
};


int test_main(int argc, char** argv)
{


//Random scale-free
typedef boost::unique_rmat_iterator<boost::minstd_rand, Graph> RMATGen;
boost::minstd_rand gen;
  Graph g(RMATGen(gen, 100, 1000, 0.57, 0.19, 0.19, 0.05),
          RMATGen(), 100);


  property_map<Graph, vertex_index_t>::type
    index_map = get(vertex_index, g);


        typedef property_map<Graph, double EdgeProperties::*>::type     egoods_map;
        typedef property_map<Graph, double EdgeProperties::*>::type     ecash_map;
        typedef property_map<Graph, double VertexProperties::*>::type   price_map;

  //Vertex iterator distributed property maps
  typedef property_map<Graph, vertex_index_t>::const_type VertexIndexMap;
  typedef iterator_property_map<std::vector<size_t>::iterator, VertexIndexMap>
    d_index_map;

  std::vector<size_t> index_S(num_vertices(g), std::numeric_limits<size_t>::max());
  d_index_map d_index(index_S.begin(), get(vertex_index, g));



  //Delete self-edges
  Remover_1<Graph>      r(g);
  remove_edge_if(r, g);


  boost::graph_traits<Graph>::vertex_iterator vit, vit_end;
  boost::graph_traits<Graph>::in_edge_iterator it, it_end;
  boost::graph_traits<Graph>::out_edge_iterator oit, oit_end;

  for(boost::tie(vit,vit_end) = vertices(g); vit != vit_end; ++vit) {
    cout << index_map[*vit] << " --> ";
    for (boost::tie(oit,oit_end) = out_edges(*vit, g); oit != oit_end; ++oit)
      cout << index_map[target(*oit, g)] << "  ";
    cout << endl;
  }


  for(boost::tie(vit,vit_end) = vertices(g); vit != vit_end; ++vit) {
    cout << index_map[*vit] << " <-- ";
    for (boost::tie(it,it_end) = in_edges(*vit, g); it != it_end; ++it)
      cout << index_map[source(*it, g)] << "  ";
    cout << endl;
  }


  return 0;
}