COIN-OR::LEMON - Graph Library

About

Downloads

Documentation

Development

Issue Tracker

Browse Tickets

Custom Query

Roadmap

Browse Source

Local Info

Mailing Lists

Search

Ticket #35: lgf_demo.patch

File lgf_demo.patch, 5.6 KB (added by Balazs Dezso, 16 years ago)

  • demo/Makefile.am 

    # HG changeset patch
# User Balazs Dezso <deba@inf.elte.hu>
# Date 1212230084 -7200
# Node ID 00d297da491e3393ba541528d697d84ebe6f5e0e
# Parent  c82fd9568d756001cc5aabe28571b247e7e190bb
Reworking demo file

diff -r c82fd9568d75 -r 00d297da491e demo/Makefile.am
    a b  
    11EXTRA_DIST += \
    2         demo/CMakeLists.txt
     2        demo/CMakeLists.txt \
     3        demo/digraph.lgf
    34
    45if WANT_DEMO
    56

  • new file demo/digraph.lgf 

    diff -r c82fd9568d75 -r 00d297da491e demo/digraph.lgf
    - +  
     1@nodes
     2label
     30
     41
     52
     63
     74
     85
     96
     107
     11@arcs
     12                label capacity
     130       1       0         16
     140       2       1         12
     150       3       2         20
     161       2       3         10
     171       4       4         10
     181       5       5         13
     192       3       6         10
     202       4       7         8
     212       6       8         8
     225       3       9         20
     233       6       10        25
     244       7       11        15
     255       7       12        15
     266       7       13        18
     27@attributes
     28source 0
     29target 7

  • demo/lgf_demo.cc 

    diff -r c82fd9568d75 -r 00d297da491e demo/lgf_demo.cc
    a b  
    2020///\file
    2121///\brief Demonstrating graph input and output
    2222///
    23 /// This simple demo program gives an example of how to read and write
    24 /// a graph and additional maps (on the nodes or the edges) from/to a
    25 /// stream.
     23/// This program gives an example of how to load a directed graph from
     24/// an \ref lgf-format "LGF" file with the \ref lemon::DigraphReader
     25/// "DigraphReader" class.
    2626///
    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
    2832
    2933#include <iostream>
    3034#include <lemon/smart_graph.h>
    … …  
    3539
    3640using namespace lemon;
    3741
    38 int main(int argc, const char *argv[]) {
    39   const int n = argc > 1 ? std::atoi(argv[1]) : 20;
    40   const int e = argc > 2 ? std::atoi(argv[2]) : static_cast<int>(n * std::log(double(n)));
    41   const int m = argc > 3 ? std::atoi(argv[3]) : 100;
     42int main() {
     43  SmartDigraph g;
     44  SmartDigraph::ArcMap<int> cap(g);
     45  SmartDigraph::Node s, t;
    4246
    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();
    4452
    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;
    4656
    47   try {
     57  std::cout << "We can write it to the standard output:" << std::endl;
    4858
    49     typedef SmartDigraph Digraph;
    50     typedef Digraph::Node Node;
    51     typedef Digraph::Arc Arc;
    52     typedef Digraph::ArcIt ArcIt;
    53 
    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 
     59  digraphWriter(std::cout, g).     // write g to the standard output
     60    arcMap("capacity", cap).       // write cap into 'capacity'
     61    node("source", s).             // write s to 'source'
     62    node("target", t).             // write t to 'target'
     63    run();
    15164
    15265  return 0;
    15366}