COIN-OR::LEMON - Graph Library

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


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
Files:
1 added
136 edited
37 moved

Legend:

Unmodified
Added
Removed
  • src/Makefile.am

    r841 r921  
    1 SUBDIRS = hugo benchmark test
     1SUBDIRS = lemon benchmark test
  • src/benchmark/bench_tools.h

    r750 r921  
    11// -*- mode:C++ -*-
    2 #ifndef HUGO_BENCH_TEST_H
    3 #define HUGO_BENCH_TEST_H
     2#ifndef LEMON_BENCH_TEST_H
     3#define LEMON_BENCH_TEST_H
    44
    55#include<vector>
    66#include<iostream>
    77
    8 #include<hugo/time_measure.h>
     8#include<lemon/time_measure.h>
    99
    1010///An experimental typedef factory
     
    7575};
    7676
    77 inline void PrintTime(char *ID,hugo::Timer &T)
     77inline void PrintTime(char *ID,lemon::Timer &T)
    7878{
    79   hugo::TimeStamp S(T);
     79  lemon::TimeStamp S(T);
    8080  std::cout << ID << ' ' << S.getUserTime() << ' '
    8181            << S.getSystemTime() << ' ' << S.getRealTime() << std::endl;
  • src/benchmark/bfs-bench.cc

    r839 r921  
    33#include <queue>
    44#include<math.h>
    5 #include<hugo/smart_graph.h>
     5#include<lemon/smart_graph.h>
    66#include"bench_tools.h"
    77
    88using namespace std;
    9 using namespace hugo;
     9using namespace lemon;
    1010
    1111inline int numOfOnes(int n,int dim)
  • src/benchmark/graph-bench.cc

    r718 r921  
    11#include<math.h>
    2 #include<hugo/list_graph.h>
     2#include<lemon/list_graph.h>
    33
    44#include"bench_tools.h"
    55
    6 using namespace hugo;
     6using namespace lemon;
    77
    88///Makes a full graph by adding and deleting a lot of edges;
     
    4646int main()
    4747{
    48   hugo::Timer T;
     48  lemon::Timer T;
    4949  makeFullGraph<ListGraph>(nextPrim(1000),nextPrim(300),nextPrim(100));
    5050 
  • src/benchmark/hcube.cc

    r905 r921  
    22
    33#include<math.h>
    4 #include<hugo/list_graph.h>
    5 #include<hugo/smart_graph.h>
    6 #include<hugo/dijkstra.h>
    7 #include<hugo/preflow.h>
     4#include<lemon/list_graph.h>
     5#include<lemon/smart_graph.h>
     6#include<lemon/dijkstra.h>
     7#include<lemon/preflow.h>
    88
    99#include"bench_tools.h"
    1010
    1111using namespace std;
    12 using namespace hugo;
     12using namespace lemon;
    1313
    1414inline int numOfOnes(int n,int dim)
  • src/demo/sub_graph_wrapper_demo.cc

    r888 r921  
    99#include <fstream>
    1010
    11 #include <hugo/smart_graph.h>
    12 #include <hugo/dijkstra.h>
    13 #include <hugo/maps.h>
    14 #include <hugo/graph_wrapper.h>
    15 #include <hugo/dimacs.h>
    16 #include <hugo/preflow.h>
    17 #include <hugo/tight_edge_filter_map.h>
     11#include <lemon/smart_graph.h>
     12#include <lemon/dijkstra.h>
     13#include <lemon/maps.h>
     14#include <lemon/graph_wrapper.h>
     15#include <lemon/dimacs.h>
     16#include <lemon/preflow.h>
     17#include <lemon/tight_edge_filter_map.h>
    1818
    19 using namespace hugo;
     19using namespace lemon;
    2020
    2121using std::cout;
  • 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
  • src/test/bfs_test.cc

    r906 r921  
    11/* -*- C++ -*-
    2  * src/test/bfs_test.cc - Part of HUGOlib, a generic C++ optimization library
     2 * src/test/bfs_test.cc - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1616
    1717#include "test_tools.h"
    18 #include <hugo/smart_graph.h>
    19 #include <hugo/bfs.h>
    20 #include<hugo/skeletons/graph.h>
     18#include <lemon/smart_graph.h>
     19#include <lemon/bfs.h>
     20#include<lemon/skeletons/graph.h>
    2121
    22 using namespace hugo;
     22using namespace lemon;
    2323
    2424const int PET_SIZE =5;
  • src/test/dfs_test.cc

    r906 r921  
    11/* -*- C++ -*-
    2  * src/test/dfs_test.cc - Part of HUGOlib, a generic C++ optimization library
     2 * src/test/dfs_test.cc - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1616
    1717#include "test_tools.h"
    18 #include <hugo/smart_graph.h>
    19 #include <hugo/dfs.h>
    20 #include<hugo/skeletons/graph.h>
     18#include <lemon/smart_graph.h>
     19#include <lemon/dfs.h>
     20#include<lemon/skeletons/graph.h>
    2121
    22 using namespace hugo;
     22using namespace lemon;
    2323
    2424const int PET_SIZE =5;
  • src/test/dijkstra_heap_test.cc

    r906 r921  
    11/* -*- C++ -*-
    2  * src/test/dijkstra_heap_test.cc - Part of HUGOlib, a generic C++ optimization library
     2 * src/test/dijkstra_heap_test.cc - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    2020
    2121//The input is a graph in standard dimacs format from the standard input (like
    22 //in /hugo_loc/testfiles/dimacs). It runs dijkstra.h on this graph with both
     22//in /lemon_loc/testfiles/dimacs). It runs dijkstra.h on this graph with both
    2323//heaps, checking two postconditions:
    2424
     
    3131#include <math.h>
    3232
    33 #include <hugo/smart_graph.h>
    34 #include <hugo/dimacs.h>
    35 #include <hugo/dijkstra.h>
    36 #include <hugo/time_measure.h>
    37 #include <hugo/bin_heap.h>
    38 #include <hugo/fib_heap.h>
     33#include <lemon/smart_graph.h>
     34#include <lemon/dimacs.h>
     35#include <lemon/dijkstra.h>
     36#include <lemon/time_measure.h>
     37#include <lemon/bin_heap.h>
     38#include <lemon/fib_heap.h>
    3939
    40 using namespace hugo;
     40using namespace lemon;
    4141
    4242int main(int, char **) {
  • src/test/dijkstra_test.cc

    r906 r921  
    11/* -*- C++ -*-
    2  * src/test/dijkstra_test.cc - Part of HUGOlib, a generic C++ optimization library
     2 * src/test/dijkstra_test.cc - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1616
    1717#include "test_tools.h"
    18 #include <hugo/smart_graph.h>
    19 #include <hugo/dijkstra.h>
    20 #include<hugo/skeletons/graph.h>
    21 #include<hugo/skeletons/maps.h>
    22 using namespace hugo;
     18#include <lemon/smart_graph.h>
     19#include <lemon/dijkstra.h>
     20#include<lemon/skeletons/graph.h>
     21#include<lemon/skeletons/maps.h>
     22using namespace lemon;
    2323
    2424const int PET_SIZE =5;
  • src/test/error_test.cc

    r906 r921  
    11/* -*- C++ -*-
    2  * src/test/error_test.cc - Part of HUGOlib, a generic C++ optimization library
     2 * src/test/error_test.cc - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1717#include <iostream>
    1818
    19 #include <hugo/error.h>
     19#include <lemon/error.h>
    2020#include "test_tools.h"
    21 using namespace hugo;
     21using namespace lemon;
    2222using std::cout;
    2323using std::endl;
  • src/test/graph_test.cc

    r919 r921  
    11/* -*- C++ -*-
    2  * src/test/graph_test.cc - Part of HUGOlib, a generic C++ optimization library
     2 * src/test/graph_test.cc - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1616
    1717#include<iostream>
    18 #include<hugo/smart_graph.h>
    19 #include<hugo/skeletons/graph.h>
    20 #include<hugo/list_graph.h>
    21 #include<hugo/full_graph.h>
     18#include<lemon/smart_graph.h>
     19#include<lemon/skeletons/graph.h>
     20#include<lemon/list_graph.h>
     21#include<lemon/full_graph.h>
    2222
    2323#include"test_tools.h"
     
    3434*/
    3535
    36 using namespace hugo;
     36using namespace lemon;
    3737
    3838template<class Graph> void bidirPetersen(Graph &G)
     
    6969
    7070//Compile Graph
    71 template void hugo::checkCompileStaticGraph<skeleton::StaticGraph>
     71template void lemon::checkCompileStaticGraph<skeleton::StaticGraph>
    7272(skeleton::StaticGraph &);
    7373
    74 template void hugo::checkCompileGraph<skeleton::ExtendableGraph>
     74template void lemon::checkCompileGraph<skeleton::ExtendableGraph>
    7575(skeleton::ExtendableGraph &);
    7676
    77 template void hugo::checkCompileErasableGraph<skeleton::ErasableGraph>
     77template void lemon::checkCompileErasableGraph<skeleton::ErasableGraph>
    7878(skeleton::ErasableGraph &);
    7979
    8080//Compile SmartGraph
    81 template void hugo::checkCompileGraph<SmartGraph>(SmartGraph &);
    82 template void hugo::checkCompileGraphFindEdge<SmartGraph>(SmartGraph &);
     81template void lemon::checkCompileGraph<SmartGraph>(SmartGraph &);
     82template void lemon::checkCompileGraphFindEdge<SmartGraph>(SmartGraph &);
    8383
    8484//Compile SymSmartGraph
    85 template void hugo::checkCompileGraph<SymSmartGraph>(SymSmartGraph &);
    86 template void hugo::checkCompileGraphFindEdge<SymSmartGraph>(SymSmartGraph &);
     85template void lemon::checkCompileGraph<SymSmartGraph>(SymSmartGraph &);
     86template void lemon::checkCompileGraphFindEdge<SymSmartGraph>(SymSmartGraph &);
    8787
    8888//Compile ListGraph
    89 template void hugo::checkCompileGraph<ListGraph>(ListGraph &);
    90 template void hugo::checkCompileErasableGraph<ListGraph>(ListGraph &);
    91 template void hugo::checkCompileGraphFindEdge<ListGraph>(ListGraph &);
     89template void lemon::checkCompileGraph<ListGraph>(ListGraph &);
     90template void lemon::checkCompileErasableGraph<ListGraph>(ListGraph &);
     91template void lemon::checkCompileGraphFindEdge<ListGraph>(ListGraph &);
    9292
    9393
    9494//Compile SymListGraph
    95 template void hugo::checkCompileGraph<SymListGraph>(SymListGraph &);
    96 template void hugo::checkCompileErasableGraph<SymListGraph>(SymListGraph &);
    97 template void hugo::checkCompileGraphFindEdge<SymListGraph>(SymListGraph &);
     95template void lemon::checkCompileGraph<SymListGraph>(SymListGraph &);
     96template void lemon::checkCompileErasableGraph<SymListGraph>(SymListGraph &);
     97template void lemon::checkCompileGraphFindEdge<SymListGraph>(SymListGraph &);
    9898
    9999//Compile FullGraph
    100 template void hugo::checkCompileStaticGraph<FullGraph>(FullGraph &);
    101 template void hugo::checkCompileGraphFindEdge<FullGraph>(FullGraph &);
     100template void lemon::checkCompileStaticGraph<FullGraph>(FullGraph &);
     101template void lemon::checkCompileGraphFindEdge<FullGraph>(FullGraph &);
    102102
    103103//Compile EdgeSet <ListGraph>
    104 template void hugo::checkCompileGraph<EdgeSet <ListGraph> >
     104template void lemon::checkCompileGraph<EdgeSet <ListGraph> >
    105105(EdgeSet <ListGraph> &);
    106 template void hugo::checkCompileGraphEraseEdge<EdgeSet <ListGraph> >
     106template void lemon::checkCompileGraphEraseEdge<EdgeSet <ListGraph> >
    107107(EdgeSet <ListGraph> &);
    108 template void hugo::checkCompileGraphFindEdge<EdgeSet <ListGraph> >
     108template void lemon::checkCompileGraphFindEdge<EdgeSet <ListGraph> >
    109109(EdgeSet <ListGraph> &);
    110110
    111111//Compile EdgeSet <NodeSet>
    112 template void hugo::checkCompileGraph<EdgeSet <NodeSet> >(EdgeSet <NodeSet> &);
    113 template void hugo::checkCompileGraphEraseEdge<EdgeSet <NodeSet> >
     112template void lemon::checkCompileGraph<EdgeSet <NodeSet> >(EdgeSet <NodeSet> &);
     113template void lemon::checkCompileGraphEraseEdge<EdgeSet <NodeSet> >
    114114(EdgeSet <NodeSet> &);
    115 template void hugo::checkCompileGraphFindEdge<EdgeSet <NodeSet> >
     115template void lemon::checkCompileGraphFindEdge<EdgeSet <NodeSet> >
    116116(EdgeSet <NodeSet> &);
    117117
  • src/test/graph_test.h

    r919 r921  
    11/* -*- C++ -*-
    2  * src/test/graph_test.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/test/graph_test.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1414 *
    1515 */
    16 #ifndef HUGO_TEST_GRAPH_TEST_H
    17 #define HUGO_TEST_GRAPH_TEST_H
     16#ifndef LEMON_TEST_GRAPH_TEST_H
     17#define LEMON_TEST_GRAPH_TEST_H
    1818
    1919
     
    2323//! \file
    2424//! \brief Some utility to  test graph classes.
    25 namespace hugo {
     25namespace lemon {
    2626
    2727  struct DummyType {
     
    320320
    321321 
    322 } //namespace hugo
     322} //namespace lemon
    323323
    324324
  • src/test/graph_wrapper_test.cc

    r906 r921  
    11/* -*- C++ -*-
    2  * src/test/graph_wrapper_test.cc - Part of HUGOlib, a generic C++ optimization library
     2 * src/test/graph_wrapper_test.cc - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1616
    1717#include<iostream>
    18 #include<hugo/smart_graph.h>
    19 #include<hugo/skeletons/graph.h>
    20 #include<hugo/list_graph.h>
    21 #include<hugo/full_graph.h>
    22 #include<hugo/graph_wrapper.h>
     18#include<lemon/smart_graph.h>
     19#include<lemon/skeletons/graph.h>
     20#include<lemon/list_graph.h>
     21#include<lemon/full_graph.h>
     22#include<lemon/graph_wrapper.h>
    2323
    2424#include"test/test_tools.h"
     
    3232*/
    3333
    34 using namespace hugo;
     34using namespace lemon;
    3535
    3636
  • src/test/kruskal_test.cc

    r906 r921  
    11/* -*- C++ -*-
    2  * src/test/kruskal_test.cc - Part of HUGOlib, a generic C++ optimization library
     2 * src/test/kruskal_test.cc - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1919
    2020#include "test_tools.h"
    21 #include <hugo/maps.h>
    22 #include <hugo/kruskal.h>
    23 #include <hugo/list_graph.h>
    24 #include <hugo/skeletons/maps.h>
    25 #include <hugo/skeletons/graph.h>
     21#include <lemon/maps.h>
     22#include <lemon/kruskal.h>
     23#include <lemon/list_graph.h>
     24#include <lemon/skeletons/maps.h>
     25#include <lemon/skeletons/graph.h>
    2626
    2727
    2828using namespace std;
    29 using namespace hugo;
     29using namespace lemon;
    3030
    3131void checkCompileKruskal()
  • src/test/min_cost_flow_test.cc

    r906 r921  
    11/* -*- C++ -*-
    2  * src/test/min_cost_flow_test.cc - Part of HUGOlib, a generic C++ optimization library
     2 * src/test/min_cost_flow_test.cc - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1717#include <iostream>
    1818#include "test_tools.h"
    19 #include <hugo/list_graph.h>
    20 #include <hugo/min_cost_flow.h>
     19#include <lemon/list_graph.h>
     20#include <lemon/min_cost_flow.h>
    2121//#include <path.h>
    2222//#include <maps.h>
    2323
    2424using namespace std;
    25 using namespace hugo;
     25using namespace lemon;
    2626
    2727
  • src/test/path_test.cc

    r906 r921  
    11/* -*- C++ -*-
    2  * src/test/path_test.cc - Part of HUGOlib, a generic C++ optimization library
     2 * src/test/path_test.cc - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1717#include <string>
    1818#include <iostream>
    19 #include <hugo/skeletons/path.h>
    20 #include <hugo/path.h>
    21 #include <hugo/list_graph.h>
     19#include <lemon/skeletons/path.h>
     20#include <lemon/path.h>
     21#include <lemon/list_graph.h>
    2222
    2323using namespace std;
    24 using namespace hugo;
     24using namespace lemon;
    2525using namespace skeleton;
    2626
  • src/test/preflow_test.cc

    r906 r921  
    11/* -*- C++ -*-
    2  * src/test/preflow_test.cc - Part of HUGOlib, a generic C++ optimization library
     2 * src/test/preflow_test.cc - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1919
    2020#include "test_tools.h"
    21 #include <hugo/smart_graph.h>
    22 #include <hugo/dimacs.h>
    23 #include <hugo/preflow.h>
    24 #include <hugo/skeletons/graph.h>
    25 #include <hugo/skeletons/maps.h>
    26 
    27 using namespace hugo;
     21#include <lemon/smart_graph.h>
     22#include <lemon/dimacs.h>
     23#include <lemon/preflow.h>
     24#include <lemon/skeletons/graph.h>
     25#include <lemon/skeletons/maps.h>
     26
     27using namespace lemon;
    2828
    2929void check_Preflow()
  • src/test/suurballe_test.cc

    r906 r921  
    11/* -*- C++ -*-
    2  * src/test/suurballe_test.cc - Part of HUGOlib, a generic C++ optimization library
     2 * src/test/suurballe_test.cc - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1616
    1717#include <iostream>
    18 #include <hugo/list_graph.h>
    19 #include <hugo/suurballe.h>
     18#include <lemon/list_graph.h>
     19#include <lemon/suurballe.h>
    2020//#include <path.h>
    2121#include "test_tools.h"
    2222
    2323using namespace std;
    24 using namespace hugo;
     24using namespace lemon;
    2525
    2626
  • src/test/test_tools.h

    r919 r921  
    11/* -*- C++ -*-
    2  * src/test/test_tools.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/test/test_tools.h - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1515 */
    1616
    17 #ifndef HUGO_TEST_TEST_TOOLS_H
    18 #define HUGO_TEST_TEST_TOOLS_H
     17#ifndef LEMON_TEST_TEST_TOOLS_H
     18#define LEMON_TEST_TEST_TOOLS_H
    1919
    2020//! \ingroup misc
  • src/test/test_tools_fail.cc

    r906 r921  
    11/* -*- C++ -*-
    2  * src/test/test_tools_fail.cc - Part of HUGOlib, a generic C++ optimization library
     2 * src/test/test_tools_fail.cc - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  • src/test/test_tools_pass.cc

    r906 r921  
    11/* -*- C++ -*-
    2  * src/test/test_tools_pass.cc - Part of HUGOlib, a generic C++ optimization library
     2 * src/test/test_tools_pass.cc - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  • src/test/time_measure_test.cc

    r906 r921  
    11/* -*- C++ -*-
    2  * src/test/time_measure_test.cc - Part of HUGOlib, a generic C++ optimization library
     2 * src/test/time_measure_test.cc - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1515 */
    1616
    17 #include <hugo/time_measure.h>
     17#include <lemon/time_measure.h>
    1818
    1919///\file \brief Test cases for time_measure.h
     
    2222
    2323
    24 using namespace hugo;
     24using namespace lemon;
    2525
    2626int main()
  • src/test/unionfind_test.cc

    r906 r921  
    11/* -*- C++ -*-
    2  * src/test/unionfind_test.cc - Part of HUGOlib, a generic C++ optimization library
     2 * src/test/unionfind_test.cc - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1717#include <iostream>
    1818
    19 #include <hugo/maps.h>
    20 #include <hugo/unionfind.h>
     19#include <lemon/maps.h>
     20#include <lemon/unionfind.h>
    2121#include "test_tools.h"
    2222
    23 using namespace hugo;
     23using namespace lemon;
    2424using namespace std;
    2525
  • src/test/xy_test.cc

    r906 r921  
    11/* -*- C++ -*-
    2  * src/test/xy_test.cc - Part of HUGOlib, a generic C++ optimization library
     2 * src/test/xy_test.cc - Part of LEMON, a generic C++ optimization library
    33 *
    44 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
     
    1515 */
    1616
    17 #include <hugo/xy.h>
     17#include <lemon/xy.h>
    1818#include <iostream>
    1919#include "test_tools.h"
    2020
    2121using namespace std;
    22 using namespace hugo;
     22using namespace lemon;
    2323int main()
    2424{
  • src/work/akos/loader_demo.cc

    r106 r921  
    55#include <loader.h>
    66
    7 using namespace hugo;
     7using namespace lemon;
    88
    99int main(int, char **) {
  • src/work/alpar/bfs-named-param.cc

    r744 r921  
    11// -*- mode:C++ -*-
    22
    3 #include <hugo/smart_graph.h>
    4 #include <hugo/maps.h>
     3#include <lemon/smart_graph.h>
     4#include <lemon/maps.h>
    55#include <vector>
    66#include <iostream>
    77
    8 using namespace hugo;
     8using namespace lemon;
    99
    1010struct _BFS_DEFAULT_VIS {};
  • src/work/alpar/boolmap_iter.cc

    r348 r921  
    33#include <smart_graph.h>
    44
    5 using namespace hugo;
     5using namespace lemon;
    66
    77///\todo This is only a static map!
  • src/work/alpar/f_ed_ka.h

    r108 r921  
    1212//#include <bfs_iterator.hh>
    1313
    14 namespace hugo {
     14namespace lemon {
    1515  template <typename Graph, typename FlowMap, typename CapacityMap>
    1616  typename FlowMap::ValueType maxFlow(Graph &G,
     
    115115  }
    116116 
    117 } // namespace hugo
     117} // namespace lemon
    118118
    119119#endif //EDMONDS_KARP_HH
  • src/work/alpar/f_ed_ka_demo.cc

    r118 r921  
    99#include "../marci/time_measure.h"
    1010
    11 using namespace hugo;
     11using namespace lemon;
    1212
    1313// Use a DIMACS max flow file as stdin.
  • src/work/alpar/gwrapper.h

    r147 r921  
    33#define GRAPH_WRAPPER_H
    44
    5 namespace hugo {
     5namespace lemon {
    66
    77template<typename G>
  • src/work/alpar/list_graph_demo.cc

    r880 r921  
    55#include <vector>
    66
    7 using namespace hugo;
     7using namespace lemon;
    88
    99typedef ListGraph Graph;
  • src/work/alpar/rw_nonref_map.cc

    r351 r921  
    22#include <smart_graph.h>
    33
    4 using namespace hugo;
     4using namespace lemon;
    55
    66template<class GG,class TT>
  • src/work/alpar/smart_graph_demo.cc

    r880 r921  
    55#include <vector>
    66
    7 using namespace hugo;
     7using namespace lemon;
    88
    99typedef SmartGraph Graph;
  • src/work/athos/bfs_test.cc

    r671 r921  
    55#include <sage_graph.h>
    66//#include <smart_graph.h>
    7 #include <hugo/dimacs.h>
    8 #include <hugo/time_measure.h>
    9 #include <hugo/for_each_macros.h>
     7#include <lemon/dimacs.h>
     8#include <lemon/time_measure.h>
     9#include <lemon/for_each_macros.h>
    1010#include <bfs_dfs.h>
    1111
    12 using namespace hugo;
     12using namespace lemon;
    1313
    1414int main() {
  • src/work/athos/dijkstra_at.h

    r250 r921  
    2525using namespace std;
    2626
    27 namespace hugo {
     27namespace lemon {
    2828
    2929  template <typename graph_type, typename T>
     
    119119
    120120
    121 }//namespace hugo
     121}//namespace lemon
    122122
    123123#endif //DIJKSTRA_AT
  • src/work/athos/dijkstra_demo.cc

    r250 r921  
    66#include <dijkstra_at.h>
    77
    8 using namespace hugo;
     8using namespace lemon;
    99
    1010
  • src/work/athos/kruskal.h

    r250 r921  
    88#include <union_find.h>
    99
    10 namespace hugo {
     10namespace lemon {
    1111 
    1212  template <typename graph_type, typename T>
     
    5757  }
    5858
    59 }//namespacc hugo
     59}//namespacc lemon
    6060
    6161#endif
  • src/work/athos/min_cost_flow.cc

    r672 r921  
    11#include <iostream>
    22//#include "test_tools.h"
    3 #include <hugo/list_graph.h>
     3#include <lemon/list_graph.h>
    44#include <mincostflow.h>
    55//#include <path.h>
     
    77
    88using namespace std;
    9 using namespace hugo;
     9using namespace lemon;
    1010
    1111
  • src/work/athos/mincostflow.h

    r672 r921  
    11// -*- c++ -*-
    2 #ifndef HUGO_MINCOSTFLOW_H
    3 #define HUGO_MINCOSTFLOW_H
     2#ifndef LEMON_MINCOSTFLOW_H
     3#define LEMON_MINCOSTFLOW_H
    44
    55///\ingroup galgs
     
    77///\brief An algorithm for finding the minimum cost flow of given value in an uncapacitated network
    88
    9 #include <hugo/dijkstra.h>
    10 #include <hugo/graph_wrapper.h>
    11 #include <hugo/maps.h>
     9#include <lemon/dijkstra.h>
     10#include <lemon/graph_wrapper.h>
     11#include <lemon/maps.h>
    1212#include <vector>
    1313#include <list>
    1414#include <values.h>
    15 #include <hugo/for_each_macros.h>
    16 #include <hugo/unionfind.h>
    17 #include <hugo/bin_heap.h>
     15#include <lemon/for_each_macros.h>
     16#include <lemon/unionfind.h>
     17#include <lemon/bin_heap.h>
    1818#include <bfs_dfs.h>
    1919
    20 namespace hugo {
     20namespace lemon {
    2121
    2222/// \addtogroup galgs
     
    2727  ///
    2828  ///
    29   /// The class \ref hugo::MinCostFlow "MinCostFlow" implements
     29  /// The class \ref lemon::MinCostFlow "MinCostFlow" implements
    3030  /// an algorithm for solving the following general minimum cost flow problem>
    3131  ///
     
    509509  ///@}
    510510
    511 } //namespace hugo
    512 
    513 #endif //HUGO_MINCOSTFLOW_H
     511} //namespace lemon
     512
     513#endif //LEMON_MINCOSTFLOW_H
  • src/work/athos/minlength_demo.cc

    r607 r921  
    33
    44#include <list_graph.h>
    5 #include <hugo/dimacs.h>
    6 #include <hugo/time_measure.h>
     5#include <lemon/dimacs.h>
     6#include <lemon/time_measure.h>
    77#include "minlengthpaths.h"
    88//#include <time_measure.h>
    99
    10 using namespace hugo;
     10using namespace lemon;
    1111
    1212// Use a DIMACS max flow file as stdin.
  • src/work/athos/old/minlengthpaths.h

    r607 r921  
    11// -*- c++ -*-
    2 #ifndef HUGO_MINLENGTHPATHS_H
    3 #define HUGO_MINLENGTHPATHS_H
     2#ifndef LEMON_MINLENGTHPATHS_H
     3#define LEMON_MINLENGTHPATHS_H
    44
    55///\ingroup galgs
     
    88
    99#include <iostream>
    10 #include <hugo/dijkstra.h>
    11 #include <hugo/graph_wrapper.h>
    12 #include <hugo/maps.h>
     10#include <lemon/dijkstra.h>
     11#include <lemon/graph_wrapper.h>
     12#include <lemon/maps.h>
    1313#include <vector>
    1414
    1515
    16 namespace hugo {
     16namespace lemon {
    1717
    1818/// \addtogroup galgs
     
    2222  /// of minimal total length
    2323  ///
    24   /// The class \ref hugo::MinLengthPaths "MinLengthPaths" implements
     24  /// The class \ref lemon::MinLengthPaths "MinLengthPaths" implements
    2525  /// an algorithm for finding k edge-disjoint paths
    2626  /// from a given source node to a given target node in an
     
    198198  ///@}
    199199
    200 } //namespace hugo
    201 
    202 #endif //HUGO_MINLENGTHPATHS_H
     200} //namespace lemon
     201
     202#endif //LEMON_MINLENGTHPATHS_H
  • src/work/athos/pf_demo.cc

    r331 r921  
    88#include "preflow_push.hh"
    99
    10 using namespace hugo;
     10using namespace lemon;
    1111
    1212
  • src/work/athos/preflow_push_wogw.h

    r331 r921  
    1 #ifndef HUGO_PREFLOW_PUSH_HH
    2 #define HUGO_PREFLOW_PUSH_HH
     1#ifndef LEMON_PREFLOW_PUSH_HH
     2#define LEMON_PREFLOW_PUSH_HH
    33
    44//#include <algorithm>
     
    1414using namespace std;
    1515
    16 namespace hugo {
     16namespace lemon {
    1717
    1818  template <typename Graph, typename T>
     
    459459
    460460
    461 }//namespace hugo
     461}//namespace lemon
    462462
    463463#endif //PREFLOW_PUSH_HH
  • src/work/athos/suurballe.cc

    r314 r921  
    77#include <minlengthpaths.h>
    88
    9 using namespace hugo;
     9using namespace lemon;
    1010
    1111
  • src/work/athos/uf_demo.cc

    r250 r921  
    55#include <iostream>
    66#include <list_graph.hh>
    7 using namespace hugo;
     7using namespace lemon;
    88using namespace std;
    99
  • src/work/athos/union_find.h

    r250 r921  
    1414
    1515
    16 namespace hugo {
     16namespace lemon {
    1717 
    1818  template <typename KeyType, typename KeyIntMap>
     
    9191  };
    9292 
    93 }//namespace hugo
     93}//namespace lemon
    9494#endif
  • src/work/athos/xy/boundingbox.cc

    r244 r921  
    33#include <iostream>
    44using namespace std;
    5 using namespace hugo;
     5using namespace lemon;
    66int main()
    77{
  • src/work/athos/xy/xy.cc

    r513 r921  
    33#include <vector>
    44using namespace std;
    5 using namespace hugo;
     5using namespace lemon;
    66
    77
  • src/work/bin_heap_demo.cc

    r618 r921  
    33#include <map>
    44
    5 #include <hugo/bin_heap.h>
     5#include <lemon/bin_heap.h>
    66
    7 using namespace hugo;
     7using namespace lemon;
    88using namespace std;
    99
  • src/work/deba/array_map_factory.h

    r703 r921  
    77#include "extended_pair.h"
    88
    9 namespace hugo {
     9namespace lemon {
    1010       
    1111  template <typename MapRegistry> class ArrayMapFactory {
  • src/work/deba/bin_heap.h

    r698 r921  
    5959
    6060
    61 #ifndef HUGO_BIN_HEAP_H
    62 #define HUGO_BIN_HEAP_H
     61#ifndef LEMON_BIN_HEAP_H
     62#define LEMON_BIN_HEAP_H
    6363
    6464///\ingroup auxdat
     
    7070#include <functional>
    7171
    72 namespace hugo {
     72namespace lemon {
    7373
    7474  /// \addtogroup auxdat
     
    242242  ///@}
    243243
    244 } // namespace hugo
     244} // namespace lemon
    245245
    246246#endif // BIN_HEAP_HH
  • src/work/deba/dijkstra.h

    r880 r921  
    11// -*- C++ -*-
    2 #ifndef HUGO_DIJKSTRA_H
    3 #define HUGO_DIJKSTRA_H
     2#ifndef LEMON_DIJKSTRA_H
     3#define LEMON_DIJKSTRA_H
    44
    55///\ingroup galgs
     
    77///\brief Dijkstra algorithm.
    88
    9 #include <hugo/bin_heap.h>
    10 #include <hugo/invalid.h>
    11 
    12 namespace hugo {
     9#include <lemon/bin_heap.h>
     10#include <lemon/invalid.h>
     11
     12namespace lemon {
    1313
    1414/// \addtogroup galgs
     
    323323/// @}
    324324 
    325 } //END OF NAMESPACE HUGO
     325} //END OF NAMESPACE LEMON
    326326
    327327#endif
  • src/work/deba/invalid.h

    r701 r921  
    11// -*- mode:C++ -*-
    22
    3 #ifndef HUGO_INVALID_H
    4 #define HUGO_INVALID_H
     3#ifndef LEMON_INVALID_H
     4#define LEMON_INVALID_H
    55
    66///\file
    77///\brief Definition of INVALID.
    88
    9 namespace hugo {
     9namespace lemon {
    1010
    1111  /// Dummy type to make it easier to make invalid iterators.
     
    3333  const Invalid INVALID = Invalid();
    3434
    35 } //namespace hugo
     35} //namespace lemon
    3636
    3737#endif
  • src/work/deba/list_graph.h

    r880 r921  
    11// -*- mode:C++ -*-
    22
    3 #ifndef HUGO_LIST_GRAPH_H
    4 #define HUGO_LIST_GRAPH_H
     3#ifndef LEMON_LIST_GRAPH_H
     4#define LEMON_LIST_GRAPH_H
    55
    66///\ingroup graphs
     
    1818#include "map_defines.h"
    1919
    20 namespace hugo {
     20namespace lemon {
    2121
    2222/// \addtogroup graphs
     
    397397}
    398398
    399 #endif //HUGO_LIST_GRAPH_H
     399#endif //LEMON_LIST_GRAPH_H
  • src/work/deba/map_registry.h

    r703 r921  
    66using namespace std;
    77
    8 namespace hugo {
     8namespace lemon {
    99
    1010/**
  • src/work/deba/pac_map_factory.h

    r595 r921  
    99*/
    1010
    11 namespace hugo {
     11namespace lemon {
    1212       
    1313        template <typename G, typename K, typename KIt, template <typename, typename> class PAC>
  • src/work/deba/vector_map_factory.h

    r703 r921  
    77#include "extended_pair.h"
    88
    9 namespace hugo {
     9namespace lemon {
    1010
    1111  /** The VectorMapFactory template class is a factory class
  • src/work/iterator_bfs_dfs_demo.cc

    r107 r921  
    66#include <bfs_iterator.hh>
    77
    8 using namespace hugo;
     8using namespace lemon;
    99
    1010int main (int, char*[])
  • src/work/jacint/graph_gen.h

    r605 r921  
    1111// ///\author Marton Makai
    1212
    13 namespace hugo {
     13namespace lemon {
    1414
    1515
     
    118118  }
    119119 
    120 } //namespace hugo
     120} //namespace lemon
  • src/work/jacint/ledacomp.cc

    r581 r921  
    4242// }
    4343
    44 using namespace hugo;
     44using namespace lemon;
    4545
    4646int main() {
  • src/work/jacint/max_flow.h

    r709 r921  
    11// -*- C++ -*-
    2 #ifndef HUGO_MAX_FLOW_H
    3 #define HUGO_MAX_FLOW_H
     2#ifndef LEMON_MAX_FLOW_H
     3#define LEMON_MAX_FLOW_H
    44
    55#include <vector>
     
    77#include <stack>
    88
    9 #include <hugo/graph_wrapper.h>
     9#include <lemon/graph_wrapper.h>
    1010#include <bfs_dfs.h>
    11 #include <hugo/invalid.h>
    12 #include <hugo/maps.h>
    13 #include <hugo/for_each_macros.h>
     11#include <lemon/invalid.h>
     12#include <lemon/maps.h>
     13#include <lemon/for_each_macros.h>
    1414
    1515/// \file
     
    1717/// \ingroup galgs
    1818
    19 namespace hugo {
     19namespace lemon {
    2020
    2121  /// \addtogroup galgs
     
    11941194
    11951195      dfs.pushAndSetReached
    1196         ///\bug hugo 0.2
     1196        ///\bug lemon 0.2
    11971197        (typename ErasingResGW::Node
    11981198         (typename FilterResGW::Node
     
    12611261
    12621262
    1263 } //namespace hugo
    1264 
    1265 #endif //HUGO_MAX_FLOW_H
    1266 
    1267 
    1268 
    1269 
     1263} //namespace lemon
     1264
     1265#endif //LEMON_MAX_FLOW_H
     1266
     1267
     1268
     1269
  • src/work/jacint/max_flow_bug.cc

    r757 r921  
    11#include <iostream>
    22
    3 //#include <hugo/list_graph.h>
     3//#include <lemon/list_graph.h>
    44#include <sage_graph.h>
    5 #include <hugo/dimacs.h>
    6 #include <hugo/max_flow.h>
     5#include <lemon/dimacs.h>
     6#include <lemon/max_flow.h>
    77//#include <max_flow_no_stack.h>
    8 #include <hugo/time_measure.h>
     8#include <lemon/time_measure.h>
    99
    10 using namespace hugo;
     10using namespace lemon;
    1111
    1212int main(int, char **) {
  • src/work/jacint/max_flow_test.cc

    r757 r921  
    11#include <iostream>
    22
    3 #include <hugo/list_graph.h>
    4 #include <hugo/dimacs.h>
     3#include <lemon/list_graph.h>
     4#include <lemon/dimacs.h>
    55#include <max_flow.h>
    66#include <max_flow_no_stack.h>
    7 #include <hugo/time_measure.h>
     7#include <lemon/time_measure.h>
    88
    9 using namespace hugo;
     9using namespace lemon;
    1010
    1111int main(int, char **) {
  • src/work/jacint/max_matching.cc

    r536 r921  
    1111#include <graph_wrapper.h>
    1212
    13 using namespace hugo;
     13using namespace lemon;
    1414
    1515int main(int, char **) {
  • src/work/jacint/max_matching.h

    r682 r921  
    11// -*- C++ -*-
    2 #ifndef HUGO_MAX_MATCHING_H
    3 #define HUGO_MAX_MATCHING_H
     2#ifndef LEMON_MAX_MATCHING_H
     3#define LEMON_MAX_MATCHING_H
    44
    55///\ingroup galgs
     
    1212#include <unionfind.h>
    1313
    14 namespace hugo {
     14namespace lemon {
    1515
    1616  /// \addtogroup galgs
     
    565565  /// @}
    566566 
    567 } //END OF NAMESPACE HUGO
     567} //END OF NAMESPACE LEMON
    568568
    569569#endif //EDMONDS_H
  • src/work/jacint/max_save.h

    r620 r921  
    11// -*- C++ -*-
    2 #ifndef HUGO_MAX_FLOW_H
    3 #define HUGO_MAX_FLOW_H
     2#ifndef LEMON_MAX_FLOW_H
     3#define LEMON_MAX_FLOW_H
    44
    55///\ingroup galgs
     
    2323/// \brief Dimacs file format reader.
    2424
    25 namespace hugo {
     25namespace lemon {
    2626
    2727  /// \addtogroup galgs
     
    11281128  /// @}
    11291129 
    1130 } //END OF NAMESPACE HUGO
    1131 
    1132 #endif //HUGO_MAX_FLOW_H
    1133 
    1134 
    1135 
    1136 
     1130} //END OF NAMESPACE LEMON
     1131
     1132#endif //LEMON_MAX_FLOW_H
     1133
     1134
     1135
     1136
  • src/work/jacint/preflow.cc

    r470 r921  
    66#include <time_measure.h>
    77
    8 using namespace hugo;
     8using namespace lemon;
    99
    1010int main(int, char **) {
  • src/work/jacint/preflow_excess.h

    r437 r921  
    4444*/
    4545
    46 #ifndef HUGO_PREFLOW_H
    47 #define HUGO_PREFLOW_H
     46#ifndef LEMON_PREFLOW_H
     47#define LEMON_PREFLOW_H
    4848
    4949#define H0 20
     
    5454#include <stack>
    5555
    56 namespace hugo {
     56namespace lemon {
    5757
    5858  template <typename Graph, typename T,
     
    656656  };
    657657
    658 } //namespace hugo
     658} //namespace lemon
    659659
    660660#endif //PREFLOW_H
  • src/work/jacint/preflow_excess_test.cc

    r437 r921  
    1212#include <time_measure.h>
    1313
    14 using namespace hugo;
     14using namespace lemon;
    1515
    1616int main(int, char **) {
  • src/work/jacint/preflow_res.h

    r444 r921  
    11// -*- C++ -*-
    22//The same as preflow.h, using ResGraphWrapper
    3 #ifndef HUGO_PREFLOW_RES_H
    4 #define HUGO_PREFLOW_RES_H
     3#ifndef LEMON_PREFLOW_RES_H
     4#define LEMON_PREFLOW_RES_H
    55
    66#define H0 20
     
    1313#include<iostream>
    1414
    15 namespace hugo {
     15namespace lemon {
    1616
    1717  template <typename Graph, typename T,
     
    487487  };
    488488
    489 } //namespace hugo
    490 
    491 #endif //HUGO_PREFLOW_RES_H
    492 
    493 
    494 
    495 
     489} //namespace lemon
     490
     491#endif //LEMON_PREFLOW_RES_H
     492
     493
     494
     495
  • src/work/jacint/prim.cc

    r258 r921  
    1111#include <fib_heap.h>
    1212
    13 using namespace hugo;
     13using namespace lemon;
    1414
    1515int main(int, char **) {
  • src/work/jacint/prim.h

    r211 r921  
    3030 */
    3131
    32 #ifndef HUGO_PRIM_H
    33 #define HUGO_PRIM_H
     32#ifndef LEMON_PRIM_H
     33#define LEMON_PRIM_H
    3434
    3535#include <fib_heap.h>
    3636#include <invalid.h>
    3737
    38 namespace hugo {
     38namespace lemon {
    3939
    4040  template <typename Graph, typename T,
  • src/work/johanna/contract_wrapper.h

    r394 r921  
    11// -*- C++ -*- //
    22
    3 #ifndef HUGO_CONTRACT_WRAPPER
    4 #define HUGO_CONTRACT_WRAPPER
     3#ifndef LEMON_CONTRACT_WRAPPER
     4#define LEMON_CONTRACT_WRAPPER
    55
    66#include <graph_wrapper.h>
    77
    8 namespace hugo {
     8namespace lemon {
    99
    1010  template<typename Graph>
  • src/work/johanna/ma_order.h

    r350 r921  
    11// -*- C++ -*- //
    22
    3 #ifndef HUGO_MA_ORDER_H
    4 #define HUGO_MA_ORDER_H
     3#ifndef LEMON_MA_ORDER_H
     4#define LEMON_MA_ORDER_H
    55
    66#include <vector>
     
    88#include <bin_heap.h>
    99
    10 namespace hugo {
     10namespace lemon {
    1111
    1212  template <typename Graph,
     
    8383  };
    8484
    85 } // namespace hugo
     85} // namespace lemon
    8686
    87 #endif // HUGO_MA_ORDER_H
     87#endif // LEMON_MA_ORDER_H
  • src/work/johanna/ma_order_test.cc

    r350 r921  
    99
    1010using namespace std;
    11 using namespace hugo;
     11using namespace lemon;
    1212
    1313int main() {
  • src/work/klao/debug.h

    r680 r921  
    11// -*- C++ -*- //
    22
    3 #ifndef HUGO_DEBUG_H
    4 #define HUGO_DEBUG_H
     3#ifndef LEMON_DEBUG_H
     4#define LEMON_DEBUG_H
    55
    66//! \file
    77//! \brief Basic definitions for debug control.
    88
    9 namespace hugo {
     9namespace lemon {
    1010
    1111  //! Debug mode for testing/debugging
     
    5454
    5555}
    56 #endif // HUGO_DEBUG_H
     56#endif // LEMON_DEBUG_H
  • src/work/klao/iter_map.h

    r555 r921  
    11// -*- c++ -*- //
    22
    3 #ifndef HUGO_ITER_MAP
    4 #define HUGO_ITER_MAP
     3#ifndef LEMON_ITER_MAP
     4#define LEMON_ITER_MAP
    55
    66#include <vector>
     
    1111#include <cstring>
    1212
    13 #include <hugo/invalid.h>
     13#include <lemon/invalid.h>
    1414
    15 namespace hugo {
     15namespace lemon {
    1616
    1717  /// \brief A map with "small integers" as value set which can enumarate it
  • src/work/klao/iter_map_test.cc

    r618 r921  
    11#include <iter_map.h>
    2 #include <hugo/maps.h>
     2#include <lemon/maps.h>
    33
    44#include <iostream>
    55
    6 using namespace hugo;
     6using namespace lemon;
    77using namespace std;
    88
  • src/work/klao/map_test.cc

    r618 r921  
    11#include <iostream>
    22
    3 #include <hugo/maps.h>
     3#include <lemon/maps.h>
    44
    55using namespace std;
    6 using namespace hugo;
     6using namespace lemon;
    77
    88int main()
  • src/work/marci/augmenting_flow.h

    r888 r921  
    11// -*- C++ -*-
    2 #ifndef HUGO_AUGMENTING_FLOW_H
    3 #define HUGO_AUGMENTING_FLOW_H
     2#ifndef LEMON_AUGMENTING_FLOW_H
     3#define LEMON_AUGMENTING_FLOW_H
    44
    55#include <vector>
    66#include <iostream>
    77
    8 #include <hugo/graph_wrapper.h>
     8#include <lemon/graph_wrapper.h>
    99#include <bfs_dfs.h>
    10 #include <hugo/invalid.h>
    11 #include <hugo/maps.h>
    12 #include <hugo/tight_edge_filter_map.h>
     10#include <lemon/invalid.h>
     11#include <lemon/maps.h>
     12#include <lemon/tight_edge_filter_map.h>
    1313
    1414/// \file
     
    1616/// \ingroup galgs
    1717
    18 namespace hugo {
     18namespace lemon {
    1919
    2020  /// \addtogroup galgs
     
    537537
    538538      dfs.pushAndSetReached
    539         /// \bug hugo 0.2
     539        /// \bug lemon 0.2
    540540        (typename ErasingResGW::Node
    541541         (typename FilterResGW::Node
     
    595595
    596596
    597 } //namespace hugo
    598 
    599 #endif //HUGO_AUGMENTING_FLOW_H
    600 
    601 
     597} //namespace lemon
     598
     599#endif //LEMON_AUGMENTING_FLOW_H
     600
     601
  • src/work/marci/bfs_dfs.h

    r777 r921  
    11// -*- c++ -*-
    2 #ifndef HUGO_BFS_DFS_H
    3 #define HUGO_BFS_DFS_H
     2#ifndef LEMON_BFS_DFS_H
     3#define LEMON_BFS_DFS_H
    44
    55/// \ingroup galgs
     
    1515#include <utility>
    1616
    17 #include <hugo/invalid.h>
    18 
    19 namespace hugo {
     17#include <lemon/invalid.h>
     18
     19namespace lemon {
    2020
    2121  /// Bfs searches for the nodes wich are not marked in
     
    118118    /// The conversion operator makes for converting the bfs-iterator
    119119    /// to an \c out-edge-iterator.
    120     ///\bug Edge have to be in HUGO 0.2
     120    ///\bug Edge have to be in LEMON 0.2
    121121    operator Edge() const { return actual_edge; }
    122122    /// Returns if b-node has been reached just now.
     
    270270    /// The conversion operator makes for converting the bfs-iterator
    271271    /// to an \c out-edge-iterator.
    272     ///\bug Edge have to be in HUGO 0.2
     272    ///\bug Edge have to be in LEMON 0.2
    273273    operator Edge() const { return actual_edge; }
    274274    /// Returns if b-node has been reached just now.
     
    344344
    345345
    346 } // namespace hugo
    347 
    348 #endif //HUGO_BFS_DFS_H
     346} // namespace lemon
     347
     348#endif //LEMON_BFS_DFS_H
  • src/work/marci/bfs_dfs_misc.h

    r762 r921  
    11// -*- c++ -*-
    2 #ifndef HUGO_BFS_DFS_MISC_H
    3 #define HUGO_BFS_DFS_MISC_H
     2#ifndef LEMON_BFS_DFS_MISC_H
     3#define LEMON_BFS_DFS_MISC_H
    44
    55/// \ingroup galgs
     
    1414#include <for_each_macros.h>
    1515
    16 namespace hugo {
     16namespace lemon {
    1717
    1818  /// This function eats a read-write \c BoolMap& bool_map,
     
    7272          ++dfs;
    7373          if (dfs.isBNodeNewlyReached()) {
    74             ///\bug hugo 0.2-ben Edge kell
     74            ///\bug lemon 0.2-ben Edge kell
    7575            pred.set(dfs.aNode(), typename Graph::OutEdgeIt(dfs));
    7676          } else {
     
    7878            if (g.valid(typename Graph::OutEdgeIt(dfs)) &&
    7979                !examined[dfs.bNode()]) {
    80               ///\bug hugo 0.2-ben Edge kell
     80              ///\bug lemon 0.2-ben Edge kell
    8181              pred.set(dfs.bNode(), typename Graph::OutEdgeIt(dfs));
    8282              return dfs.aNode();
     
    9393  }
    9494
    95 } //namespace hugo
     95} //namespace lemon
    9696
    97 #endif //HUGO_BFS_DFS_MISC_H
     97#endif //LEMON_BFS_DFS_MISC_H
  • src/work/marci/bfsit_vs_byhand.cc

    r777 r921  
    44
    55#include <sage_graph.h>
    6 #include <hugo/smart_graph.h>
    7 #include <hugo/dimacs.h>
    8 #include <hugo/time_measure.h>
    9 //#include <hugo/for_each_macros.h>
     6#include <lemon/smart_graph.h>
     7#include <lemon/dimacs.h>
     8#include <lemon/time_measure.h>
     9//#include <lemon/for_each_macros.h>
    1010#include <bfs_dfs.h>
    1111
    12 using namespace hugo;
     12using namespace lemon;
    1313
    1414using std::cout;
  • src/work/marci/bipartite_graph_wrapper.h

    r902 r921  
    11// -*- c++ -*-
    2 #ifndef HUGO_BIPARTITE_GRAPH_WRAPPER_H
    3 #define HUGO_BIPARTITE_GRAPH_WRAPPER_H
     2#ifndef LEMON_BIPARTITE_GRAPH_WRAPPER_H
     3#define LEMON_BIPARTITE_GRAPH_WRAPPER_H
    44
    55///\ingroup gwrappers
     
    1111///\author Marton Makai
    1212
    13 #include <hugo/invalid.h>
     13#include <lemon/invalid.h>
    1414#include <iter_map.h>
    15 #include <hugo/graph_wrapper.h>
     15#include <lemon/graph_wrapper.h>
    1616#include <for_each_macros.h>
    1717
    18 namespace hugo {
     18namespace lemon {
    1919
    2020  /// \brief A wrapper for composing a bipartite graph from a graph
     
    927927  ///@}
    928928
    929 } //namespace hugo
    930 
    931 
    932 #endif //HUGO_BIPARTITE_GRAPH_WRAPPER_H
    933 
     929} //namespace lemon
     930
     931
     932#endif //LEMON_BIPARTITE_GRAPH_WRAPPER_H
     933
  • src/work/marci/bipartite_graph_wrapper_test.cc

    r902 r921  
    55
    66//#include <sage_graph.h>
    7 #include <hugo/smart_graph.h>
     7#include <lemon/smart_graph.h>
    88//#include <dimacs.h>
    9 #include <hugo/time_measure.h>
     9#include <lemon/time_measure.h>
    1010//#include <for_each_macros.h>
    1111#include <bfs_dfs.h>
    12 #include <hugo/graph_wrapper.h>
     12#include <lemon/graph_wrapper.h>
    1313#include <bipartite_graph_wrapper.h>
    14 #include <hugo/maps.h>
    15 #include <hugo/preflow.h>
     14#include <lemon/maps.h>
     15#include <lemon/preflow.h>
    1616#include <augmenting_flow.h>
    1717
     
    1919using std::endl;
    2020
    21 using namespace hugo;
     21using namespace lemon;
    2222
    2323int main() {
  • src/work/marci/bipartite_matching_demo.cc

    r771 r921  
    77//#include <smart_graph.h>
    88//#include <dimacs.h>
    9 #include <hugo/time_measure.h>
     9#include <lemon/time_measure.h>
    1010#include <for_each_macros.h>
    1111#include <bfs_dfs.h>
    1212#include <bipartite_graph_wrapper.h>
    13 #include <hugo/maps.h>
    14 #include <hugo/max_flow.h>
     13#include <lemon/maps.h>
     14#include <lemon/max_flow.h>
    1515#include <graph_gen.h>
    1616#include <max_bipartite_matching.h>
    1717
    18 using namespace hugo;
     18using namespace lemon;
    1919
    2020using std::cin;
  • src/work/marci/const_map_time.cc

    r890 r921  
    44#include <iostream>
    55
    6 #include <hugo/maps.h>
    7 #include <hugo/smart_graph.h>
    8 #include <hugo/time_measure.h>
    9 #include <hugo/dimacs.h>
    10 #include <hugo/graph_wrapper.h>
     6#include <lemon/maps.h>
     7#include <lemon/smart_graph.h>
     8#include <lemon/time_measure.h>
     9#include <lemon/dimacs.h>
     10#include <lemon/graph_wrapper.h>
    1111
    12 using namespace hugo;
     12using namespace lemon;
    1313
    1414int main() {
  • src/work/marci/experiment/bfs_iterator.h

    r281 r921  
    11// -*- c++ -*-
    2 #ifndef HUGO_BFS_ITERATOR_H
    3 #define HUGO_BFS_ITERATOR_H
     2#ifndef LEMON_BFS_ITERATOR_H
     3#define LEMON_BFS_ITERATOR_H
    44
    55#include <queue>
     
    88#include <graph_wrapper.h>
    99
    10 namespace hugo {
     10namespace lemon {
    1111
    1212//   template <typename Graph>
     
    837837
    838838
    839 } // namespace hugo
    840 
    841 #endif //HUGO_BFS_ITERATOR_H
     839} // namespace lemon
     840
     841#endif //LEMON_BFS_ITERATOR_H
  • src/work/marci/experiment/bfs_iterator_1.h

    r298 r921  
    11// -*- c++ -*-
    2 #ifndef HUGO_BFS_ITERATOR_H
    3 #define HUGO_BFS_ITERATOR_H
     2#ifndef LEMON_BFS_ITERATOR_H
     3#define LEMON_BFS_ITERATOR_H
    44
    55#include <queue>
     
    88#include <graph_wrapper_1.h>
    99
    10 namespace hugo {
     10namespace lemon {
    1111
    1212//   template <typename Graph>
     
    832832
    833833
    834 } // namespace hugo
    835 
    836 #endif //HUGO_BFS_ITERATOR_H
     834} // namespace lemon
     835
     836#endif //LEMON_BFS_ITERATOR_H
  • src/work/marci/experiment/edmonds_karp.h

    r281 r921  
    11// -*- c++ -*-
    2 #ifndef HUGO_EDMONDS_KARP_H
    3 #define HUGO_EDMONDS_KARP_H
     2#ifndef LEMON_EDMONDS_KARP_H
     3#define LEMON_EDMONDS_KARP_H
    44
    55#include <algorithm>
     
    1010#include <invalid.h>
    1111
    12 namespace hugo {
     12namespace lemon {
    1313
    1414  template<typename Graph, typename Number, typename FlowMap, typename CapacityMap>
     
    12341234
    12351235
    1236 } // namespace hugo
    1237 
    1238 #endif //HUGO_EDMONDS_KARP_H
     1236} // namespace lemon
     1237
     1238#endif //LEMON_EDMONDS_KARP_H
  • src/work/marci/experiment/edmonds_karp_1.h

    r298 r921  
    11// -*- c++ -*-
    2 #ifndef HUGO_EDMONDS_KARP_H
    3 #define HUGO_EDMONDS_KARP_H
     2#ifndef LEMON_EDMONDS_KARP_H
     3#define LEMON_EDMONDS_KARP_H
    44
    55#include <algorithm>
     
    1111#include <graph_wrapper_1.h>
    1212
    13 namespace hugo {
     13namespace lemon {
    1414
    1515  template<typename Graph, typename Number, typename FlowMap, typename CapacityMap>
     
    11441144
    11451145
    1146 } // namespace hugo
    1147 
    1148 #endif //HUGO_EDMONDS_KARP_H
     1146} // namespace lemon
     1147
     1148#endif //LEMON_EDMONDS_KARP_H
  • src/work/marci/experiment/edmonds_karp_demo.cc

    r281 r921  
    1515};
    1616
    17 using namespace hugo;
     17using namespace lemon;
    1818
    1919// Use a DIMACS max flow file as stdin.
  • src/work/marci/experiment/edmonds_karp_demo_1.cc

    r281 r921  
    1515};
    1616
    17 using namespace hugo;
     17using namespace lemon;
    1818
    1919// Use a DIMACS max flow file as stdin.
  • src/work/marci/experiment/graph_wrapper.h

    r880 r921  
    11// -*- c++ -*-
    2 #ifndef HUGO_GRAPH_WRAPPER_H
    3 #define HUGO_GRAPH_WRAPPER_H
     2#ifndef LEMON_GRAPH_WRAPPER_H
     3#define LEMON_GRAPH_WRAPPER_H
    44
    55#include <invalid.h>
    66
    7 namespace hugo {
     7namespace lemon {
    88
    99  template<typename Graph>
     
    17021702//   };
    17031703
    1704 } //namespace hugo
    1705 
    1706 #endif //HUGO_GRAPH_WRAPPER_H
    1707 
     1704} //namespace lemon
     1705
     1706#endif //LEMON_GRAPH_WRAPPER_H
     1707
  • src/work/marci/experiment/graph_wrapper_1.h

    r880 r921  
    11// -*- c++ -*-
    2 #ifndef HUGO_GRAPH_WRAPPER_H
    3 #define HUGO_GRAPH_WRAPPER_H
     2#ifndef LEMON_GRAPH_WRAPPER_H
     3#define LEMON_GRAPH_WRAPPER_H
    44
    55#include <invalid.h>
    66
    7 namespace hugo {
     7namespace lemon {
    88
    99  template<typename Graph>
     
    13431343//   };
    13441344
    1345 } //namespace hugo
    1346 
    1347 #endif //HUGO_GRAPH_WRAPPER_H
    1348 
     1345} //namespace lemon
     1346
     1347#endif //LEMON_GRAPH_WRAPPER_H
     1348
  • src/work/marci/experiment/graph_wrapper_st_ostream_op.h

    r445 r921  
    11// -*- c++ -*-
    2 #ifndef HUGO_GRAPH_WRAPPER_H
    3 #define HUGO_GRAPH_WRAPPER_H
     2#ifndef LEMON_GRAPH_WRAPPER_H
     3#define LEMON_GRAPH_WRAPPER_H
    44
    55#include <invalid.h>
    66#include <iter_map.h>
    77
    8 namespace hugo {
     8namespace lemon {
    99
    1010  // Graph wrappers
    1111
    1212  /// \addtogroup gwrappers
    13   /// A main parts of HUGOlib are the different graph structures,
     13  /// A main parts of LEMON are the different graph structures,
    1414  /// generic graph algorithms, graph concepts which couple these, and
    1515  /// graph wrappers. While the previous ones are more or less clear, the
     
    16471647  ///@}
    16481648
    1649 } //namespace hugo
    1650 
    1651 
    1652 #endif //HUGO_GRAPH_WRAPPER_H
    1653 
     1649} //namespace lemon
     1650
     1651
     1652#endif //LEMON_GRAPH_WRAPPER_H
     1653
  • src/work/marci/experiment/iterator_bfs_demo.cc

    r303 r921  
    99#include <graph_wrapper.h>
    1010
    11 using namespace hugo;
     11using namespace lemon;
    1212using std::cout;
    1313using std::endl;
  • src/work/marci/experiment/iterator_bfs_demo_1.cc

    r303 r921  
    99#include <graph_wrapper_1.h>
    1010
    11 using namespace hugo;
     11using namespace lemon;
    1212using std::cout;
    1313using std::endl;
  • src/work/marci/experiment/list_graph.h

    r281 r921  
    11// -*- c++ -*-
    2 #ifndef HUGO_LIST_GRAPH_H
    3 #define HUGO_LIST_GRAPH_H
     2#ifndef LEMON_LIST_GRAPH_H
     3#define LEMON_LIST_GRAPH_H
    44
    55#include <iostream>
     
    88#include <invalid.h>
    99
    10 namespace hugo {
     10namespace lemon {
    1111
    1212  template <typename It>
     
    566566
    567567
    568 } //namespace hugo
    569 
    570 #endif //HUGO_LIST_GRAPH_H
     568} //namespace lemon
     569
     570#endif //LEMON_LIST_GRAPH_H
  • src/work/marci/for_each_macros.h

    r725 r921  
    11// -*- c++ -*-
    2 #ifndef HUGO_FOR_EACH_MACROS_H
    3 #define HUGO_FOR_EACH_MACROS_H
     2#ifndef LEMON_FOR_EACH_MACROS_H
     3#define LEMON_FOR_EACH_MACROS_H
    44
    55// /// \ingroup gwrappers
     
    88///
    99/// This file contains several macros which make easier writting
    10 /// for cycles in HUGO using HUGO iterators.
     10/// for cycles in LEMON using LEMON iterators.
    1111///
    1212/// \author Marton Makai
    1313
    14 namespace hugo {
     14namespace lemon {
    1515
    16   /// This macro provides a comfortable interface for iterating with HUGO
     16  /// This macro provides a comfortable interface for iterating with LEMON
    1717  /// iterators.
    1818  /// \code
     
    3434#define FOR_EACH_GLOB(e, g) for((g).first((e)); (g).valid((e)); (g).next((e)))
    3535
    36   /// This macro provides a comfortable interface for iterating with HUGO
     36  /// This macro provides a comfortable interface for iterating with LEMON
    3737  /// iterators.
    3838  /// \code
     
    126126//   }
    127127
    128   /// This macro provides a comfortable interface for iterating with HUGO
     128  /// This macro provides a comfortable interface for iterating with LEMON
    129129  /// iterators.
    130130  /// \code
     
    144144#define FOR_EACH_LOC(Ittype, e, g) for(Ittype e=loopFirst(Ittype(), (g)); (g).valid(e); (g).next(e))
    145145
    146   /// This macro provides a comfortable interface for iterating with HUGO
     146  /// This macro provides a comfortable interface for iterating with LEMON
    147147  /// iterators.
    148148  /// \code
     
    171171// #define FOR_EACH_OUTEDGE_LOC(e, g, v) for((g).first((e), (v)); (g).valid((e)); (g).next((e)))
    172172
    173 } //namespace hugo
     173} //namespace lemon
    174174
    175 #endif //HUGO_FOR_EACH_MACROS_H
     175#endif //LEMON_FOR_EACH_MACROS_H
  • src/work/marci/graph_concept.h

    r826 r921  
    11// -*- c++ -*-
    2 #ifndef HUGO_GRAPH_H
    3 #define HUGO_GRAPH_H
     2#ifndef LEMON_GRAPH_H
     3#define LEMON_GRAPH_H
    44
    55///\file
    66///\brief Declaration of GraphConcept.
    77
    8 #include <hugo/invalid.h>
    9 
    10 namespace hugo {
     8#include <lemon/invalid.h>
     9
     10namespace lemon {
    1111
    1212  /// @defgroup empty_graph The GraphConcept class
     
    472472  /// @}
    473473
    474 } //namespace hugo
     474} //namespace lemon
    475475
    476476
     
    492492// }
    493493
    494 #endif // HUGO_GRAPH_H
     494#endif // LEMON_GRAPH_H
  • src/work/marci/graph_wrapper_time.cc

    r849 r921  
    88#include <string>
    99#include <vector>
    10 #include <hugo/invalid.h>
    11 #include <hugo/time_measure.h>
    12 #include <hugo/graph_wrapper.h>
    13 #include <hugo/preflow.h>
    14 #include <hugo/dimacs.h>
    15 #include <hugo/list_graph.h>
     10#include <lemon/invalid.h>
     11#include <lemon/time_measure.h>
     12#include <lemon/graph_wrapper.h>
     13#include <lemon/preflow.h>
     14#include <lemon/dimacs.h>
     15#include <lemon/list_graph.h>
    1616
    17 using namespace hugo;
     17using namespace lemon;
    1818
    1919using std::cout;
  • src/work/marci/gw_vs_not.cc

    r270 r921  
    1010#include <graph_wrapper.h>
    1111
    12 using namespace hugo;
     12using namespace lemon;
    1313
    1414// Use a DIMACS max flow file as stdin.
  • src/work/marci/iterator_bfs_demo.cc

    r777 r921  
    55
    66#include <sage_graph.h>
    7 #include <hugo/smart_graph.h>
     7#include <lemon/smart_graph.h>
    88#include <bfs_dfs.h>
    9 #include <hugo/graph_wrapper.h>
    10 
    11 using namespace hugo;
     9#include <lemon/graph_wrapper.h>
     10
     11using namespace lemon;
    1212
    1313using std::cout;
  • src/work/marci/leda/bipartite_matching_comparison.cc

    r771 r921  
    1414//#include <smart_graph.h>
    1515//#include <dimacs.h>
    16 #include <hugo/time_measure.h>
     16#include <lemon/time_measure.h>
    1717#include <for_each_macros.h>
    18 #include <hugo/graph_wrapper.h>
     18#include <lemon/graph_wrapper.h>
    1919#include <bipartite_graph_wrapper.h>
    20 #include <hugo/maps.h>
    21 #include <hugo/max_flow.h>
     20#include <lemon/maps.h>
     21#include <lemon/max_flow.h>
    2222
    2323using std::cin;
     
    2525using std::endl;
    2626
    27 using namespace hugo;
     27using namespace lemon;
    2828
    2929int main() {
     
    9292    max_flow_test(stgw, stgw.S_NODE, stgw.T_NODE, const1map, flow/*, true*/);
    9393  max_flow_test.run();
    94   cout << "HUGO max matching algorithm based on preflow." << endl
     94  cout << "LEMON max matching algorithm based on preflow." << endl
    9595            << "Size of matching: "
    9696            << max_flow_test.flowValue() << endl;
     
    108108//   typedef SageGraph MutableGraph;
    109109//   while (max_flow_test.augmentOnBlockingFlow<MutableGraph>()) { }
    110 //   cout << "HUGO max matching algorithm based on blocking flow augmentation."
     110//   cout << "LEMON max matching algorithm based on blocking flow augmentation."
    111111//          << endl << "Matching size: "
    112112//          << max_flow_test.flowValue() << endl;
     
    142142    max_flow_test(hg, s, t, cm, flow);
    143143  max_flow_test.run();
    144   cout << "HUGO max matching algorithm on SageGraph by copying the graph, based on preflow."
     144  cout << "LEMON max matching algorithm on SageGraph by copying the graph, based on preflow."
    145145            << endl
    146146            << "Size of matching: "
  • src/work/marci/leda/bipartite_matching_leda.cc

    r769 r921  
    1414//#include <smart_graph.h>
    1515//#include <dimacs.h>
    16 #include <hugo/time_measure.h>
     16#include <lemon/time_measure.h>
    1717#include <for_each_macros.h>
    18 #include <hugo/graph_wrapper.h>
     18#include <lemon/graph_wrapper.h>
    1919#include <bipartite_graph_wrapper.h>
    20 #include <hugo/maps.h>
    21 #include <hugo/max_flow.h>
     20#include <lemon/maps.h>
     21#include <lemon/max_flow.h>
    2222
    2323/**
     
    4343}
    4444
    45 using namespace hugo;
     45using namespace lemon;
    4646
    4747int main() {
  • src/work/marci/leda/bipartite_matching_leda_gen.cc

    r769 r921  
    1414//#include <smart_graph.h>
    1515//#include <dimacs.h>
    16 #include <hugo/time_measure.h>
     16#include <lemon/time_measure.h>
    1717#include <for_each_macros.h>
    18 #include <hugo/graph_wrapper.h>
     18#include <lemon/graph_wrapper.h>
    1919#include <bipartite_graph_wrapper.h>
    20 #include <hugo/maps.h>
    21 #include <hugo/max_flow.h>
     20#include <lemon/maps.h>
     21#include <lemon/max_flow.h>
    2222#include <augmenting_flow.h>
    2323
     
    4444}
    4545
    46 using namespace hugo;
     46using namespace lemon;
    4747
    4848int main() {
     
    111111    max_flow_test(stgw, stgw.S_NODE, stgw.T_NODE, const1map, flow/*, true*/);
    112112  max_flow_test.run();
    113   std::cout << "HUGO max matching algorithm based on preflow." << std::endl
     113  std::cout << "LEMON max matching algorithm based on preflow." << std::endl
    114114            << "Size of matching: "
    115115            << max_flow_test.flowValue() << std::endl;
     
    130130    max_flow_test_1(stgw, stgw.S_NODE, stgw.T_NODE, const1map, flow/*, true*/);
    131131  while (max_flow_test_1.augmentOnBlockingFlow<MutableGraph>()) { }
    132   std::cout << "HUGO max matching algorithm based on blocking flow augmentation."
     132  std::cout << "LEMON max matching algorithm based on blocking flow augmentation."
    133133            << std::endl << "Matching size: "
    134134            << max_flow_test_1.flowValue() << std::endl;
  • src/work/marci/leda/leda_graph_wrapper.h

    r650 r921  
    11// -*- c++ -*-
    2 #ifndef HUGO_LEDA_GRAPH_WRAPPER_H
    3 #define HUGO_LEDA_GRAPH_WRAPPER_H
     2#ifndef LEMON_LEDA_GRAPH_WRAPPER_H
     3#define LEMON_LEDA_GRAPH_WRAPPER_H
    44
    55#include <LEDA/graph.h>
     
    1515//#endif
    1616
    17 #include <hugo/invalid.h>
    18 
    19 namespace hugo {
    20 
    21   /// \brief A graph wrapper structure for wrapping LEDA graphs in HUGO.
     17#include <lemon/invalid.h>
     18
     19namespace lemon {
     20
     21  /// \brief A graph wrapper structure for wrapping LEDA graphs in LEMON.
    2222  ///
    2323  /// This graph wrapper class wraps LEDA graphs and LEDA parametrized graphs
    24   /// to satisfy HUGO graph concepts.
    25   /// Then the generic HUGOlib algorithms and wrappers can be used
     24  /// to satisfy LEMON graph concepts.
     25  /// Then the generic LEMON algorithms and wrappers can be used
    2626  /// with LEDA graphs.
    2727  /// \ingroup gwrapper
     
    299299
    300300    /// This class is to wrap existing
    301     /// LEDA node-maps to HUGO ones.
     301    /// LEDA node-maps to LEMON ones.
    302302    template<typename T> class NodeMapWrapper
    303303    {
     
    321321
    322322    /// This class is to wrap existing
    323     /// LEDA edge-maps to HUGO ones.
     323    /// LEDA edge-maps to LEMON ones.
    324324    template<typename T> class EdgeMapWrapper
    325325    {
     
    380380  };
    381381
    382 } //namespace hugo
    383 
    384 #endif // HUGO_LEDA_GRAPH_WRAPPER_H
     382} //namespace lemon
     383
     384#endif // LEMON_LEDA_GRAPH_WRAPPER_H
  • src/work/marci/leda/max_bipartite_matching_demo.cc

    r771 r921  
    3737}
    3838
    39 using namespace hugo;
     39using namespace lemon;
    4040
    4141using std::cout;
  • src/work/marci/leda_bfs_dfs.cc

    r189 r921  
    1212#include <leda_graph_wrapper.h>
    1313
    14 using namespace hugo;
     14using namespace lemon;
    1515using std::cout;
    1616using std::endl;
  • src/work/marci/leda_graph_demo.cc

    r189 r921  
    99#include <edmonds_karp.h>
    1010
    11 using namespace hugo;
     11using namespace lemon;
    1212
    1313using std::cout;
  • src/work/marci/lg_vs_sg_vs_sg.cc

    r777 r921  
    55
    66#include <sage_graph.h>
    7 #include <hugo/list_graph.h>
    8 #include <hugo/smart_graph.h>
    9 #include <hugo/dimacs.h>
    10 #include <hugo/max_flow.h>
     7#include <lemon/list_graph.h>
     8#include <lemon/smart_graph.h>
     9#include <lemon/dimacs.h>
     10#include <lemon/max_flow.h>
    1111#include <augmenting_flow.h>
    12 #include <hugo/time_measure.h>
     12#include <lemon/time_measure.h>
    1313#include <for_each_macros.h>
    1414
    15 using namespace hugo;
     15using namespace lemon;
    1616
    1717// Use a DIMACS max flow file as stdin.
  • src/work/marci/lp/lp_solver_wrapper.h

    r888 r921  
    11// -*- c++ -*-
    2 #ifndef HUGO_LP_SOLVER_WRAPPER_H
    3 #define HUGO_LP_SOLVER_WRAPPER
     2#ifndef LEMON_LP_SOLVER_WRAPPER_H
     3#define LEMON_LP_SOLVER_WRAPPER
    44
    55///\ingroup misc
     
    2121
    2222//#include <sage_graph.h>
    23 //#include <hugo/list_graph.h>
    24 //#include <hugo/graph_wrapper.h>
    25 #include <hugo/invalid.h>
     23//#include <lemon/list_graph.h>
     24//#include <lemon/graph_wrapper.h>
     25#include <lemon/invalid.h>
    2626//#include <bfs_dfs.h>
    2727//#include <stp.h>
    28 //#include <hugo/max_flow.h>
     28//#include <lemon/max_flow.h>
    2929//#include <augmenting_flow.h>
    3030//#include <iter_map.h>
     
    3434using std::endl;
    3535
    36 namespace hugo {
     36namespace lemon {
    3737
    3838 
     
    4545  /// stl vector, the range is partitioned into sets and each set is
    4646  /// doubly linked in a list.
    47   /// That is, each class is iterable by hugo iterators, and any member of
     47  /// That is, each class is iterable by lemon iterators, and any member of
    4848  /// the vector can bo moved to an other class.
    4949  template <typename T>
     
    6464    /// The classes are indexed by integers from \c 0 to \c classNum()-1.
    6565    int classNum() const { return tips.size(); }
    66     /// This hugo style iterator iterates through a class.
     66    /// This lemon style iterator iterates through a class.
    6767    class ClassIt;
    6868    /// Constructor. The number of classes is to be given which is fixed
     
    158158  /// \brief Wrappers for LP solvers
    159159  ///
    160   /// This class implements a hugo wrapper for glpk.
    161   /// Later other LP-solvers will be wrapped into hugo.
     160  /// This class implements a lemon wrapper for glpk.
     161  /// Later other LP-solvers will be wrapped into lemon.
    162162  /// The aim of this class is to give a general surface to different
    163163  /// solvers, i.e. it makes possible to write algorithms using LP's,
     
    425425  /// @}
    426426
    427 } //namespace hugo
    428 
    429 #endif //HUGO_LP_SOLVER_WRAPPER_H
     427} //namespace lemon
     428
     429#endif //LEMON_LP_SOLVER_WRAPPER_H
  • src/work/marci/lp/max_flow_by_lp.cc

    r764 r921  
    44
    55#include <sage_graph.h>
    6 #include <hugo/smart_graph.h>
    7 #include <hugo/dimacs.h>
    8 #include <hugo/time_measure.h>
     6#include <lemon/smart_graph.h>
     7#include <lemon/dimacs.h>
     8#include <lemon/time_measure.h>
    99//#include <graph_wrapper.h>
    10 #include <hugo/max_flow.h>
     10#include <lemon/max_flow.h>
    1111#include <augmenting_flow.h>
    1212//#include <preflow_res.h>
     
    1414#include <lp_solver_wrapper.h>
    1515
    16 using namespace hugo;
     16using namespace lemon;
    1717
    1818// Use a DIMACS max flow file as stdin.
  • src/work/marci/macro_test.cc

    r762 r921  
    66#include <for_each_macros.h>
    77
    8 using namespace hugo;
     8using namespace lemon;
    99
    1010int main()
  • src/work/marci/max_bipartite_matching.h

    r768 r921  
    11// -*- c++ -*-
    2 #ifndef HUGO_MAX_BIPARTITE_MATCHING_H
    3 #define HUGO_MAX_BIPARTITE_MATCHING_H
     2#ifndef LEMON_MAX_BIPARTITE_MATCHING_H
     3#define LEMON_MAX_BIPARTITE_MATCHING_H
    44
    55/// \ingroup galgs
     
    1515//#include <for_each_macros.h>
    1616#include <bipartite_graph_wrapper.h>
    17 //#include <hugo/maps.h>
    18 #include <hugo/max_flow.h>
     17//#include <lemon/maps.h>
     18#include <lemon/max_flow.h>
    1919
    20 namespace hugo {
     20namespace lemon {
    2121
    2222  // template <typename Graph, typename EdgeCap, typename NodeCap,
     
    136136  };
    137137
    138 } //namespace hugo
     138} //namespace lemon
    139139
    140 #endif //HUGO_MAX_BIPARTITE_MATCHING_H
     140#endif //LEMON_MAX_BIPARTITE_MATCHING_H
  • src/work/marci/max_flow_1.cc

    r762 r921  
    44
    55#include <sage_graph.h>
    6 #include <hugo/smart_graph.h>
    7 #include <hugo/dimacs.h>
    8 #include <hugo/time_measure.h>
     6#include <lemon/smart_graph.h>
     7#include <lemon/dimacs.h>
     8#include <lemon/time_measure.h>
    99//#include <graph_wrapper.h>
    10 #include <hugo/max_flow.h>
     10#include <lemon/max_flow.h>
    1111//#include <preflow_res.h>
    1212#include <for_each_macros.h>
    1313
    14 using namespace hugo;
     14using namespace lemon;
    1515
    1616// Use a DIMACS max flow file as stdin.
  • src/work/marci/max_flow_demo.cc

    r854 r921  
    77#include <fstream>
    88
    9 #include <hugo/smart_graph.h>
    10 #include <hugo/list_graph.h>
    11 #include <hugo/dimacs.h>
    12 #include <hugo/time_measure.h>
    13 #include <hugo/preflow.h>
     9#include <lemon/smart_graph.h>
     10#include <lemon/list_graph.h>
     11#include <lemon/dimacs.h>
     12#include <lemon/time_measure.h>
     13#include <lemon/preflow.h>
    1414#include <augmenting_flow.h>
    1515#include <graph_concept.h>
    1616
    17 using namespace hugo;
     17using namespace lemon;
    1818
    1919int main(int, char **) {
  • src/work/marci/merge_node_graph_wrapper.h

    r917 r921  
    11/* -*- C++ -*-
    2  * src/hugo/merge_node_graph_wrapper.h - Part of HUGOlib, a generic C++ optimization library
     2 * src/lemon/merge_node_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_MERGE_NODE_GRAPH_WRAPPER_H
    18 #define HUGO_MERGE_NODE_GRAPH_WRAPPER_H
     17#ifndef LEMON_MERGE_NODE_GRAPH_WRAPPER_H
     18#define LEMON_MERGE_NODE_GRAPH_WRAPPER_H
    1919
    20 #include <hugo/invalid.h>
    21 #include <hugo/maps.h>
    22 #include <hugo/map_defines.h>
    23 #include <hugo/graph_wrapper.h>
     20#include <lemon/invalid.h>
     21#include <lemon/maps.h>
     22#include <lemon/map_defines.h>
     23#include <lemon/graph_wrapper.h>
    2424#include <iostream>
    2525
    26 namespace hugo {
     26namespace lemon {
    2727
    2828  template <typename Graph1, typename Graph2, typename Enable=void>
     
    173173  };
    174174
    175 } //namespace hugo
     175} //namespace lemon
    176176
    177 #endif //HUGO_MERGE_NODE_GRAPH_WRAPPER_H
     177#endif //LEMON_MERGE_NODE_GRAPH_WRAPPER_H
  • src/work/marci/merge_node_graph_wrapper_test.cc

    r917 r921  
    11#include <iostream>
    22
    3 #include <hugo/list_graph.h>
    4 #include <hugo/smart_graph.h>
     3#include <lemon/list_graph.h>
     4#include <lemon/smart_graph.h>
    55#include <merge_node_graph_wrapper.h>
    66
     
    88using std::endl;
    99
    10 using namespace hugo;
     10using namespace lemon;
    1111
    1212int main() {
  • src/work/marci/oldies/edmonds_karp.h

    r474 r921  
    11// -*- c++ -*-
    2 #ifndef HUGO_EDMONDS_KARP_H
    3 #define HUGO_EDMONDS_KARP_H
     2#ifndef LEMON_EDMONDS_KARP_H
     3#define LEMON_EDMONDS_KARP_H
    44
    55#include <algorithm>
     
    1313#include <for_each_macros.h>
    1414
    15 namespace hugo {
     15namespace lemon {
    1616
    1717  template <typename Graph, typename Num,
     
    952952
    953953
    954 } // namespace hugo
    955 
    956 #endif //HUGO_EDMONDS_KARP_H
     954} // namespace lemon
     955
     956#endif //LEMON_EDMONDS_KARP_H
  • src/work/marci/oldies/marci_graph_demo.cc

    r280 r921  
    77#include <edmonds_karp.h>
    88
    9 using namespace hugo;
     9using namespace lemon;
    1010
    1111int main (int, char*[])
  • src/work/marci/preflow_bug.cc

    r747 r921  
    44
    55#include <sage_graph.h>
    6 #include <hugo/smart_graph.h>
    7 #include <hugo/dimacs.h>
    8 //#include <hugo/time_measure.h>
     6#include <lemon/smart_graph.h>
     7#include <lemon/dimacs.h>
     8//#include <lemon/time_measure.h>
    99//#include <graph_wrapper.h>
    10 #include <hugo/max_flow.h>
     10#include <lemon/max_flow.h>
    1111//#include <preflow_res.h>
    1212#include <for_each_macros.h>
     
    1616using std::endl;
    1717
    18 using namespace hugo;
     18using namespace lemon;
    1919
    2020// Use a DIMACS min cost flow file as stdin.
  • src/work/marci/preflow_demo_athos.cc

    r522 r921  
    77#include <time_measure.h>
    88
    9 using namespace hugo;
     9using namespace lemon;
    1010
    1111// Use a DIMACS max flow file as stdin.
  • src/work/marci/preflow_demo_jacint.cc

    r105 r921  
    88#include <time_measure.h>
    99
    10 using namespace hugo;
     10using namespace lemon;
    1111
    1212// Use a DIMACS max flow file as stdin.
  • src/work/marci/top_sort_test.cc

    r762 r921  
    44#include <list>
    55
    6 #include <hugo/dimacs.h>
     6#include <lemon/dimacs.h>
    77#include <bfs_dfs_misc.h>
    88#include <sage_graph.h>
    9 #include <hugo/graph_wrapper.h>
    10 #include <hugo/maps.h>
     9#include <lemon/graph_wrapper.h>
     10#include <lemon/maps.h>
    1111#include <for_each_macros.h>
    1212
    13 using namespace hugo;
     13using namespace lemon;
    1414
    1515using std::cout;
  • src/work/peter/edgepathgraph.h

    r880 r921  
    11// -*- c++ -*-
    2 #ifndef HUGO_NET_GRAPH_H
    3 #define HUGO_NET_GRAPH_H
     2#ifndef LEMON_NET_GRAPH_H
     3#define LEMON_NET_GRAPH_H
    44
    55///\file
    66///\brief Declaration of EdgePathGraph.
    77
    8 #include <hugo/invalid.h>
    9 #include <hugo/maps.h>
    10 
    11 /// The namespace of HugoLib
    12 namespace hugo {
     8#include <lemon/invalid.h>
     9#include <lemon/maps.h>
     10
     11/// The namespace of LEMON
     12namespace lemon {
    1313
    1414  // @defgroup empty_graph The EdgePathGraph class
     
    402402  // @}
    403403
    404 } //namespace hugo
    405 
    406 
    407 #endif // HUGO_SKELETON_GRAPH_H
     404} //namespace lemon
     405
     406
     407#endif // LEMON_SKELETON_GRAPH_H
  • src/work/peter/edgepathgraph_test.cc

    r677 r921  
    44
    55#include "edgepathgraph.h"
    6 #include <hugo/list_graph.h>
    7 #include <hugo/smart_graph.h>
     6#include <lemon/list_graph.h>
     7#include <lemon/smart_graph.h>
    88#include <path.h>
    99
    10 using namespace hugo;
     10using namespace lemon;
    1111using namespace std;
    1212
  • src/work/peter/hierarchygraph.h

    r880 r921  
    11// -*- c++ -*-
    2 #ifndef HUGO_NET_GRAPH_H
    3 #define HUGO_NET_GRAPH_H
     2#ifndef LEMON_NET_GRAPH_H
     3#define LEMON_NET_GRAPH_H
    44
    55///\file
    66///\brief Declaration of HierarchyGraph.
    77
    8 #include <hugo/invalid.h>
    9 #include <hugo/maps.h>
    10 
    11 /// The namespace of HugoLib
    12 namespace hugo
     8#include <lemon/invalid.h>
     9#include <lemon/maps.h>
     10
     11/// The namespace of LEMON
     12namespace lemon
    1313{
    1414
     
    576576  // @}
    577577
    578 }                               //namespace hugo
    579 
    580 
    581 #endif // HUGO_SKELETON_GRAPH_H
     578}                               //namespace lemon
     579
     580
     581#endif // LEMON_SKELETON_GRAPH_H
  • src/work/peter/hierarchygraph_test.cc

    r690 r921  
    44
    55#include "hierarchygraph.h"
    6 #include <hugo/list_graph.h>
    7 #include <hugo/smart_graph.h>
     6#include <lemon/list_graph.h>
     7#include <lemon/smart_graph.h>
    88#include <path.h>
    99
    10 using namespace hugo;
     10using namespace lemon;
    1111using namespace std;
    1212
  • src/work/peter/path/debug.h

    r815 r921  
    11// -*- C++ -*- //
    22
    3 #ifndef HUGO_DEBUG_H
    4 #define HUGO_DEBUG_H
     3#ifndef LEMON_DEBUG_H
     4#define LEMON_DEBUG_H
    55
    66//! \file
    77//! \brief Basic definitions for debug control.
    88
    9 namespace hugo {
     9namespace lemon {
    1010
    1111  //! Debug mode for testing/debugging
     
    5454
    5555}
    56 #endif // HUGO_DEBUG_H
     56#endif // LEMON_DEBUG_H
  • src/work/peter/path/path.h

    r815 r921  
    44@defgroup paths Path Structures
    55@ingroup datas
    6 \brief Path structures implemented in Hugo.
    7 
    8 Hugolib provides flexible data structures
     6\brief Path structures implemented in LEMON.
     7
     8LEMON provides flexible data structures
    99to work with paths.
    1010
     
    1313algorithm to store its result in any kind of path structure.
    1414
    15 \sa hugo::skeleton::Path
     15\sa lemon::skeleton::Path
    1616
    1717*/
     
    2121///\brief Classes for representing paths in graphs.
    2222
    23 #ifndef HUGO_PATH_H
    24 #define HUGO_PATH_H
     23#ifndef LEMON_PATH_H
     24#define LEMON_PATH_H
    2525
    2626#include <deque>
     
    2828#include <algorithm>
    2929
    30 #include <hugo/invalid.h>
    31 #include <hugo/error.h>
     30#include <lemon/invalid.h>
     31#include <lemon/error.h>
    3232#include <debug.h>
    3333
    34 namespace hugo {
     34namespace lemon {
    3535
    3636  /// \addtogroup paths
     
    11701170  ///@}
    11711171
    1172 } // namespace hugo
    1173 
    1174 #endif // HUGO_PATH_H
     1172} // namespace lemon
     1173
     1174#endif // LEMON_PATH_H
  • src/work/peter/path/path_skeleton.h

    r815 r921  
    66///\brief Classes for representing paths in graphs.
    77
    8 #ifndef HUGO_PATH_H
    9 #define HUGO_PATH_H
    10 
    11 #include <hugo/invalid.h>
    12 
    13 namespace hugo {
     8#ifndef LEMON_PATH_H
     9#define LEMON_PATH_H
     10
     11#include <lemon/invalid.h>
     12
     13namespace lemon {
    1414  namespace skeleton {
    1515    /// \addtogroup skeletons
     
    219219  }
    220220 
    221 } // namespace hugo
    222 
    223 #endif // HUGO_PATH_H
     221} // namespace lemon
     222
     223#endif // LEMON_PATH_H
  • src/work/peter/path/path_test.cc

    r815 r921  
    66
    77using namespace std;
    8 using namespace hugo;
     8using namespace lemon;
    99using namespace skeleton;
    1010
  • src/work/sage_graph.h

    r774 r921  
    11// -*- c++ -*-
    2 #ifndef HUGO_SAGE_GRAPH_H
    3 #define HUGO_SAGE_GRAPH_H
     2#ifndef LEMON_SAGE_GRAPH_H
     3#define LEMON_SAGE_GRAPH_H
    44
    55#include <iostream>
    66#include <vector>
    77
    8 #include <hugo/invalid.h>
    9 
    10 namespace hugo {
     8#include <lemon/invalid.h>
     9
     10namespace lemon {
    1111
    1212//   template <typename It>
     
    537537  };
    538538
    539 } //namespace hugo
    540 
    541 #endif //HUGO_SAGE_GRAPH_H
     539} //namespace lemon
     540
     541#endif //LEMON_SAGE_GRAPH_H
Note: See TracChangeset for help on using the changeset viewer.