RhodeCode

 *

 *

 * Copyright (C) 2003-2008

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

  // Add non-parsed arguments (e.g. input files)

  ap.other("infile", "The input file.")

    .other("...");

  // Perform the parsing process

  // (in case of any error it terminates the program)

  ap.parse();

  if(ap.given("gra")) std::cout << "  -gra is given\n";

  if(ap.given("grb")) std::cout << "  -grb is given\n";

  if(ap.given("grc")) std::cout << "  -grc is given\n";

  switch(ap.files().size()) {

  case 0:

    std::cout << "  No file argument was given.\n";

    break;

  default:

    std::cout << "  "

  }

  for(unsigned int i=0;i<ap.files().size();++i)

    std::cout << "    '" << ap.files()[i] << "'\n";

  return 0;

}

 *

 *

 * Copyright (C) 2003-2008

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

  typedef ListDigraph::NodeIt NodeIt;

  typedef ListDigraph::Arc Arc;

  typedef dim2::Point<int> Point;

  Node n1=g.addNode();

  Node n2=g.addNode();

  Node n3=g.addNode();

  ListDigraph::NodeMap<int> shapes(g);

  ListDigraph::ArcMap<int> acolors(g);

  ListDigraph::ArcMap<int> widths(g);

  coords[n1]=Point(50,50);  sizes[n1]=1; colors[n1]=1; shapes[n1]=0;

  coords[n2]=Point(50,70);  sizes[n2]=2; colors[n2]=2; shapes[n2]=2;

  coords[n3]=Point(70,70);  sizes[n3]=1; colors[n3]=3; shapes[n3]=0;

  coords[n4]=Point(70,50);  sizes[n4]=2; colors[n4]=4; shapes[n4]=1;

  coords[n5]=Point(85,60);  sizes[n5]=3; colors[n5]=5; shapes[n5]=2;

  Arc a;

  a=g.addArc(n1,n2); acolors[a]=0; widths[a]=1;

  a=g.addArc(n4,n1); acolors[a]=0; widths[a]=1;

  a=g.addArc(n2,n4); acolors[a]=1; widths[a]=2;

  a=g.addArc(n3,n4); acolors[a]=2; widths[a]=1;

  IdMap<ListDigraph,Node> id(g);

  // Create five .eps files showing the digraph with different options

  ListDigraph h;

  ListDigraph::NodeMap<int> hcolors(h);

  ListDigraph::NodeMap<Point> hcoords(h);

  int cols=int(sqrt(double(palette.size())));

  for(int i=0;i<int(paletteW.size());i++) {

    Node n=h.addNode();

    hcoords[n]=Point(1+i%cols,1+i/cols);

    hcolors[n]=i;

  }

  cout << "Create 'graph_to_eps_demo_out_6_colors.eps'" << endl;

  graphToEps(h,"graph_to_eps_demo_out_6_colors.eps").

    scale(60).

    nodeTexts(hcolors).nodeTextSize(.6).

    nodeColors(composeMap(paletteW,hcolors)).

    run();

  return 0;

}

 *

 *

 * Copyright (C) 2003-2008

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

///\brief Demonstrating graph input and output

///

/// This program gives an example of how to read and write a digraph

/// \ref lgf-format "LGF" format.

///

/// The \c "digraph.lgf" file:

  SmartDigraph g;

  SmartDigraph::ArcMap<int> cap(g);

  SmartDigraph::Node s, t;

  try {

    digraphReader("digraph.lgf", g). // read the directed graph into g

      arcMap("capacity", cap).       // read the 'capacity' arc map into cap

 *

 *

 * Copyright (C) 2003-2008

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

/*!

\section naming_conv Naming Conventions

The name of a class or any type should look like the following.

\code

\endcode

\subsection cs-func Methods and other functions

The name of a function should look like the following.

\code

\endcode

\subsection cs-funcs Constants, Macros

The names of constants and macros should look like the following.

\code

\endcode

The names of class and instance member variables and auto variables (=variables used locally in methods) should look like the following.

\code

\endcode

\subsection pri-loc-var Private member variables

 *

 *

 * Copyright (C) 2003-2008

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

\brief Implementation helper files

This directory contains some helper classes to implement graphs, maps and

files.

*/

 *

 *

 * Copyright (C) 2003-2008

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

@ingroup datas

\brief Graph structures implemented in LEMON.

The most efficient implementation of diverse applications require the

usage of different physical graph implementations. These differences

running time or on memory usage, some structures may fail to provide

some graph features like arc/edge or node deletion.

arcs have to be hidden or the reverse oriented graph have to be used, then

You are free to use the graph structure that fit your requirements

the best, most graph algorithms and auxiliary data structures can be used

*/

/**

\brief Graph types between real graphs and graph adaptors.

This group describes some graph types between real graphs and graph adaptors.

On the other hand they are not light-weight structures as the adaptors.

*/

/**

@ingroup datas

\brief Map structures implemented in LEMON.

*/

/**

@ingroup maps

\brief Special graph-related maps.

      return Color(0.0, 0.0, 0.0);

    }

  }

  Digraph::NodeMap<int> degree_map(graph);

  digraphToEps(graph, "graph.eps")

    .coords(coords).scaleToA4().undirected()

    .nodeColors(composeMap(functorToMap(nodeColor), degree_map))

    .run();

The \c functorToMap() function makes an \c int to \c Color map from the

\e nodeColor() function. The \c composeMap() compose the \e degree_map

and the previously created map. The composed map is a proper function to

  typedef DivMap<DoubleArcMap, DoubleArcMap> TimeMap;

  TimeMap time(length, speed);

  Dijkstra<Digraph, TimeMap> dijkstra(graph, time);

  dijkstra.run(source, target);

\endcode

*/

/**

@ingroup datas

\brief Two dimensional data storages implemented in LEMON.

@ingroup algs

\brief Common graph search algorithms.

Breadth-first search (Bfs) and Depth-first search (Dfs).

*/

This group describes the algorithms for finding shortest paths in graphs.

*/

\brief Algorithms for finding maximum flows.

This group describes the algorithms for finding maximum flows and

\f[ \max \sum_{v\in\delta^{+}(s)}f_{uv} - \sum_{v\in\delta^{-}(s)}f_{vu}\f]

LEMON contains several algorithms for solving maximum flow problems:

- \ref lemon::Preflow "Goldberg's Preflow algorithm"

- \ref lemon::DinitzSleatorTarjan "Dinitz's blocking flow algorithm with dynamic trees"

- \ref lemon::GoldbergTarjan "Preflow algorithm with dynamic trees"

\brief Algorithms for finding minimum cost flows and circulations.

This group describes the algorithms for finding minimum cost flows and

*/

/**

\brief Algorithms for finding minimum cut in graphs.

LEMON contains several algorithms related to minimum cut problems:

- \ref lemon::HaoOrlin "Hao-Orlin algorithm" to calculate minimum cut

- \ref lemon::NagamochiIbaraki "Nagamochi-Ibaraki algorithm" to

  calculate minimum cut in undirected graphs

- \ref lemon::GomoryHuTree "Gomory-Hu tree computation" to calculate all

*/

/**

@ingroup algs

\brief Algorithms for finding matchings in graphs and bipartite graphs.

This group contains algorithm objects and functions to calculate

matchings in graphs and bipartite graphs. The general matching problem is

finding a subset of the arcs which does not shares common endpoints.

There are several different algorithms for calculate matchings in

graphs.  The matching problems in bipartite graphs are generally

easier than in general graphs. The goal of the matching optimization

maximum cardinality matching.

Lemon contains the next algorithms:

  bipartite graphs

  and maximum weighted bipartite matching in bipartite graph

  matching in bipartite graph

- \ref lemon::MaxMatching "MaxMatching" Edmond's blossom shrinking algorithm

  for calculate maximum cardinality matching in general graph

*/

@ingroup lp_group

\brief Helper tools to the Lp and Mip solvers.

*/

/**

\brief Tools and utilities for programming in LEMON

Tools and utilities for programming in LEMON.

@defgroup io_group Input-Output

\brief Graph Input-Output methods

and graph related data. Now it supports the LEMON format, the

\c DIMACS format and the encapsulated postscript (EPS) format.

*/

\brief General \c EPS drawer and graph exporter

This group describes general \c EPS drawing methods and special

*/

classes implemented in LEMON.

The purpose of the classes in this group is fourfold.

- These classes contain the documentations of the concepts. In order

  to avoid document multiplications, an implementation of a concept

  simply refers to the corresponding concept class.

/**

@defgroup tools Standalone utility applications

The standard compilation procedure (<tt>./configure;make</tt>) will compile

*/

 *

 *

 * Copyright (C) 2003-2008

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

\e quoted. A plain token is just a sequence of non-whitespace characters,

while a quoted token is a

character sequence surrounded by double quotes, and it can also

The \c \@nodes section describes a set of nodes and associated

maps. The first is a header line, its columns are the names of the

\code

 @arcs

 1   2   16

 1   3   12

 2   3   18

 *

 *

 * Copyright (C) 2003-2008

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 *

 *

 * Copyright (C) 2003-2008

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

\subsection howtoread How to read the documentation

take a look at our \ref quicktour

"Quick Tour to LEMON" which will guide you along.

\ref getstart "How to start using LEMON".

some \ref demoprograms "demo programs"!

If you know what you are looking for then try to find it under the

 *

 *

 * Copyright (C) 2003-2008

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 *

 *

 * Copyright (C) 2003-2008

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 *

 *

 * Copyright (C) 2003-2008

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

  {

    for(Opts::iterator i=_opts.begin();i!=_opts.end();++i)

      if(i->second.self_delete)

  }

  ArgParser &ArgParser::intOption(const std::string &name,

  {

    ParData p;

    p.int_p=new int(value);

  }

  ArgParser &ArgParser::doubleOption(const std::string &name,

  {

    ParData p;

    p.double_p=new double(value);

  }

  ArgParser &ArgParser::boolOption(const std::string &name,

  {

    ParData p;

    p.bool_p=new bool(value);

  }

  ArgParser &ArgParser::stringOption(const std::string &name,

  {

    ParData p;

    p.string_p=new std::string(value);

  }

  ArgParser &ArgParser::refOption(const std::string &name,

  {

    ParData p;

    p.int_p=&ref;

  }

  ArgParser &ArgParser::refOption(const std::string &name,

  {

    ParData p;

    p.string_p=&ref;

  }

  ArgParser &ArgParser::funcOption(const std::string &name,

  {

    ParData p;

    p.func_p.p=func;

  }

  ArgParser &ArgParser::optionGroup(const std::string &group,

  {

    Opts::iterator i = _opts.find(opt);

    LEMON_ASSERT(i!=_opts.end(), "Unknown option: '"+opt+"'");

                 "Option already in option group: '"+opt+"'");

    GroupData &g=_groups[group];

    g.opts.push_back(opt);

  }

  ArgParser &ArgParser::synonym(const std::string &syn,

  {

    Opts::iterator o = _opts.find(opt);

    Opts::iterator s = _opts.find(syn);

  }

  ArgParser &ArgParser::other(const std::string &name,

  {

    _others_help.push_back(OtherArg(name,help));

    return *this;

    os << "-" << i->first;

    if(i->second.has_syn)

      for(Opts::iterator j=_opts.begin();j!=_opts.end();++j)

    switch(i->second.type) {

    case STRING:

      os << " str";

      if(o!=i->second.opts.end()) os<<'|';

    }

  }

  void ArgParser::showHelp(Opts::iterator i)

  {

    if(i->second.help.size()==0||i->second.syn) return;

  {

    if(i->help.size()==0) return;

    std::cerr << "  " << i->name << std::endl

  }

  void ArgParser::shortHelp()

  {

    const unsigned int LINE_LEN=77;

      show(cstr,g);

      if(!g->second.mandatory) cstr << ']';

      if(pos+cstr.str().size()>LINE_LEN) {

      }

      std::cerr << cstr.str();

      pos+=cstr.str().size();

    }

    for(Opts::iterator i=_opts.begin();i!=_opts.end();++i)

      if(!i->second.ingroup&&!i->second.syn) {

      }

    for(std::vector<OtherArg>::iterator i=_others_help.begin();

      {

      }

    std::cerr << std::endl;

  }

  void ArgParser::showHelp()

  {

    shortHelp();

    std::cerr << "Where:\n";

    for(std::vector<OtherArg>::iterator i=_others_help.begin();

    for(Opts::iterator i=_opts.begin();i!=_opts.end();++i) showHelp(i);

    exit(1);

  }

  {

    std::cerr << "\nUnknown option: " << arg << "\n";

    std::cerr << "\nType '" << _command_name <<

      " --help' to obtain a short summary on the usage.\n\n";

    exit(1);

  }

  {

    std::cerr << "Argument '" << arg << "' requires a";

    switch(t) {

    std::cerr << " value\n\n";

    showHelp();

  }

  void ArgParser::checkMandatories()

  {

    bool ok=true;

    for(Opts::iterator i=_opts.begin();i!=_opts.end();++i)

    for(Groups::iterator i=_groups.begin();i!=_groups.end();++i)

      if(i->second.mandatory||i->second.only_one)

    if(!ok) {

      std::cerr << "\nType '" << _command_name <<

      exit(1);

    }

  }

    for(int ar=1; ar<_argc; ++ar) {

      std::string arg(_argv[ar]);

      if (arg[0] != '-' || arg.size() == 1) {

      }

      else {

      }

    }

    checkMandatories();

    return *this;

}

 *

 *

 * Copyright (C) 2003-2008

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

  ///

  ///For a complete example see the \ref arg_parser_demo.cc demo file.

  class ArgParser {

    static void _showHelp(void *p);

  protected:

    int _argc;

    const char **_argv;

    enum OptType { UNKNOWN=0, BOOL=1, STRING=2, DOUBLE=3, INTEGER=4, FUNC=5 };

    class ParData {

    public:

      union {