COIN-OR::LEMON - Graph Library

About

Downloads

Documentation

Development

Issue Tracker

Browse Tickets

Custom Query

Roadmap

Browse Source

Local Info

Mailing Lists

Search

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


Ignore:
Timestamp:
09/29/04 17:30:04 (20 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/marci
Files:
47 edited

Legend:

Unmodified
Added
Removed

  • 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;
Note: See TracChangeset for help on using the changeset viewer.