COIN-OR::LEMON - Graph Library

Changeset 2529:93de38566e6c in lemon-0.x for lemon


Ignore:
Timestamp:
11/30/07 10:22:38 (12 years ago)
Author:
Balazs Dezso
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@3405
Message:

Minor changes

Location:
lemon
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • lemon/bin_heap.h

    r2391 r2529  
    3030namespace lemon {
    3131
    32   /// \ingroup auxdat
    33 
    34   /// A Binary Heap implementation.
    35  
     32  ///\ingroup auxdat
     33  ///
     34  ///\brief A Binary Heap implementation.
     35  ///
    3636  ///This class implements the \e binary \e heap data structure. A \e heap
    3737  ///is a data structure for storing items with specified values called \e
     
    230230
    231231    /// \brief Decreases the priority of \c i to \c p.
    232 
     232    ///
    233233    /// This method decreases the priority of item \c i to \c p.
    234234    /// \pre \c i must be stored in the heap with priority at least \c
  • lemon/fib_heap.h

    r2391 r2529  
    3131 
    3232  /// \ingroup auxdat
    33 
    34   /// Fibonacci Heap.
    35 
     33  ///
     34  ///\brief Fibonacci Heap.
     35  ///
    3636  ///This class implements the \e Fibonacci \e heap data structure. A \e heap
    3737  ///is a data structure for storing items with specified values called \e
  • lemon/graph_adaptor.h

    r2422 r2529  
    3535#include <lemon/bits/graph_adaptor_extender.h>
    3636#include <lemon/bits/graph_extender.h>
    37 
    3837#include <lemon/tolerance.h>
    3938
     
    948947  ///Graph::EdgeMap<int> flow(g, 0);
    949948  ///
    950   ///Preflow<SubGA, int, ConstMap<Edge, int>, Graph::EdgeMap<int> >
    951   ///  preflow(ga, s, t, const_1_map, flow);
     949  ///Preflow<SubGA, ConstMap<Edge, int>, Graph::EdgeMap<int> >
     950  ///  preflow(ga, const_1_map, s, t);
    952951  ///preflow.run();
    953952  ///\endcode
     
    959958  ///     << endl;
    960959  ///for(EdgeIt e(g); e!=INVALID; ++e)
    961   ///  if (flow[e])
     960  ///  if (preflow.flow(e))
    962961  ///    cout << " " << g.id(g.source(e)) << "--"
    963962  ///         << length[e] << "->" << g.id(g.target(e)) << endl;
     
    20222021      return INVALID;
    20232022    }
     2023
    20242024   
    20252025    template <typename T>
     
    20312031      NodeMap(const SplitGraphAdaptorBase& _graph, const T& t)
    20322032        : inNodeMap(_graph, t), outNodeMap(_graph, t) {}
    2033      
     2033      NodeMap& operator=(const NodeMap& cmap) {
     2034        return operator=<NodeMap>(cmap);
     2035      }
     2036      template <typename CMap>
     2037      NodeMap& operator=(const CMap& cmap) {
     2038        Parent::operator=(cmap);
     2039        return *this;
     2040      }
     2041
    20342042      void set(const Node& key, const T& val) {
    20352043        if (SplitGraphAdaptorBase::inNode(key)) { inNodeMap.set(key, val); }
     
    20632071      EdgeMap(const SplitGraphAdaptorBase& _graph, const T& t)
    20642072        : edge_map(_graph, t), node_map(_graph, t) {}
     2073      EdgeMap& operator=(const EdgeMap& cmap) {
     2074        return operator=<EdgeMap>(cmap);
     2075      }
     2076      template <typename CMap>
     2077      EdgeMap& operator=(const CMap& cmap) {
     2078        Parent::operator=(cmap);
     2079        return *this;
     2080      }
    20652081     
    20662082      void set(const Edge& key, const T& val) {
     
    24712487  /// SGraph::EdgeMap<int> sflow(sgraph);
    24722488  ///
    2473   /// Preflow<SGraph, int, SCapacity>
    2474   ///   spreflow(sgraph, SGraph::outNode(source),SGraph::inNode(target),
    2475   ///            scapacity, sflow);
     2489  /// Preflow<SGraph, SCapacity>
     2490  ///   spreflow(sgraph, scapacity,
     2491  ///            SGraph::outNode(source), SGraph::inNode(target));
    24762492  ///                                           
    24772493  /// spreflow.run();
  • lemon/min_mean_cycle.h

    r2517 r2529  
    2020#define LEMON_MIN_MEAN_CYCLE_H
    2121
    22 /// \ingroup min_cost_flow
     22/// \ingroup shortest_path
    2323///
    2424/// \file
     
    3232namespace lemon {
    3333
    34   /// \addtogroup min_cost_flow
     34  /// \addtogroup shortest_path
    3535  /// @{
    3636
  • lemon/topology.h

    r2429 r2529  
    716716  /// \param graph The graph.
    717717  /// \return %True when the graph bi-node-connected.
    718   /// \todo Make it faster.
    719718  template <typename UGraph>
    720719  bool biNodeConnected(const UGraph& graph) {
     
    10431042  /// \param graph The undirected graph.
    10441043  /// \return The number of components.
    1045   /// \todo Make it faster.
    10461044  template <typename UGraph>
    10471045  bool biEdgeConnected(const UGraph& graph) {
Note: See TracChangeset for help on using the changeset viewer.