RhodeCode

LEMON code without an explicit copyright is covered by the following

copyright/license.

Kutatocsoport (Egervary Combinatorial Optimization Research Group,

EGRES).

Permission is hereby granted, free of charge, to any person or organization

obtaining a copy of the software and accompanying documentation covered by

this license (the "Software") to use, reproduce, display, distribute,

execute, and transmit the Software, and to prepare derivative works of the

Software, and to permit third-parties to whom the Software is furnished to

do so, all subject to the following:

The copyright notices in the Software and this entire statement, including

the above license grant, this restriction and the following disclaimer,

must be included in all copies of the Software, in whole or in part, and

all derivative works of the Software, unless such copies or derivative

works are solely in the form of machine-executable object code generated by

a source language processor.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT

SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE

FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,

ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

DEALINGS IN THE SOFTWARE.

===========================================================================

This license is a verbatim copy of the Boost Software License, Version 1.0.

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library.

 *

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 * (Egervary Research Group on Combinatorial Optimization, EGRES).

 *

 * Permission to use, modify and distribute this software is granted

 * provided that this copyright notice appears in all copies. For

 * precise terms see the accompanying LICENSE file.

 *

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any

 * purpose.

 *

 */

///\ingroup demos

///\file

///\brief Argument parser demo

///

/// This example shows how the argument parser can be used.

///

/// \include arg_parser_demo.cc

#include <lemon/arg_parser.h>

using namespace lemon;

int main(int argc, char **argv)

{

  // Initialize the argument parser

  ArgParser ap(argc, argv);

  int i;

  std::string s;

  double d = 1.0;

  bool b, nh;

  bool g1, g2, g3;

  // Add a mandatory integer option with storage reference

  ap.refOption("n", "An integer input.", i, true);

  // Add a double option with storage reference (the default value is 1.0)

  ap.refOption("val", "A double input.", d);

  // Add a double option without storage reference (the default value is 3.14)

  ap.doubleOption("val2", "A double input.", 3.14);

  // Set synonym for -val option

  ap.synonym("vals", "val");

  // Add a string option

  ap.refOption("name", "A string input.", s);

  // Add bool options

  ap.refOption("f", "A switch.", b)

    .refOption("nohelp", "", nh)

    .refOption("gra", "Choice A", g1)

    .refOption("grb", "Choice B", g2)

    .refOption("grc", "Choice C", g3);

  // Bundle -gr* options into a group

  ap.optionGroup("gr", "gra")

    .optionGroup("gr", "grb")

    .optionGroup("gr", "grc");

  // Set the group mandatory

  ap.mandatoryGroup("gr");

  // Set the options of the group exclusive (only one option can be given)

  ap.onlyOneGroup("gr");

  // 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();

  // Check each option if it has been given and print its value

  std::cout << "Parameters of '" << ap.commandName() << "':\n";

  std::cout << "  Value of -n: " << i << std::endl;

  if(ap.given("val")) std::cout << "  Value of -val: " << d << std::endl;

  if(ap.given("val2")) {

    d = ap["val2"];

    std::cout << "  Value of -val2: " << d << std::endl;

  }

  if(ap.given("name")) std::cout << "  Value of -name: " << s << std::endl;

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

  if(ap.given("nohelp")) std::cout << "  Value of -nohelp: " << nh << std::endl;

  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;

  case 1:

    std::cout << "  1 file argument was given. It is:\n";

    break;

  default:

    std::cout << "  "

              << ap.files().size() << " file arguments were given. They are:\n";

  }

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

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

  return 0;

}

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library.

 *

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 * (Egervary Research Group on Combinatorial Optimization, EGRES).

 *

 * Permission to use, modify and distribute this software is granted

 * provided that this copyright notice appears in all copies. For

 * precise terms see the accompanying LICENSE file.

 *

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any

 * purpose.

 *

 */

/// \ingroup demos

/// \file

/// \brief Demo of the graph drawing function \ref graphToEps()

///

/// This demo program shows examples how to use the function \ref

/// graphToEps(). It takes no input but simply creates seven

/// <tt>.eps</tt> files demonstrating the capability of \ref

/// graphToEps(), and showing how to draw directed graphs,

/// how to handle parallel egdes, how to change the properties (like

/// color, shape, size, title etc.) of nodes and arcs individually

/// using appropriate graph maps.

///

/// \include graph_to_eps_demo.cc

#include<lemon/list_graph.h>

#include<lemon/graph_to_eps.h>

#include<lemon/math.h>

using namespace std;

using namespace lemon;

int main()

{

  Palette palette;

  Palette paletteW(true);

  // Create a small digraph

  ListDigraph g;

  typedef ListDigraph::Node Node;

  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();

  Node n4=g.addNode();

  Node n5=g.addNode();

  ListDigraph::NodeMap<Point> coords(g);

  ListDigraph::NodeMap<double> sizes(g);

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

  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(n2,n3); acolors[a]=0; widths[a]=1;

  a=g.addArc(n3,n5); acolors[a]=0; widths[a]=3;

  a=g.addArc(n5,n4); 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 .eps files showing the digraph with different options

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

  graphToEps(g,"graph_to_eps_demo_out_1_pure.eps").

    coords(coords).

    title("Sample .eps figure").

    run();

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

  graphToEps(g,"graph_to_eps_demo_out_2.eps").

    coords(coords).

    title("Sample .eps figure").

    absoluteNodeSizes().absoluteArcWidths().

    nodeScale(2).nodeSizes(sizes).

    nodeShapes(shapes).

    nodeColors(composeMap(palette,colors)).

    arcColors(composeMap(palette,acolors)).

    arcWidthScale(.4).arcWidths(widths).

    nodeTexts(id).nodeTextSize(3).

    run();

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

  graphToEps(g,"graph_to_eps_demo_out_3_arr.eps").

    title("Sample .eps figure (with arrowheads)").

    absoluteNodeSizes().absoluteArcWidths().

    nodeColors(composeMap(palette,colors)).

    coords(coords).

    nodeScale(2).nodeSizes(sizes).

    nodeShapes(shapes).

    arcColors(composeMap(palette,acolors)).

    arcWidthScale(.4).arcWidths(widths).

    nodeTexts(id).nodeTextSize(3).

    drawArrows().arrowWidth(2).arrowLength(2).

    run();

  // Add more arcs to the digraph

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

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

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

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

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

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

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

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

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

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

  graphToEps(g,"graph_to_eps_demo_out_4_par.eps").

    title("Sample .eps figure (parallel arcs)").

    absoluteNodeSizes().absoluteArcWidths().

    nodeShapes(shapes).

    coords(coords).

    nodeScale(2).nodeSizes(sizes).

    nodeColors(composeMap(palette,colors)).

    arcColors(composeMap(palette,acolors)).

    arcWidthScale(.4).arcWidths(widths).

    nodeTexts(id).nodeTextSize(3).

    enableParallel().parArcDist(1.5).

    run();

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

  graphToEps(g,"graph_to_eps_demo_out_5_par_arr.eps").

    title("Sample .eps figure (parallel arcs and arrowheads)").

    absoluteNodeSizes().absoluteArcWidths().

    nodeScale(2).nodeSizes(sizes).

    coords(coords).

    nodeShapes(shapes).

    nodeColors(composeMap(palette,colors)).

    arcColors(composeMap(palette,acolors)).

    arcWidthScale(.3).arcWidths(widths).

    nodeTexts(id).nodeTextSize(3).

    enableParallel().parArcDist(1).

    drawArrows().arrowWidth(1).arrowLength(1).

    run();

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

  graphToEps(g,"graph_to_eps_demo_out_6_par_arr_a4.eps").

    title("Sample .eps figure (fits to A4)").

    scaleToA4().

    absoluteNodeSizes().absoluteArcWidths().

    nodeScale(2).nodeSizes(sizes).

    coords(coords).

    nodeShapes(shapes).

    nodeColors(composeMap(palette,colors)).

    arcColors(composeMap(palette,acolors)).

    arcWidthScale(.3).arcWidths(widths).

    nodeTexts(id).nodeTextSize(3).

    enableParallel().parArcDist(1).

    drawArrows().arrowWidth(1).arrowLength(1).

    run();

  // Create an .eps file showing the colors of a default Palette

  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_7_colors.eps'" << endl;

  graphToEps(h,"graph_to_eps_demo_out_7_colors.eps").

    scale(60).

    title("Sample .eps figure (Palette demo)").

    coords(hcoords).

    absoluteNodeSizes().absoluteArcWidths().

    nodeScale(.45).

    distantColorNodeTexts().

    nodeTexts(hcolors).nodeTextSize(.6).

    nodeColors(composeMap(paletteW,hcolors)).

    run();

  return 0;

}

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library.

 *

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 * (Egervary Research Group on Combinatorial Optimization, EGRES).

 *

 * Permission to use, modify and distribute this software is granted

 * provided that this copyright notice appears in all copies. For

 * precise terms see the accompanying LICENSE file.

 *

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any

 * purpose.

 *

 */

///\ingroup demos

///\file

///\brief Demonstrating graph input and output

///

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

/// and additional maps from/to a stream or a file using the

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

///

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

/// \include digraph.lgf

///

/// And the program which reads it and prints the digraph to the

/// standard output:

/// \include lgf_demo.cc

#include <iostream>

#include <lemon/smart_graph.h>

#include <lemon/lgf_reader.h>

#include <lemon/lgf_writer.h>

using namespace lemon;

int main() {

  SmartDigraph g;

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

  SmartDigraph::Node s, t;

  try {

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

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

      node("source", s).             // read 'source' node to s

      node("target", t).             // read 'target' node to t

      run();

  } catch (Exception& error) { // check if there was any error

    std::cerr << "Error: " << error.what() << std::endl;

    return -1;

  }

  std::cout << "A digraph is read from 'digraph.lgf'." << std::endl;

  std::cout << "Number of nodes: " << countNodes(g) << std::endl;

  std::cout << "Number of arcs: " << countArcs(g) << std::endl;

  std::cout << "We can write it to the standard output:" << std::endl;

  digraphWriter(g).                // write g to the standard output

    arcMap("capacity", cap).       // write cap into 'capacity'

    node("source", s).             // write s to 'source'

    node("target", t).             // write t to 'target'

    run();

  return 0;

}

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library.

 *

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 * (Egervary Research Group on Combinatorial Optimization, EGRES).

 *

 * Permission to use, modify and distribute this software is granted

 * provided that this copyright notice appears in all copies. For

 * precise terms see the accompanying LICENSE file.

 *

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any

 * purpose.

 *

 */

/*!

\page coding_style LEMON Coding Style

\section naming_conv Naming Conventions

In order to make development easier we have made some conventions

according to coding style. These include names of types, classes,

functions, variables, constants and exceptions. If these conventions

are met in one's code then it is easier to read and maintain

it. Please comply with these conventions if you want to contribute

developing LEMON library.

\note When the coding style requires the capitalization of an abbreviation,

only the first letter should be upper case.

\code

XmlReader

\endcode

\warning In some cases we diverge from these rules.

This is primary done because STL uses different naming convention and

in certain cases

it is beneficial to provide STL compatible interface.

\subsection cs-files File Names

The header file names should look like the following.

\code

header_file.h

\endcode

Note that all standard LEMON headers are located in the \c lemon subdirectory,

so you should include them from C++ source like this:

\code

#include <lemon/header_file.h>

\endcode

The source code files use the same style and they have '.cc' extension.

\code

source_code.cc

\endcode

\subsection cs-class Classes and other types

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

\code

AllWordsCapitalizedWithoutUnderscores

\endcode

\subsection cs-func Methods and other functions

The name of a function should look like the following.

\code

firstWordLowerCaseRestCapitalizedWithoutUnderscores

\endcode

\subsection cs-funcs Constants, Macros

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

\code

ALL_UPPER_CASE_WITH_UNDERSCORES

\endcode

\subsection cs-loc-var Class and instance member variables, auto variables

The names of class and instance member variables and auto variables

(=variables used locally in methods) should look like the following.

\code

all_lower_case_with_underscores

\endcode

\subsection pri-loc-var Private member variables

Private member variables should start with underscore

\code

_start_with_underscores

\endcode

\subsection cs-excep Exceptions

When writing exceptions please comply the following naming conventions.

\code

ClassNameEndsWithException

\endcode

or

\code

ClassNameEndsWithError

\endcode

\section header-template Template Header File

Each LEMON header file should look like this:

\include template.h

*/

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library.

 *

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 * (Egervary Research Group on Combinatorial Optimization, EGRES).

 *

 * Permission to use, modify and distribute this software is granted

 * provided that this copyright notice appears in all copies. For

 * precise terms see the accompanying LICENSE file.

 *

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any

 * purpose.

 *

 */

/**

\dir demo

\brief A collection of demo applications.

This directory contains several simple demo applications, mainly

for educational purposes.

*/

/**

\dir doc

\brief Auxiliary (and the whole generated) documentation.

This directory contains some auxiliary pages and the whole generated

documentation.

*/

/**

\dir test

\brief Test programs.

This directory contains several test programs that check the consistency

of the code.

*/

/**

\dir tools

\brief Some useful executables.

This directory contains the sources of some useful complete executables.

*/

/**

\dir lemon

\brief Base include directory of LEMON.

This is the base directory of LEMON includes, so each include file must be

prefixed with this, e.g.

\code

#include<lemon/list_graph.h>

#include<lemon/dijkstra.h>

\endcode

*/

/**

\dir concepts

\brief Concept descriptors and checking classes.

This directory contains the concept descriptors and concept checking tools.

For more information see the \ref concept "Concepts" module.

*/

/**

\dir bits

\brief Auxiliary tools for implementation.

maps and some other classes.

As a user you typically don't have to deal with these files.

*/

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library.

 *

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 * (Egervary Research Group on Combinatorial Optimization, EGRES).

 *

 * Permission to use, modify and distribute this software is granted

 * provided that this copyright notice appears in all copies. For

 * precise terms see the accompanying LICENSE file.

 *

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any

 * purpose.

 *

 */

namespace lemon {

/**

@defgroup datas Data Structures

This group describes the several data structures implemented in LEMON.

*/

/**

@defgroup graphs Graph Structures

@ingroup datas

\brief Graph structures implemented in LEMON.

The implementation of combinatorial algorithms heavily relies on

efficient graph implementations. LEMON offers data structures which are

planned to be easily used in an experimental phase of implementation studies,

and thereafter the program code can be made efficient by small modifications.

The most efficient implementation of diverse applications require the

usage of different physical graph implementations. These differences

appear in the size of graph we require to handle, memory or time usage

limitations or in the set of operations through which the graph can be

accessed.  LEMON provides several physical graph structures to meet

the diverging requirements of the possible users.  In order to save on

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

some graph features like arc/edge or node deletion.

Alteration of standard containers need a very limited number of

operations, these together satisfy the everyday requirements.

In the case of graph structures, different operations are needed which do

not alter the physical graph, but gives another view. If some nodes or

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

this is the case. It also may happen that in a flow implementation

the residual graph can be accessed by another algorithm, or a node-set

is to be shrunk for another algorithm.

LEMON also provides a variety of graphs for these requirements called

\ref graph_adaptors "graph adaptors". Adaptors cannot be used alone but only

in conjunction with other graph representations.

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

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

with any graph structure.

<b>See also:</b> \ref graph_concepts "Graph Structure Concepts".

*/

/**

@defgroup graph_adaptors Adaptor Classes for graphs

@ingroup graphs

\brief This group contains several adaptor classes for digraphs and graphs

The main parts of LEMON are the different graph structures, generic

graph algorithms, graph concepts which couple these, and graph

adaptors. While the previous notions are more or less clear, the

latter one needs further explanation. Graph adaptors are graph classes

which serve for considering graph structures in different ways.

A short example makes this much clearer.  Suppose that we have an

instance \c g of a directed graph type say ListDigraph and an algorithm

\code

template <typename Digraph>

int algorithm(const Digraph&);

\endcode

is needed to run on the reverse oriented graph.  It may be expensive

(in time or in memory usage) to copy \c g with the reversed

arcs.  In this case, an adaptor class is used, which (according

to LEMON digraph concepts) works as a digraph.  The adaptor uses the

original digraph structure and digraph operations when methods of the

reversed oriented graph are called.  This means that the adaptor have

minor memory usage, and do not perform sophisticated algorithmic

actions.  The purpose of it is to give a tool for the cases when a

graph have to be used in a specific alteration.  If this alteration is

obtained by a usual construction like filtering the arc-set or

considering a new orientation, then an adaptor is worthwhile to use.

To come back to the reverse oriented graph, in this situation

\code

template<typename Digraph> class ReverseDigraph;

\endcode

template class can be used. The code looks as follows

\code

ListDigraph g;

ReverseDigraph<ListGraph> rg(g);

int result = algorithm(rg);

\endcode

After running the algorithm, the original graph \c g is untouched.

This techniques gives rise to an elegant code, and based on stable

graph adaptors, complex algorithms can be implemented easily.

In flow, circulation and bipartite matching problems, the residual

graph is of particular importance. Combining an adaptor implementing

this, shortest path algorithms and minimum mean cycle algorithms,

a range of weighted and cardinality optimization algorithms can be

obtained. For other examples, the interested user is referred to the

detailed documentation of particular adaptors.

The behavior of graph adaptors can be very different. Some of them keep

capabilities of the original graph while in other cases this would be

meaningless. This means that the concepts that they are models of depend

on the graph adaptor, and the wrapped graph(s).

If an arc of \c rg is deleted, this is carried out by deleting the

corresponding arc of \c g, thus the adaptor modifies the original graph.

But for a residual graph, this operation has no sense.

Let us stand one more example here to simplify your work.

RevGraphAdaptor has constructor

\code

ReverseDigraph(Digraph& digraph);

\endcode

This means that in a situation, when a <tt>const ListDigraph&</tt>

reference to a graph is given, then it have to be instantiated with

<tt>Digraph=const ListDigraph</tt>.

\code

int algorithm1(const ListDigraph& g) {

  RevGraphAdaptor<const ListDigraph> rg(g);

  return algorithm2(rg);

}

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library.

 *

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 * (Egervary Research Group on Combinatorial Optimization, EGRES).

 *

 * Permission to use, modify and distribute this software is granted

 * provided that this copyright notice appears in all copies. For

 * precise terms see the accompanying LICENSE file.

 *

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any

 * purpose.

 *

 */

namespace lemon {

/*!

\page lgf-format LEMON Graph Format (LGF)

The \e LGF is a <em>column oriented</em>

file format for storing graphs and associated data like

node and edge maps.

Each line with \c '#' first non-whitespace

character is considered as a comment line.

Otherwise the file consists of sections starting with

a header line. The header lines starts with an \c '@' character followed by the

type of section. The standard section types are \c \@nodes, \c

\@arcs and \c \@edges

and \@attributes. Each header line may also have an optional

\e name, which can be use to distinguish the sections of the same

type.

The standard sections are column oriented, each line consists of

<em>token</em>s separated by whitespaces. A token can be \e plain or

\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

contain whitespaces and escape sequences.

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

maps appearing in the following lines.

One of the maps must be called \c

"label", which plays special role in the file.

The following

non-empty lines until the next section describes nodes of the

graph. Each line contains the values of the node maps

associated to the current node.

\code

 @nodes

 label  coordinates  size    title

 1      (10,20)      10      "First node"

 2      (80,80)      8       "Second node"

 3      (40,10)      10      "Third node"

\endcode

The \c \@arcs section is very similar to the \c \@nodes section,

it again starts with a header line describing the names of the maps,

but the \c "label" map is not obligatory here. The following lines

describe the arcs. The first two tokens of each line are

the source and the target node of the arc, respectively, then come the map

values. The source and target tokens must be node labels.

\code

 @arcs

         capacity

 1   2   16

 1   3   12

 2   3   18

\endcode

The \c \@edges is just a synonym of \c \@arcs. The \@arcs section can

also store the edge set of an undirected graph. In such case there is

a conventional method for store arc maps in the file, if two columns

has the same caption with \c '+' and \c '-' prefix, then these columns

can be regarded as the values of an arc map.

The \c \@attributes section contains key-value pairs, each line

consists of two tokens, an attribute name, and then an attribute

value. The value of the attribute could be also a label value of a

node or an edge, or even an edge label prefixed with \c '+' or \c '-',

which regards to the forward or backward directed arc of the

corresponding edge.

\code

 @attributes

 source 1

 target 3

 caption "LEMON test digraph"

\endcode

The \e LGF can contain extra sections, but there is no restriction on

the format of such sections.

*/

}

//  LocalWords:  whitespace whitespaces

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library.

 *

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 * (Egervary Research Group on Combinatorial Optimization, EGRES).

 *

 * Permission to use, modify and distribute this software is granted

 * provided that this copyright notice appears in all copies. For

 * precise terms see the accompanying LICENSE file.

 *

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any

 * purpose.

 *

 */

/**

\page license License Terms

\verbinclude LICENSE

*/

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library.

 *

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 * (Egervary Research Group on Combinatorial Optimization, EGRES).

 *

 * Permission to use, modify and distribute this software is granted

 * provided that this copyright notice appears in all copies. For

 * precise terms see the accompanying LICENSE file.

 *

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any

 * purpose.

 *

 */

/**

\mainpage LEMON Documentation

\section intro Introduction

\subsection whatis What is LEMON

LEMON stands for

<b>L</b>ibrary of <b>E</b>fficient <b>M</b>odels

and <b>O</b>ptimization in <b>N</b>etworks.

It is a C++ template

library aimed at combinatorial optimization tasks which

often involve in working

with graphs.

<b>

LEMON is an <a class="el" href="http://opensource.org/">open&nbsp;source</a>

project.

You are free to use it in your commercial or

non-commercial applications under very permissive

\ref license "license terms".

</b>

\subsection howtoread How to read the documentation

If you want to get a quick start and see the most important features then

take a look at our \ref quicktour

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

If you already feel like using our library, see the page that tells you

\ref getstart "How to start using LEMON".

If you

want to see how LEMON works, see

some \ref demoprograms "demo programs".

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

<a class="el" href="modules.html">Modules</a>

section.

If you are a user of the old (0.x) series of LEMON, please check out the

\ref migration "Migration Guide" for the backward incompatibilities.

*/

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library.

 *

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 * (Egervary Research Group on Combinatorial Optimization, EGRES).

 *

 * Permission to use, modify and distribute this software is granted

 * provided that this copyright notice appears in all copies. For

 * precise terms see the accompanying LICENSE file.

 *

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any