COIN-OR::LEMON - Graph Library

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


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

hugo -> lemon

Location:
src/work
Files:
111 edited

Legend:

Unmodified
Added
Removed
  • 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.