COIN-OR::LEMON - Graph Library

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


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

hugo -> lemon

Location:
src/lemon
Files:
1 added
37 moved

Legend:

Unmodified
Added
Removed
  • src/lemon/array_map.h

    r906 r921  
    11/* -*- C++ -*-
    2  * src/hugo/array_map.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/lemon/array_map.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1515 */
    1616
    17 #ifndef HUGO_ARRAY_MAP_H
    18 #define HUGO_ARRAY_MAP_H
     17#ifndef LEMON_ARRAY_MAP_H
     18#define LEMON_ARRAY_MAP_H
    1919
    2020#include <memory>
    2121
    22 #include <hugo/map_iterator.h>
    23 #include <hugo/map_bits.h>
     22#include <lemon/map_iterator.h>
     23#include <lemon/map_bits.h>
    2424
    2525///\ingroup graphmaps
     
    2828///their elements dynamically.
    2929
    30 namespace hugo {
     30namespace lemon {
    3131
    3232
     
    347347}
    348348
    349 #endif //HUGO_ARRAY_MAP_H
     349#endif //LEMON_ARRAY_MAP_H
  • src/lemon/attic/debug.h

    r907 r921  
    11/* -*- C++ -*-
    2  * src/hugo/debug.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/lemon/debug.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1515 */
    1616
    17 #ifndef HUGO_DEBUG_H
    18 #define HUGO_DEBUG_H
     17#ifndef LEMON_DEBUG_H
     18#define LEMON_DEBUG_H
    1919
    2020//! \file
    2121//! \brief Basic definitions for debug control.
    2222
    23 namespace hugo {
     23namespace lemon {
    2424
    2525  //! Debug mode for testing/debugging
     
    6868
    6969}
    70 #endif // HUGO_DEBUG_H
     70#endif // LEMON_DEBUG_H
  • src/lemon/attic/error.h

    r907 r921  
    11/* -*- C++ -*-
    2  * src/hugo/error.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/lemon/error.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1515 */
    1616
    17 #ifndef HUGO_ERROR_H
    18 #define HUGO_ERROR_H
     17#ifndef LEMON_ERROR_H
     18#define LEMON_ERROR_H
    1919
    2020//! \ingroup misc
     
    2727
    2828
    29 namespace hugo {
     29namespace lemon {
    3030
    3131  /**
     
    7575
    7676# define FIXME(msg) \
    77     do { throw ::hugo::Exception() << "FIXME: " msg " (in: "    \
     77    do { throw ::lemon::Exception() << "FIXME: " msg " (in: "    \
    7878      __FILE__ ", " << __LINE__ << ")";                         \
    7979    } while(false)
    8080
    8181}
    82 #endif // HUGO_ERROR_H
     82#endif // LEMON_ERROR_H
  • src/lemon/attic/tight_edge_filter_map.h

    r919 r921  
    11/* -*- C++ -*-
    2  * src/hugo/tight_edge_filter_map.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/lemon/tight_edge_filter_map.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1515 */
    1616
    17 #ifndef HUGO_TIGHT_EDGE_FILTER_MAP_H
    18 #define HUGO_TIGHT_EDGE_FILTER_MAP_H
     17#ifndef LEMON_TIGHT_EDGE_FILTER_MAP_H
     18#define LEMON_TIGHT_EDGE_FILTER_MAP_H
    1919
    20 #include <hugo/maps.h>
     20#include <lemon/maps.h>
    2121
    2222// /// \file
     
    2424// /// \ingroup galgs
    2525
    26 namespace hugo {
     26namespace lemon {
    2727
    2828  /// \brief A map for filtering the edge-set to those edges
     
    5757  };
    5858
    59 } //namespace hugo
     59} //namespace lemon
    6060
    61 #endif //HUGO_TIGHT_EDGE_FILTER_MAP_H
     61#endif //LEMON_TIGHT_EDGE_FILTER_MAP_H
    6262
    6363
  • src/lemon/bfs.h

    r911 r921  
    11/* -*- C++ -*-
    2  * src/hugo/bfs.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/lemon/bfs.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1515 */
    1616
    17 #ifndef HUGO_BFS_H
    18 #define HUGO_BFS_H
     17#ifndef LEMON_BFS_H
     18#define LEMON_BFS_H
    1919
    2020///\ingroup flowalgs
     
    2424///\todo Revise Manual.
    2525
    26 #include <hugo/bin_heap.h>
    27 #include <hugo/invalid.h>
    28 
    29 namespace hugo {
     26#include <lemon/bin_heap.h>
     27#include <lemon/invalid.h>
     28
     29namespace lemon {
    3030
    3131/// \addtogroup flowalgs
     
    280280/// @}
    281281 
    282 } //END OF NAMESPACE HUGO
     282} //END OF NAMESPACE LEMON
    283283
    284284#endif
  • src/lemon/bin_heap.h

    r906 r921  
    11/* -*- C++ -*-
    2  * src/hugo/bin_heap.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/lemon/bin_heap.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1515 */
    1616
    17 #ifndef HUGO_BIN_HEAP_H
    18 #define HUGO_BIN_HEAP_H
     17#ifndef LEMON_BIN_HEAP_H
     18#define LEMON_BIN_HEAP_H
    1919
    2020///\ingroup auxdat
     
    2727#include <functional>
    2828
    29 namespace hugo {
     29namespace lemon {
    3030
    3131  /// \addtogroup auxdat
     
    199199  ///@}
    200200
    201 } // namespace hugo
    202 
    203 #endif // HUGO_BIN_HEAP_H
     201} // namespace lemon
     202
     203#endif // LEMON_BIN_HEAP_H
  • src/lemon/default_map.h

    r919 r921  
    11/* -*- C++ -*-
    2  * src/hugo/default_map.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/lemon/default_map.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1515 */
    1616
    17 #ifndef HUGO_DEFAULT_MAP_H
    18 #define HUGO_DEFAULT_MAP_H
     17#ifndef LEMON_DEFAULT_MAP_H
     18#define LEMON_DEFAULT_MAP_H
    1919
    2020
    21 #include <hugo/array_map.h>
    22 #include <hugo/vector_map.h>
     21#include <lemon/array_map.h>
     22#include <lemon/vector_map.h>
    2323
    2424///\ingroup graphmaps
     
    2727///their elements dynamically.
    2828
    29 namespace hugo {
     29namespace lemon {
    3030
    3131/// \addtogroup graphmaps
  • src/lemon/dfs.h

    r911 r921  
    11/* -*- C++ -*-
    2  * src/hugo/dfs.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/lemon/dfs.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1515 */
    1616
    17 #ifndef HUGO_DFS_H
    18 #define HUGO_DFS_H
     17#ifndef LEMON_DFS_H
     18#define LEMON_DFS_H
    1919
    2020///\ingroup flowalgs
     
    2424///\todo Revise Manual.
    2525
    26 #include <hugo/bin_heap.h>
    27 #include <hugo/invalid.h>
    28 
    29 namespace hugo {
     26#include <lemon/bin_heap.h>
     27#include <lemon/invalid.h>
     28
     29namespace lemon {
    3030
    3131/// \addtogroup flowalgs
     
    284284/// @}
    285285 
    286 } //END OF NAMESPACE HUGO
     286} //END OF NAMESPACE LEMON
    287287
    288288#endif
  • src/lemon/dijkstra.h

    r911 r921  
    11/* -*- C++ -*-
    2  * src/hugo/dijkstra.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/lemon/dijkstra.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1515 */
    1616
    17 #ifndef HUGO_DIJKSTRA_H
    18 #define HUGO_DIJKSTRA_H
     17#ifndef LEMON_DIJKSTRA_H
     18#define LEMON_DIJKSTRA_H
    1919
    2020///\ingroup flowalgs
     
    2222///\brief Dijkstra algorithm.
    2323
    24 #include <hugo/bin_heap.h>
    25 #include <hugo/invalid.h>
    26 
    27 namespace hugo {
     24#include <lemon/bin_heap.h>
     25#include <lemon/invalid.h>
     26
     27namespace lemon {
    2828
    2929/// \addtogroup flowalgs
     
    338338/// @}
    339339 
    340 } //END OF NAMESPACE HUGO
     340} //END OF NAMESPACE LEMON
    341341
    342342#endif
  • src/lemon/dimacs.h

    r906 r921  
    11/* -*- C++ -*-
    2  * src/hugo/dimacs.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/lemon/dimacs.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1515 */
    1616
    17 #ifndef HUGO_DIMACS_H
    18 #define HUGO_DIMACS_H
     17#ifndef LEMON_DIMACS_H
     18#define LEMON_DIMACS_H
    1919
    2020#include <iostream>
    2121#include <string>
    2222#include <vector>
    23 #include <hugo/maps.h>
     23#include <lemon/maps.h>
    2424
    2525/// \ingroup misc
     
    2727/// \brief Dimacs file format reader.
    2828
    29 namespace hugo {
     29namespace lemon {
    3030
    3131
     
    203203  /// @}
    204204
    205 } //namespace hugo
    206 
    207 #endif //HUGO_DIMACS_H
     205} //namespace lemon
     206
     207#endif //LEMON_DIMACS_H
  • src/lemon/extended_pair.h

    r906 r921  
    11/* -*- C++ -*-
    2  * src/hugo/extended_pair.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/lemon/extended_pair.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1515 */
    1616
    17 #ifndef HUGO_EXTENDED_PAIR_H
    18 #define HUGO_EXTENDED_PAIR_H
     17#ifndef LEMON_EXTENDED_PAIR_H
     18#define LEMON_EXTENDED_PAIR_H
    1919
    2020template <typename T1, typename A1, typename T2, typename A2>
  • src/lemon/fib_heap.h

    r911 r921  
    11/* -*- C++ -*-
    2  * src/hugo/fib_heap.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/lemon/fib_heap.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1515 */
    1616
    17 #ifndef HUGO_FIB_HEAP_H
    18 #define HUGO_FIB_HEAP_H
     17#ifndef LEMON_FIB_HEAP_H
     18#define LEMON_FIB_HEAP_H
    1919
    2020///\file
     
    2626#include <math.h>
    2727
    28 namespace hugo {
     28namespace lemon {
    2929 
    3030  /// \addtogroup auxdat
     
    505505  ///@}
    506506
    507 } //namespace hugo
    508 
    509 #endif //HUGO_FIB_HEAP_H
    510 
     507} //namespace lemon
     508
     509#endif //LEMON_FIB_HEAP_H
     510
  • src/lemon/full_graph.h

    r906 r921  
    11/* -*- C++ -*-
    2  * src/hugo/full_graph.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/lemon/full_graph.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1515 */
    1616
    17 #ifndef HUGO_FULL_GRAPH_H
    18 #define HUGO_FULL_GRAPH_H
     17#ifndef LEMON_FULL_GRAPH_H
     18#define LEMON_FULL_GRAPH_H
    1919
    2020///\ingroup graphs
     
    2525#include <climits>
    2626
    27 #include <hugo/invalid.h>
    28 
    29 #include <hugo/map_registry.h>
    30 #include <hugo/array_map.h>
    31 
    32 #include <hugo/map_defines.h>
    33 
    34 namespace hugo {
     27#include <lemon/invalid.h>
     28
     29#include <lemon/map_registry.h>
     30#include <lemon/array_map.h>
     31
     32#include <lemon/map_defines.h>
     33
     34namespace lemon {
    3535
    3636/// \addtogroup graphs
     
    241241  /// @} 
    242242
    243 } //namespace hugo
    244 
    245 
    246 
    247 
    248 #endif //HUGO_FULL_GRAPH_H
     243} //namespace lemon
     244
     245
     246
     247
     248#endif //LEMON_FULL_GRAPH_H
  • src/lemon/graph_wrapper.h

    r911 r921  
    11/* -*- C++ -*-
    2  * src/hugo/graph_wrapper.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/lemon/graph_wrapper.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1515 */
    1616
    17 #ifndef HUGO_GRAPH_WRAPPER_H
    18 #define HUGO_GRAPH_WRAPPER_H
     17#ifndef LEMON_GRAPH_WRAPPER_H
     18#define LEMON_GRAPH_WRAPPER_H
    1919
    2020///\ingroup gwrappers
     
    2626///\author Marton Makai
    2727
    28 #include <hugo/invalid.h>
    29 #include <hugo/maps.h>
    30 #include <hugo/map_defines.h>
     28#include <lemon/invalid.h>
     29#include <lemon/maps.h>
     30#include <lemon/map_defines.h>
    3131#include <iostream>
    3232
    33 namespace hugo {
     33namespace lemon {
    3434
    3535  // Graph wrappers
    3636
    3737  /// \addtogroup gwrappers
    38   /// A main parts of HUGOlib are the different graph structures,
     38  /// A main parts of LEMON are the different graph structures,
    3939  /// generic graph algorithms, graph concepts which couple these, and
    4040  /// graph wrappers. While the previous ones are more or less clear, the
     
    12221222  ///@}
    12231223
    1224 } //namespace hugo
    1225 
    1226 #endif //HUGO_GRAPH_WRAPPER_H
    1227 
     1224} //namespace lemon
     1225
     1226#endif //LEMON_GRAPH_WRAPPER_H
     1227
  • src/lemon/invalid.h

    r906 r921  
    11/* -*- C++ -*-
    2  * src/hugo/invalid.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/lemon/invalid.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1515 */
    1616
    17 #ifndef HUGO_INVALID_H
    18 #define HUGO_INVALID_H
     17#ifndef LEMON_INVALID_H
     18#define LEMON_INVALID_H
    1919
    2020///\file
    2121///\brief Definition of INVALID.
    2222
    23 namespace hugo {
     23namespace lemon {
    2424
    2525  /// Dummy type to make it easier to make invalid iterators.
     
    4747  const Invalid INVALID = Invalid();
    4848
    49 } //namespace hugo
     49} //namespace lemon
    5050
    5151#endif
  • src/lemon/kruskal.h

    r906 r921  
    11/* -*- C++ -*-
    2  * src/hugo/kruskal.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/lemon/kruskal.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1515 */
    1616
    17 #ifndef HUGO_KRUSKAL_H
    18 #define HUGO_KRUSKAL_H
     17#ifndef LEMON_KRUSKAL_H
     18#define LEMON_KRUSKAL_H
    1919
    2020#include <algorithm>
    21 #include <hugo/unionfind.h>
     21#include <lemon/unionfind.h>
    2222
    2323/**
     
    3737///Kruskal's algorithm to compute a minimum cost tree.
    3838
    39 namespace hugo {
     39namespace lemon {
    4040
    4141  /// \addtogroup spantree
     
    344344  /// @}
    345345
    346 } //namespace hugo
    347 
    348 #endif //HUGO_KRUSKAL_H
     346} //namespace lemon
     347
     348#endif //LEMON_KRUSKAL_H
  • src/lemon/list_graph.h

    r919 r921  
    11/* -*- C++ -*-
    2  * src/hugo/list_graph.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/lemon/list_graph.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1515 */
    1616
    17 #ifndef HUGO_LIST_GRAPH_H
    18 #define HUGO_LIST_GRAPH_H
     17#ifndef LEMON_LIST_GRAPH_H
     18#define LEMON_LIST_GRAPH_H
    1919
    2020///\ingroup graphs
     
    2525#include <climits>
    2626
    27 #include <hugo/invalid.h>
    28 
    29 #include <hugo/map_registry.h>
    30 #include <hugo/array_map.h>
    31 
    32 #include <hugo/sym_map.h>
    33 
    34 #include <hugo/map_defines.h>
    35 
    36 
    37 namespace hugo {
     27#include <lemon/invalid.h>
     28
     29#include <lemon/map_registry.h>
     30#include <lemon/array_map.h>
     31
     32#include <lemon/sym_map.h>
     33
     34#include <lemon/map_defines.h>
     35
     36
     37namespace lemon {
    3838
    3939/// \addtogroup graphs
     
    424424  ///of oppositely directed edges.
    425425  ///There is a new edge map type called
    426   ///\ref hugo::SymListGraph::SymEdgeMap "SymEdgeMap"
     426  ///\ref lemon::SymListGraph::SymEdgeMap "SymEdgeMap"
    427427  ///that complements this
    428428  ///feature by
    429429  ///storing shared values for the edge pairs. The usual
    430   ///\ref hugo::skeleton::StaticGraph::EdgeMap "EdgeMap"
     430  ///\ref lemon::skeleton::StaticGraph::EdgeMap "EdgeMap"
    431431  ///can be used
    432432  ///as well.
    433433  ///
    434434  ///The oppositely directed edge can also be obtained easily
    435   ///using \ref hugo::SymListGraph::opposite() "opposite()" member function.
     435  ///using \ref lemon::SymListGraph::opposite() "opposite()" member function.
    436436  ///
    437437  ///Here erase(Edge) deletes a pair of edges.
     
    11021102/// @} 
    11031103
    1104 } //namespace hugo
    1105 
    1106 #endif //HUGO_LIST_GRAPH_H
     1104} //namespace lemon
     1105
     1106#endif //LEMON_LIST_GRAPH_H
  • src/lemon/map_bits.h

    r919 r921  
    11/* -*- C++ -*-
    2  * src/hugo/map_bits.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/lemon/map_bits.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1515 */
    1616
    17 #ifndef HUGO_MAP_BITS_H
    18 #define HUGO_MAP_BITS_H
     17#ifndef LEMON_MAP_BITS_H
     18#define LEMON_MAP_BITS_H
    1919
    2020///\ingroup graphmaps
     
    2222///\brief Some utils to help implement maps.
    2323
    24 namespace hugo {
     24namespace lemon {
    2525
    2626
  • src/lemon/map_defines.h

    r919 r921  
    11/* -*- C++ -*-
    2  * src/hugo/map_defines.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/lemon/map_defines.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1515 */
    1616
    17 #ifndef HUGO_MAP_DEFINES_H
    18 #define HUGO_MAP_DEFINES_H
     17#ifndef LEMON_MAP_DEFINES_H
     18#define LEMON_MAP_DEFINES_H
    1919
    2020///\ingroup graphmaps
  • src/lemon/map_iterator.h

    r906 r921  
    11/* -*- C++ -*-
    2  * src/hugo/map_iterator.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/lemon/map_iterator.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1515 */
    1616
    17 #ifndef HUGO_MAP_ITERATOR_H
    18 #define HUGO_MAP_ITERATOR_H
     17#ifndef LEMON_MAP_ITERATOR_H
     18#define LEMON_MAP_ITERATOR_H
    1919
    2020#include <iterator>
    2121
    22 #include <hugo/extended_pair.h>
     22#include <lemon/extended_pair.h>
    2323
    2424///\ingroup graphmaps
     
    2626///\brief Iterators on the maps.
    2727
    28 namespace hugo {
     28namespace lemon {
    2929
    3030  /// \addtogroup graphmaps
  • src/lemon/map_registry.h

    r919 r921  
    11/* -*- C++ -*-
    2  * src/hugo/map_registry.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/lemon/map_registry.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1515 */
    1616
    17 #ifndef HUGO_MAP_REGISTRY_H
    18 #define HUGO_MAP_REGISTRY_H
     17#ifndef LEMON_MAP_REGISTRY_H
     18#define LEMON_MAP_REGISTRY_H
    1919
    2020#include <vector>
     
    2626using namespace std;
    2727
    28 namespace hugo {
     28namespace lemon {
    2929
    3030/// \addtogroup graphmapfactory
  • src/lemon/maps.h

    r911 r921  
    11/* -*- C++ -*-
    2  * src/hugo/maps.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/lemon/maps.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1515 */
    1616
    17 #ifndef HUGO_MAPS_H
    18 #define HUGO_MAPS_H
     17#ifndef LEMON_MAPS_H
     18#define LEMON_MAPS_H
    1919
    2020///\file
     
    2626#include <map>
    2727
    28 namespace hugo {
     28namespace lemon {
    2929
    3030  /// Base class of maps.
     
    174174 
    175175}
    176 #endif // HUGO_MAPS_H
     176#endif // LEMON_MAPS_H
  • src/lemon/min_cost_flow.h

    r910 r921  
    11/* -*- C++ -*-
    2  * src/hugo/min_cost_flow.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/lemon/min_cost_flow.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1515 */
    1616
    17 #ifndef HUGO_MIN_COST_FLOW_H
    18 #define HUGO_MIN_COST_FLOW_H
     17#ifndef LEMON_MIN_COST_FLOW_H
     18#define LEMON_MIN_COST_FLOW_H
    1919
    2020///\ingroup flowalgs
     
    2323
    2424
    25 #include <hugo/dijkstra.h>
    26 #include <hugo/graph_wrapper.h>
    27 #include <hugo/maps.h>
     25#include <lemon/dijkstra.h>
     26#include <lemon/graph_wrapper.h>
     27#include <lemon/maps.h>
    2828#include <vector>
    2929
    30 namespace hugo {
     30namespace lemon {
    3131
    3232/// \addtogroup flowalgs
     
    3737  ///
    3838  ///
    39   /// The class \ref hugo::MinCostFlow "MinCostFlow" implements
     39  /// The class \ref lemon::MinCostFlow "MinCostFlow" implements
    4040  /// an algorithm for finding a flow of value \c k
    4141  /// having minimal total cost
     
    252252  ///@}
    253253
    254 } //namespace hugo
    255 
    256 #endif //HUGO_MIN_COST_FLOW_H
     254} //namespace lemon
     255
     256#endif //LEMON_MIN_COST_FLOW_H
  • src/lemon/path.h

    r906 r921  
    11/* -*- C++ -*-
    2  * src/hugo/path.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/lemon/path.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1818@defgroup paths Path Structures
    1919@ingroup datas
    20 \brief Path structures implemented in Hugo.
    21 
    22 Hugolib provides flexible data structures
     20\brief Path structures implemented in LEMON.
     21
     22LEMON provides flexible data structures
    2323to work with paths.
    2424
     
    2727algorithm to store its result in any kind of path structure.
    2828
    29 \sa hugo::skeleton::Path
     29\sa lemon::skeleton::Path
    3030
    3131*/
     
    3535///\brief Classes for representing paths in graphs.
    3636
    37 #ifndef HUGO_PATH_H
    38 #define HUGO_PATH_H
     37#ifndef LEMON_PATH_H
     38#define LEMON_PATH_H
    3939
    4040#include <deque>
     
    4242#include <algorithm>
    4343
    44 #include <hugo/invalid.h>
    45 
    46 namespace hugo {
     44#include <lemon/invalid.h>
     45
     46namespace lemon {
    4747
    4848  /// \addtogroup paths
     
    705705  ///@}
    706706
    707 } // namespace hugo
    708 
    709 #endif // HUGO_PATH_H
     707} // namespace lemon
     708
     709#endif // LEMON_PATH_H
  • src/lemon/preflow.h

    r920 r921  
    11/* -*- C++ -*-
    2  * src/hugo/preflow.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/lemon/preflow.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1515 */
    1616
    17 #ifndef HUGO_PREFLOW_H
    18 #define HUGO_PREFLOW_H
     17#ifndef LEMON_PREFLOW_H
     18#define LEMON_PREFLOW_H
    1919
    2020#include <vector>
    2121#include <queue>
    2222
    23 #include <hugo/invalid.h>
    24 #include <hugo/maps.h>
     23#include <lemon/invalid.h>
     24#include <lemon/maps.h>
    2525
    2626/// \file
     
    2828/// Implementation of the preflow algorithm.
    2929
    30 namespace hugo {
     30namespace lemon {
    3131
    3232  /// \addtogroup flowalgs
     
    4545  ///setFlow.
    4646  ///
    47   ///After running \ref hugo::Preflow::phase1() "phase1()"
    48   ///or \ref hugo::Preflow::run() "run()", the maximal flow
     47  ///After running \ref lemon::Preflow::phase1() "phase1()"
     48  ///or \ref lemon::Preflow::run() "run()", the maximal flow
    4949  ///value can be obtained by calling \ref flowValue(). The minimum
    5050  ///value cut can be written into a <tt>bool</tt> node map by
     
    811811
    812812  };
    813 } //namespace hugo
    814 
    815 #endif //HUGO_PREFLOW_H
    816 
    817 
    818 
    819 
     813} //namespace lemon
     814
     815#endif //LEMON_PREFLOW_H
     816
     817
     818
     819
  • src/lemon/skeletons/graph.h

    r911 r921  
    11/* -*- C++ -*-
    2  * src/hugo/skeletons/graph.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/lemon/skeletons/graph.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1515 */
    1616
    17 #ifndef HUGO_SKELETON_GRAPH_H
    18 #define HUGO_SKELETON_GRAPH_H
     17#ifndef LEMON_SKELETON_GRAPH_H
     18#define LEMON_SKELETON_GRAPH_H
    1919
    2020///\ingroup skeletons
     
    2222///\brief Declaration of Graph.
    2323
    24 #include <hugo/invalid.h>
    25 #include <hugo/skeletons/maps.h>
    26 
    27 namespace hugo {
     24#include <lemon/invalid.h>
     25#include <lemon/skeletons/maps.h>
     26
     27namespace lemon {
    2828  namespace skeleton {
    2929   
     
    504504    // @}
    505505  } //namespace skeleton 
    506 } //namespace hugo
    507 
    508 
    509 
    510 #endif // HUGO_SKELETON_GRAPH_H
     506} //namespace lemon
     507
     508
     509
     510#endif // LEMON_SKELETON_GRAPH_H
  • src/lemon/skeletons/maps.h

    r906 r921  
    11/* -*- C++ -*-
    2  * src/hugo/skeletons/maps.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/lemon/skeletons/maps.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1515 */
    1616
    17 #ifndef HUGO_MAPSKELETON_H
    18 #define HUGO_MAPSKELETON_H
     17#ifndef LEMON_MAPSKELETON_H
     18#define LEMON_MAPSKELETON_H
    1919
    2020///\ingroup skeletons
     
    2222///\brief Map concepts checking classes for testing and documenting.
    2323
    24 namespace hugo {
     24namespace lemon {
    2525
    2626  namespace skeleton {
     
    117117
    118118  } //namespace skeleton
    119 } //namespace hugo
    120 #endif // HUGO_MAPSKELETON_H
     119} //namespace lemon
     120#endif // LEMON_MAPSKELETON_H
  • src/lemon/skeletons/path.h

    r906 r921  
    11/* -*- C++ -*-
    2  * src/hugo/skeletons/path.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/lemon/skeletons/path.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1919///\brief Classes for representing paths in graphs.
    2020
    21 #ifndef HUGO_SKELETON_PATH_H
    22 #define HUGO_SKELETON_PATH_H
    23 
    24 #include <hugo/invalid.h>
    25 
    26 namespace hugo {
     21#ifndef LEMON_SKELETON_PATH_H
     22#define LEMON_SKELETON_PATH_H
     23
     24#include <lemon/invalid.h>
     25
     26namespace lemon {
    2727  namespace skeleton {
    2828    /// \addtogroup skeletons
     
    232232  }
    233233
    234 } // namespace hugo
    235 
    236 #endif // HUGO_SKELETON_PATH_H
     234} // namespace lemon
     235
     236#endif // LEMON_SKELETON_PATH_H
  • src/lemon/smart_graph.h

    r919 r921  
    11/* -*- C++ -*-
    2  * src/hugo/smart_graph.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/lemon/smart_graph.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1515 */
    1616
    17 #ifndef HUGO_SMART_GRAPH_H
    18 #define HUGO_SMART_GRAPH_H
     17#ifndef LEMON_SMART_GRAPH_H
     18#define LEMON_SMART_GRAPH_H
    1919
    2020///\ingroup graphs
     
    2525#include <climits>
    2626
    27 #include <hugo/invalid.h>
    28 
    29 #include <hugo/array_map.h>
    30 #include <hugo/sym_map.h>
    31 
    32 #include <hugo/map_registry.h>
    33 
    34 #include <hugo/map_defines.h>
    35 
    36 namespace hugo {
     27#include <lemon/invalid.h>
     28
     29#include <lemon/array_map.h>
     30#include <lemon/sym_map.h>
     31
     32#include <lemon/map_registry.h>
     33
     34#include <lemon/map_defines.h>
     35
     36namespace lemon {
    3737
    3838/// \addtogroup graphs
     
    357357 
    358358  /// @} 
    359 } //namespace hugo
    360 
    361 
    362 
    363 
    364 #endif //HUGO_SMART_GRAPH_H
     359} //namespace lemon
     360
     361
     362
     363
     364#endif //LEMON_SMART_GRAPH_H
  • src/lemon/suurballe.h

    r906 r921  
    11/* -*- C++ -*-
    2  * src/hugo/suurballe.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/lemon/suurballe.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1515 */
    1616
    17 #ifndef HUGO_SUURBALLE_H
    18 #define HUGO_SUURBALLE_H
     17#ifndef LEMON_SUURBALLE_H
     18#define LEMON_SUURBALLE_H
    1919
    2020///\ingroup flowalgs
     
    2323
    2424
    25 #include <hugo/maps.h>
     25#include <lemon/maps.h>
    2626#include <vector>
    27 #include <hugo/min_cost_flow.h>
    28 
    29 namespace hugo {
     27#include <lemon/min_cost_flow.h>
     28
     29namespace lemon {
    3030
    3131/// \addtogroup flowalgs
     
    3535  /// of minimal total length
    3636  ///
    37   /// The class \ref hugo::Suurballe implements
     37  /// The class \ref lemon::Suurballe implements
    3838  /// an algorithm for finding k edge-disjoint paths
    3939  /// from a given source node to a given target node in an
     
    188188    ///then the result here will be an empty path (\c j can be 0 as well).
    189189    ///
    190     ///\param Path The type of the path structure to put the result to (must meet hugo path concept).
     190    ///\param Path The type of the path structure to put the result to (must meet lemon path concept).
    191191    ///\param p The path to put the result to
    192192    ///\param j Which path you want to get from the found paths (in a real application you would get the found paths iteratively)
     
    211211  ///@}
    212212
    213 } //namespace hugo
    214 
    215 #endif //HUGO_SUURBALLE_H
     213} //namespace lemon
     214
     215#endif //LEMON_SUURBALLE_H
  • src/lemon/sym_map.h

    r919 r921  
    11/* -*- C++ -*-
    2  * src/hugo/sym_map.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/lemon/sym_map.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1515 */
    1616
    17 #ifndef HUGO_SYM_MAP_H
    18 #define HUGO_SYM_MAP_H
     17#ifndef LEMON_SYM_MAP_H
     18#define LEMON_SYM_MAP_H
    1919
    2020///\ingroup graphmaps
     
    2323///their elements dynamically.
    2424
    25 namespace hugo {
     25namespace lemon {
    2626
    2727/// \addtogroup graphmaps
  • src/lemon/template.h

    r906 r921  
    11/* -*- C++ -*-
    2  * src/hugo/template.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/lemon/template.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1515 */
    1616
    17 #ifndef HUGO_TEMPLATE_H
    18 #define HUGO_TEMPLATE_H
     17#ifndef LEMON_TEMPLATE_H
     18#define LEMON_TEMPLATE_H
    1919
    20 #endif // HUGO_TEMPLATE_H
     20#endif // LEMON_TEMPLATE_H
  • src/lemon/time_measure.h

    r906 r921  
    11/* -*- C++ -*-
    2  * src/hugo/time_measure.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/lemon/time_measure.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1515 */
    1616
    17 #ifndef HUGO_TIME_MEASURE_H
    18 #define HUGO_TIME_MEASURE_H
     17#ifndef LEMON_TIME_MEASURE_H
     18#define LEMON_TIME_MEASURE_H
    1919
    2020///\ingroup misc
     
    2828#include <unistd.h>
    2929
    30 namespace hugo {
     30namespace lemon {
    3131
    3232  /// \addtogroup misc
     
    143143  ///It is quite easy-to-use, here is a short example.
    144144  ///\code
    145   ///#include<hugo/time_measure.h>
     145  ///#include<lemon/time_measure.h>
    146146  ///#include<iostream>
    147147  ///
     
    223223  /// @} 
    224224
    225 } //namespace hugo
    226 
    227 #endif //HUGO_TIME_MEASURE_H
     225} //namespace lemon
     226
     227#endif //LEMON_TIME_MEASURE_H
  • src/lemon/unionfind.h

    r914 r921  
    11/* -*- C++ -*-
    2  * src/hugo/unionfind.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/lemon/unionfind.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1515 */
    1616
    17 #ifndef HUGO_UNION_FIND_H
    18 #define HUGO_UNION_FIND_H
     17#ifndef LEMON_UNION_FIND_H
     18#define LEMON_UNION_FIND_H
    1919
    2020//!\ingroup auxdat
     
    3131#include <algorithm>
    3232
    33 #include <hugo/invalid.h>
    34 
    35 namespace hugo {
     33#include <lemon/invalid.h>
     34
     35namespace lemon {
    3636
    3737  //! \addtogroup auxdat
     
    720720  //! @}
    721721
    722 } //namespace hugo
    723 
    724 #endif //HUGO_UNION_FIND_H
     722} //namespace lemon
     723
     724#endif //LEMON_UNION_FIND_H
  • src/lemon/vector_map.h

    r906 r921  
    11/* -*- C++ -*-
    2  * src/hugo/vector_map.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/lemon/vector_map.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1515 */
    1616
    17 #ifndef HUGO_VECTOR_MAP_H
    18 #define HUGO_VECTOR_MAP_H
     17#ifndef LEMON_VECTOR_MAP_H
     18#define LEMON_VECTOR_MAP_H
    1919
    2020#include <vector>
    2121
    22 #include <hugo/map_iterator.h>
    23 #include <hugo/map_bits.h>
     22#include <lemon/map_iterator.h>
     23#include <lemon/map_bits.h>
    2424
    2525///\ingroup graphmaps
     
    2727///\brief Vector based graph maps.
    2828
    29 namespace hugo {
     29namespace lemon {
    3030 
    3131  /// \addtogroup graphmaps
  • src/lemon/xy.h

    r906 r921  
    11/* -*- C++ -*-
    2  * src/hugo/xy.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/lemon/xy.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1515 */
    1616
    17 #ifndef HUGO_XY_H
    18 #define HUGO_XY_H
     17#ifndef LEMON_XY_H
     18#define LEMON_XY_H
    1919
    2020#include <iostream>
     
    2424///\brief A simple two dimensional vector and a bounding box implementation
    2525///
    26 /// The class \ref hugo::xy "xy" implements
     26/// The class \ref lemon::xy "xy" implements
    2727///a two dimensional vector with the usual
    2828/// operations.
    2929///
    30 /// The class \ref hugo::BoundingBox "BoundingBox" can be used to determine
    31 /// the rectangular bounding box a set of \ref hugo::xy "xy"'s.
     30/// The class \ref lemon::BoundingBox "BoundingBox" can be used to determine
     31/// the rectangular bounding box a set of \ref lemon::xy "xy"'s.
    3232///
    3333///\author Attila Bernath
    3434
    3535
    36 namespace hugo {
     36namespace lemon {
    3737
    3838  /// \addtogroup misc
     
    244244
    245245
    246 } //namespace hugo
    247 
    248 #endif //HUGO_XY_H
     246} //namespace lemon
     247
     248#endif //LEMON_XY_H
Note: See TracChangeset for help on using the changeset viewer.