COIN-OR::LEMON - Graph Library

Changeset 921:818510fa3d99 in lemon-0.x for doc


Ignore:
Timestamp:
09/29/04 17:30:04 (15 years ago)
Author:
Alpar Juttner
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@1232
Message:

hugo -> lemon

Location:
doc
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • doc/coding_style.dox

    r811 r921  
    11/*!
    22
    3 \page coding_style Hugo Coding Style
     3\page coding_style LEMON Coding Style
    44
    55\section naming_conv Naming Conventions
     
    1010are met in one's code then it is easier to read and maintain
    1111it. Please comply with these conventions if you want to contribute
    12 developing Hugo library.
     12developing LEMON library.
    1313
    1414\subsection cs-class Classes and other types
  • doc/graphs.dox

    r911 r921  
    33\page graphs How to use graphs
    44
    5 The primary data structures of HugoLib are the graph classes. They all
     5The primary data structures of LEMON are the graph classes. They all
    66provide a node list - edge list interface, i.e. they have
    77functionalities to list the nodes and the edges of the graph as well
     
    1010
    1111Each graph should meet the
    12 \ref hugo::skeleton::StaticGraph "StaticGraph" concept.
     12\ref lemon::skeleton::StaticGraph "StaticGraph" concept.
    1313This concept does not
    1414makes it possible to change the graph (i.e. it is not possible to add
     
    1717
    1818The graphs meeting the
    19 \ref hugo::skeleton::ExtendableGraph "ExtendableGraph"
     19\ref lemon::skeleton::ExtendableGraph "ExtendableGraph"
    2020concept allow node and
    2121edge addition. You can also "clear" (i.e. erase all edges and nodes)
     
    2323
    2424In case of graphs meeting the full feature
    25 \ref hugo::skeleton::ErasableGraph "ErasableGraph"
     25\ref lemon::skeleton::ErasableGraph "ErasableGraph"
    2626concept
    2727you can also erase individual edges and node in arbitrary order.
    2828
    2929The implemented graph structures are the following.
    30 \li \ref hugo::ListGraph "ListGraph" is the most versatile graph class. It meets
    31 the \ref hugo::skeleton::ErasableGraph "ErasableGraph" concept
     30\li \ref lemon::ListGraph "ListGraph" is the most versatile graph class. It meets
     31the \ref lemon::skeleton::ErasableGraph "ErasableGraph" concept
    3232and it also have some convenience features.
    33 \li \ref hugo::SmartGraph "SmartGraph" is a more memory
    34 efficient version of \ref hugo::ListGraph "ListGraph". The
     33\li \ref lemon::SmartGraph "SmartGraph" is a more memory
     34efficient version of \ref lemon::ListGraph "ListGraph". The
    3535price of it is that it only meets the
    36 \ref hugo::skeleton::ExtendableGraph "ExtendableGraph" concept,
     36\ref lemon::skeleton::ExtendableGraph "ExtendableGraph" concept,
    3737so you cannot delete individual edges or nodes.
    38 \li \ref hugo::SymListGraph "SymListGraph" and
    39 \ref hugo::SymSmartGraph "SymSmartGraph" classes are very similar to
    40 \ref hugo::ListGraph "ListGraph" and \ref hugo::SmartGraph "SmartGraph".
     38\li \ref lemon::SymListGraph "SymListGraph" and
     39\ref lemon::SymSmartGraph "SymSmartGraph" classes are very similar to
     40\ref lemon::ListGraph "ListGraph" and \ref lemon::SmartGraph "SmartGraph".
    4141The difference is that whenever you add a
    4242new edge to the graph, it actually adds a pair of oppositely directed edges.
     
    4545attach data to the edges in such a way that the stored data
    4646are shared by the edge pairs.
    47 \li \ref hugo::FullGraph "FullGraph"
    48 implements a full graph. It is a \ref hugo::skeleton::StaticGraph, so you cannot
     47\li \ref lemon::FullGraph "FullGraph"
     48implements a full graph. It is a \ref lemon::skeleton::StaticGraph, so you cannot
    4949change the number of nodes once it is constructed. It is extremely memory
    5050efficient: it uses constant amount of memory independently from the number of
     
    5252\ref maps "EdgeMap"'s will depend on the number of nodes.
    5353
    54 \li \ref hugo::NodeSet "NodeSet" implements a graph with no edges. This class
    55 can be used as a base class of \ref hugo::EdgeSet "EdgeSet".
    56 \li \ref hugo::EdgeSet "EdgeSet" can be used to create a new graph on
     54\li \ref lemon::NodeSet "NodeSet" implements a graph with no edges. This class
     55can be used as a base class of \ref lemon::EdgeSet "EdgeSet".
     56\li \ref lemon::EdgeSet "EdgeSet" can be used to create a new graph on
    5757the node set of another graph. The base graph can be an arbitrary graph and it
    58 is possible to attach several \ref hugo::EdgeSet "EdgeSet"'s to a base graph.
     58is possible to attach several \ref lemon::EdgeSet "EdgeSet"'s to a base graph.
    5959
    6060\todo Don't we need SmartNodeSet and SmartEdgeSet?
     
    6666to dynamically attach data the to graph components.
    6767
    68 The following program demonstrates the basic features of HugoLib's graph
     68The following program demonstrates the basic features of LEMON's graph
    6969structures.
    7070
    7171\code
    7272#include <iostream>
    73 #include <hugo/list_graph.h>
     73#include <lemon/list_graph.h>
    7474
    75 using namespace hugo;
     75using namespace lemon;
    7676
    7777int main()
     
    8080\endcode
    8181
    82 ListGraph is one of HugoLib's graph classes. It is based on linked lists,
     82ListGraph is one of LEMON's graph classes. It is based on linked lists,
    8383therefore iterating throuh its edges and nodes is fast.
    8484
     
    115115step to the next node. Using operator++ on the iterator pointing to the last
    116116node invalidates the iterator i.e. sets its value to
    117 \ref hugo::INVALID "INVALID". This is what we exploit in the stop condition.
     117\ref lemon::INVALID "INVALID". This is what we exploit in the stop condition.
    118118
    119119The previous code fragment prints out the following:
     
    182182
    183183As we mentioned above, graphs are not containers rather
    184 incidence structures which are iterable in many ways. HugoLib introduces
     184incidence structures which are iterable in many ways. LEMON introduces
    185185concepts that allow us to attach containers to graphs. These containers are
    186186called maps.
  • doc/groups.dox

    r814 r921  
    22/**
    33@defgroup datas Data Structures
    4 This group describes the several graph structures implemented in HugoLib.
     4This group describes the several graph structures implemented in LEMON.
    55*/
    66
     
    88@defgroup graphs Graph Structures
    99@ingroup datas
    10 \brief Graph structures implemented in Hugo.
     10\brief Graph structures implemented in LEMON.
    1111
    12 Hugolib provides several data structures to meet the diverging requirements
     12LEMON provides several data structures to meet the diverging requirements
    1313of the possible users.
    1414In order to save on running time or on memory usage, some structures may
     
    1616some graph features like edge or node deletion.
    1717
    18 Hugolib also offers special graphs that cannot be used alone but only
     18LEMON also offers special graphs that cannot be used alone but only
    1919in conjunction with other graph representation. The examples for this are
    20 \ref hugo::EdgeSet "EdgeSet", \ref hugo::NodeSet "NodeSet"
     20\ref lemon::EdgeSet "EdgeSet", \ref lemon::NodeSet "NodeSet"
    2121and the large variety of \ref gwrappers "graph wrappers".
    2222
     
    2929@defgroup auxdat Auxiliary Data Structures
    3030@ingroup datas
    31 \brief Some data structures implemented in HugoLib.
     31\brief Some data structures implemented in LEMON.
    3232
    33 This group describes the data structures implemented in HugoLib in
     33This group describes the data structures implemented in LEMON in
    3434order to make it easier to implement combinatorial algorithms.
    3535*/
     
    5353@defgroup galgs Graph Algorithms
    5454\brief This group describes the several graph algorithms
    55 implemented in HugoLib.
     55implemented in LEMON.
    5656*/
    5757
     
    7373\brief Skeletons (a.k.a. concept checking classes)
    7474
    75 This group describes the data/algorithm skeletons implemented in HugoLib in
     75This group describes the data/algorithm skeletons implemented in LEMON in
    7676order to make it easier to check if a certain template class or
    7777template function is correctly implemented.
  • doc/mainpage.dox

    r678 r921  
    44\section intro Introduction
    55
    6 \subsection whatis What is HugoLib
     6\subsection whatis What is LEMON
    77
    8 HugoLib stands for Hungarian Graph Optimization Library.
     8LEMON stands for
     9<it>L</it>ibrary of <it>E</it>fficient <it>M</it>odels
     10and <it>O</it>ptimization in <it>N</it>etworks.
    911It is a C++ template
    1012library aimed at combinatorial optimization tasks which
     
    1517\subsection howtoread How to read this document
    1618
    17 Graph structures play central role in HugoLib, so if you are new to it,
     19Graph structures play central role in LEMON, so if you are new to it,
    1820you probably should start \ref graphs "here".
    1921You can also find this page along with others under
  • doc/maps.dox

    r697 r921  
    55\page maps Maps
    66
    7 Maps play central role in HUGOlib. As their name suggests, they map a
     7Maps play central role in LEMON. As their name suggests, they map a
    88certain range of \e keys to certain \e values. Each map has two
    99<tt>typedef</tt>'s to determine the types of keys and values, like this:
     
    2222where it is stored.
    2323
    24 Each graph structure in HUGOlib provides two standard map templates called
     24Each graph structure in LEMON provides two standard map templates called
    2525\c EdgeMap and \c NodeMap. Both are reference maps and you can easily
    2626assign data to the nodes and to the edges of the graph. For example if you
     
    7070The readable maps are very frequently used as the input of the
    7171algorithms.  For this purpose the most straightforward way is the use of the
    72 default maps provided by Hugo's graph structures.
     72default maps provided by LEMON's graph structures.
    7373Very often however, it is more
    7474convenient and/or more efficient to write your own readable map.
  • doc/namespaces.dox

    r882 r921  
    1 /// The namespace of HugoLib
     1/// The namespace of LEMON
    22
    33/// \todo Some more detailed description would be nice here.
    44///
    5 namespace hugo {
     5namespace lemon {
    66
    7   /// The namespace of HUGOlib concepts and concept checking classes
     7  /// The namespace of LEMON concepts and concept checking classes
    88
    99  /// \todo Some more detailed description would be nice here.
Note: See TracChangeset for help on using the changeset viewer.