demo/lgf_demo.cc
changeset 187 84c2a2e5cfee
parent 143 c3b45bb643b0
child 191 abc5b9d0c67e
child 192 7bf5f97d574f
equal deleted inserted replaced
1:6b2f626b9e4b 2:0561b94b3fc8
    18 
    18 
    19 ///\ingroup demos
    19 ///\ingroup demos
    20 ///\file
    20 ///\file
    21 ///\brief Demonstrating graph input and output
    21 ///\brief Demonstrating graph input and output
    22 ///
    22 ///
    23 /// This simple demo program gives an example of how to read and write
    23 /// This program gives an example of how to load a directed graph from
    24 /// a graph and additional maps (on the nodes or the edges) from/to a
    24 /// an \ref lgf-format "LGF" file with the \ref lemon::DigraphReader
    25 /// stream. 
    25 /// "DigraphReader" class.
    26 ///
    26 ///
    27 /// \include reader_writer_demo.cc
    27 /// The \c "digraph.lgf" file:
       
    28 /// \include digraph.lgf
       
    29 ///
       
    30 /// And the program which reads it:
       
    31 /// \include lgf_demo.cc
    28 
    32 
    29 #include <iostream>
    33 #include <iostream>
    30 #include <lemon/smart_graph.h>
    34 #include <lemon/smart_graph.h>
    31 #include <lemon/lgf_reader.h>
    35 #include <lemon/lgf_reader.h>
    32 #include <lemon/lgf_writer.h>
    36 #include <lemon/lgf_writer.h>
    33 #include <lemon/random.h>
    37 #include <lemon/random.h>
    34 
    38 
    35 
    39 
    36 using namespace lemon;
    40 using namespace lemon;
    37 
    41 
    38 int main(int argc, const char *argv[]) {
    42 int main() {
    39   const int n = argc > 1 ? std::atoi(argv[1]) : 20;
    43   SmartDigraph g;
    40   const int e = argc > 2 ? std::atoi(argv[2]) : static_cast<int>(n * std::log(double(n)));
    44   SmartDigraph::ArcMap<int> cap(g);
    41   const int m = argc > 3 ? std::atoi(argv[3]) : 100;
    45   SmartDigraph::Node s, t;
    42 
    46 
    43   SmartDigraph digraph;
    47   digraphReader("digraph.lgf", g). // read the directeg graph into g
       
    48     arcMap("capacity", cap).       // read the 'capacity' arc map into cap
       
    49     node("source", s).             // read 'source' node to s
       
    50     node("target", t).             // read 'target' node to t
       
    51     run();
    44 
    52 
    45   std::stringstream ss;
    53   std::cout << "Digraph read from 'digraph.lgf'" << std::endl;
       
    54   std::cout << "Number of nodes: " << countNodes(g) << std::endl;
       
    55   std::cout << "Number of arcs: " << countArcs(g) << std::endl;
    46 
    56 
    47   try {
    57   std::cout << "We can write it to the standard output:" << std::endl;
    48 
    58 
    49     typedef SmartDigraph Digraph;
    59   digraphWriter(std::cout, g).     // write g to the standard output
    50     typedef Digraph::Node Node;
    60     arcMap("capacity", cap).       // write cap into 'capacity'
    51     typedef Digraph::Arc Arc;
    61     node("source", s).             // write s to 'source'
    52     typedef Digraph::ArcIt ArcIt;
    62     node("target", t).             // write t to 'target'
    53 
    63     run();
    54     typedef Digraph::NodeMap<int> PotentialMap;
       
    55     typedef Digraph::ArcMap<int> CapacityMap;
       
    56     typedef Digraph::ArcMap<std::string> NameMap;
       
    57 
       
    58     Digraph digraph;
       
    59     PotentialMap potential(digraph);
       
    60     CapacityMap capacity(digraph);
       
    61     NameMap name(digraph);
       
    62 
       
    63     std::vector<Node> nodes;
       
    64     for (int i = 0; i < n; ++i) {
       
    65       Node node = digraph.addNode();
       
    66       potential[node] = rnd[m];
       
    67       nodes.push_back(node);
       
    68     }
       
    69 
       
    70     std::vector<Arc> arcs;
       
    71     for (int i = 0; i < e; ++i) {
       
    72       int s = rnd[n];
       
    73       int t = rnd[n];
       
    74       int c = rnd[m];
       
    75       Arc arc = digraph.addArc(nodes[s], nodes[t]);
       
    76       capacity[arc] = c;
       
    77       std::ostringstream os;
       
    78       os << "arc \t" << i << std::endl;
       
    79       name[arc] = os.str();
       
    80       arcs.push_back(arc);
       
    81     }
       
    82 
       
    83 
       
    84     DigraphWriter<Digraph>(ss, digraph).
       
    85       nodeMap("potential", potential).
       
    86       arcMap("capacity", capacity).
       
    87       arcMap("name", name).
       
    88       node("source", nodes[0]).
       
    89       node("target", nodes[1]).
       
    90       arc("bottleneck", arcs[e / 2]).
       
    91       attribute("creator", "lemon library").
       
    92       run();
       
    93 
       
    94   } catch (DataFormatError& error) {
       
    95     std::cerr << error.what() << std::endl;
       
    96   }
       
    97 
       
    98   try {
       
    99 
       
   100     typedef SmartDigraph Digraph;
       
   101     typedef Digraph::Node Node;
       
   102     typedef Digraph::Arc Arc;
       
   103     typedef Digraph::ArcIt ArcIt;
       
   104 
       
   105     typedef Digraph::NodeMap<int> LabelMap;
       
   106     typedef Digraph::NodeMap<int> PotentialMap;
       
   107     typedef Digraph::ArcMap<int> CapacityMap;
       
   108     typedef Digraph::ArcMap<std::string> NameMap;
       
   109 
       
   110     Digraph digraph;
       
   111     LabelMap label(digraph);
       
   112     PotentialMap potential(digraph);
       
   113     CapacityMap capacity(digraph);
       
   114     NameMap name(digraph);
       
   115 
       
   116     Node s, t;
       
   117     Arc a;
       
   118     
       
   119     std::string creator;
       
   120 
       
   121     for (int i = 0; i < n; ++i) {
       
   122       Node node = digraph.addNode();
       
   123       label[node] = i;
       
   124     }
       
   125     
       
   126     DigraphReader<Digraph>(ss, digraph).
       
   127       useNodes(label).
       
   128       nodeMap("potential", potential).
       
   129       arcMap("capacity", capacity).
       
   130       arcMap("name", name).
       
   131       node("source", s).
       
   132       node("target", t).
       
   133       arc("bottleneck", a).
       
   134       attribute("creator", creator).
       
   135       run();
       
   136 
       
   137     DigraphWriter<Digraph>(std::cout, digraph).
       
   138       nodeMap("potential", potential).
       
   139       arcMap("capacity", capacity).
       
   140       arcMap("name", name).
       
   141       node("source", s).
       
   142       node("target", t).
       
   143       arc("bottleneck", a).
       
   144       attribute("creator", creator).
       
   145       run();
       
   146 
       
   147   } catch (DataFormatError& error) {
       
   148     std::cerr << error.what() << std::endl;
       
   149   }
       
   150 
       
   151 
    64 
   152   return 0;
    65   return 0;
   153 }
    66 }