COIN-OR::LEMON - Graph Library

Changeset 278:931190050520 in lemon


Ignore:
Timestamp:
09/22/08 15:33:23 (11 years ago)
Author:
Peter Kovacs <kpeter@…>
Branch:
default
Phase:
public
Message:

Improve the function-type interface of bfs, dfs, and dijkstra (ticket #96)

Files:
7 edited

Legend:

Unmodified
Added
Removed
  • lemon/bfs.h

    r258 r278  
    2929#include <lemon/error.h>
    3030#include <lemon/maps.h>
     31#include <lemon/path.h>
    3132
    3233namespace lemon {
     
    116117  ///This class provides an efficient implementation of the %BFS algorithm.
    117118  ///
    118   ///There is also a \ref bfs() "function type interface" for the BFS
     119  ///There is also a \ref bfs() "function-type interface" for the BFS
    119120  ///algorithm, which is convenient in the simplier cases and it can be
    120121  ///used easier.
     
    842843    ///arcs of the shortest paths.
    843844    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    844     typedef NullMap<typename Digraph::Node,typename Digraph::Arc> PredMap;
     845    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
    845846    ///Instantiates a \ref PredMap.
    846847
     
    849850    ///\ref PredMap.
    850851    ///\todo The digraph alone may be insufficient to initialize
    851 #ifdef DOXYGEN
    852852    static PredMap *createPredMap(const Digraph &g)
    853 #else
    854     static PredMap *createPredMap(const Digraph &)
    855 #endif
    856     {
    857       return new PredMap();
     853    {
     854      return new PredMap(g);
    858855    }
    859856
     
    862859    ///The type of the map that indicates which nodes are processed.
    863860    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     861    ///By default it is a NullMap.
    864862    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    865863    ///Instantiates a \ref ProcessedMap.
     
    896894    ///The type of the map that stores the distances of the nodes.
    897895    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    898     ///
    899     typedef NullMap<typename Digraph::Node,int> DistMap;
     896    typedef typename Digraph::template NodeMap<int> DistMap;
    900897    ///Instantiates a \ref DistMap.
    901898
     
    903900    ///\param g is the digraph, to which we would like to define
    904901    ///the \ref DistMap
    905 #ifdef DOXYGEN
    906902    static DistMap *createDistMap(const Digraph &g)
    907 #else
    908     static DistMap *createDistMap(const Digraph &)
    909 #endif
    910     {
    911       return new DistMap();
    912     }
     903    {
     904      return new DistMap(g);
     905    }
     906
     907    ///The type of the shortest paths.
     908
     909    ///The type of the shortest paths.
     910    ///It must meet the \ref concepts::Path "Path" concept.
     911    typedef lemon::Path<Digraph> Path;
    913912  };
    914913
     
    940939    //Pointer to the map of distances.
    941940    void *_dist;
    942     //Pointer to the source node.
    943     Node _source;
     941    //Pointer to the shortest path to the target node.
     942    void *_path;
     943    //Pointer to the distance of the target node.
     944    int *_di;
    944945
    945946    public:
     
    947948
    948949    /// This constructor does not require parameters, therefore it initiates
    949     /// all of the attributes to default values (0, INVALID).
     950    /// all of the attributes to \c 0.
    950951    BfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0),
    951                       _dist(0), _source(INVALID) {}
     952                      _dist(0), _path(0), _di(0) {}
    952953
    953954    /// Constructor.
    954955
    955     /// This constructor requires some parameters,
    956     /// listed in the parameters list.
    957     /// Others are initiated to 0.
     956    /// This constructor requires one parameter,
     957    /// others are initiated to \c 0.
    958958    /// \param g The digraph the algorithm runs on.
    959     /// \param s The source node.
    960     BfsWizardBase(const GR &g, Node s=INVALID) :
     959    BfsWizardBase(const GR &g) :
    961960      _g(reinterpret_cast<void*>(const_cast<GR*>(&g))),
    962       _reached(0), _processed(0), _pred(0), _dist(0), _source(s) {}
     961      _reached(0), _processed(0), _pred(0), _dist(0),  _path(0), _di(0) {}
    963962
    964963  };
    965964
    966   /// Auxiliary class for the function type interface of BFS algorithm.
    967 
    968   /// This auxiliary class is created to implement the function type
    969   /// interface of \ref Bfs algorithm. It uses the functions and features
    970   /// of the plain \ref Bfs, but it is much simpler to use it.
    971   /// It should only be used through the \ref bfs() function, which makes
    972   /// it easier to use the algorithm.
     965  /// Auxiliary class for the function-type interface of BFS algorithm.
     966
     967  /// This auxiliary class is created to implement the
     968  /// \ref bfs() "function-type interface" of \ref Bfs algorithm.
     969  /// It does not have own \ref run() method, it uses the functions
     970  /// and features of the plain \ref Bfs.
    973971  ///
    974   /// Simplicity means that the way to change the types defined
    975   /// in the traits class is based on functions that returns the new class
    976   /// and not on templatable built-in classes.
    977   /// When using the plain \ref Bfs
    978   /// the new class with the modified type comes from
    979   /// the original class by using the ::
    980   /// operator. In the case of \ref BfsWizard only
    981   /// a function have to be called, and it will
    982   /// return the needed class.
    983   ///
    984   /// It does not have own \ref run() method. When its \ref run() method
    985   /// is called, it initiates a plain \ref Bfs object, and calls the
    986   /// \ref Bfs::run() method of it.
     972  /// This class should only be used through the \ref bfs() function,
     973  /// which makes it easier to use the algorithm.
    987974  template<class TR>
    988975  class BfsWizard : public TR
     
    1007994    ///\brief The type of the map that indicates which nodes are processed.
    1008995    typedef typename TR::ProcessedMap ProcessedMap;
     996    ///The type of the shortest paths
     997    typedef typename TR::Path Path;
    1009998
    1010999  public:
     
    10171006    /// Constructor that requires parameters.
    10181007    /// These parameters will be the default values for the traits class.
    1019     BfsWizard(const Digraph &g, Node s=INVALID) :
    1020       TR(g,s) {}
     1008    /// \param g The digraph the algorithm runs on.
     1009    BfsWizard(const Digraph &g) :
     1010      TR(g) {}
    10211011
    10221012    ///Copy constructor
     
    10251015    ~BfsWizard() {}
    10261016
    1027     ///Runs BFS algorithm from a source node.
    1028 
    1029     ///Runs BFS algorithm from a source node.
    1030     ///The node can be given with the \ref source() function.
     1017    ///Runs BFS algorithm from the given source node.
     1018
     1019    ///This method runs BFS algorithm from node \c s
     1020    ///in order to compute the shortest path to each node.
     1021    void run(Node s)
     1022    {
     1023      Bfs<Digraph,TR> alg(*reinterpret_cast<const Digraph*>(Base::_g));
     1024      if (Base::_pred)
     1025        alg.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
     1026      if (Base::_dist)
     1027        alg.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
     1028      if (Base::_reached)
     1029        alg.reachedMap(*reinterpret_cast<ReachedMap*>(Base::_reached));
     1030      if (Base::_processed)
     1031        alg.processedMap(*reinterpret_cast<ProcessedMap*>(Base::_processed));
     1032      if (s!=INVALID)
     1033        alg.run(s);
     1034      else
     1035        alg.run();
     1036    }
     1037
     1038    ///Finds the shortest path between \c s and \c t.
     1039
     1040    ///This method runs BFS algorithm from node \c s
     1041    ///in order to compute the shortest path to node \c t
     1042    ///(it stops searching when \c t is processed).
     1043    ///
     1044    ///\return \c true if \c t is reachable form \c s.
     1045    bool run(Node s, Node t)
     1046    {
     1047      if (s==INVALID || t==INVALID) throw UninitializedParameter();
     1048      Bfs<Digraph,TR> alg(*reinterpret_cast<const Digraph*>(Base::_g));
     1049      if (Base::_pred)
     1050        alg.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
     1051      if (Base::_dist)
     1052        alg.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
     1053      if (Base::_reached)
     1054        alg.reachedMap(*reinterpret_cast<ReachedMap*>(Base::_reached));
     1055      if (Base::_processed)
     1056        alg.processedMap(*reinterpret_cast<ProcessedMap*>(Base::_processed));
     1057      alg.run(s,t);
     1058      if (Base::_path)
     1059        *reinterpret_cast<Path*>(Base::_path) = alg.path(t);
     1060      if (Base::_di)
     1061        *Base::_di = alg.dist(t);
     1062      return alg.reached(t);
     1063    }
     1064
     1065    ///Runs BFS algorithm to visit all nodes in the digraph.
     1066
     1067    ///This method runs BFS algorithm in order to compute
     1068    ///the shortest path to each node.
    10311069    void run()
    10321070    {
    1033       if(Base::_source==INVALID) throw UninitializedParameter();
    1034       Bfs<Digraph,TR> alg(*reinterpret_cast<const Digraph*>(Base::_g));
    1035       if(Base::_reached)
    1036         alg.reachedMap(*reinterpret_cast<ReachedMap*>(Base::_reached));
    1037       if(Base::_processed)
    1038         alg.processedMap(*reinterpret_cast<ProcessedMap*>(Base::_processed));
    1039       if(Base::_pred)
    1040         alg.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
    1041       if(Base::_dist)
    1042         alg.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
    1043       alg.run(Base::_source);
    1044     }
    1045 
    1046     ///Runs BFS algorithm from the given node.
    1047 
    1048     ///Runs BFS algorithm from the given node.
    1049     ///\param s is the given source.
    1050     void run(Node s)
    1051     {
    1052       Base::_source=s;
    1053       run();
    1054     }
    1055 
    1056     /// Sets the source node, from which the Bfs algorithm runs.
    1057 
    1058     /// Sets the source node, from which the Bfs algorithm runs.
    1059     /// \param s is the source node.
    1060     BfsWizard<TR> &source(Node s)
    1061     {
    1062       Base::_source=s;
    1063       return *this;
     1071      run(INVALID);
    10641072    }
    10651073
     
    10701078      SetPredMapBase(const TR &b) : TR(b) {}
    10711079    };
    1072     ///\brief \ref named-templ-param "Named parameter"
     1080    ///\brief \ref named-func-param "Named parameter"
    10731081    ///for setting \ref PredMap object.
    10741082    ///
    1075     /// \ref named-templ-param "Named parameter"
     1083    ///\ref named-func-param "Named parameter"
    10761084    ///for setting \ref PredMap object.
    10771085    template<class T>
     
    10881096      SetReachedMapBase(const TR &b) : TR(b) {}
    10891097    };
    1090     ///\brief \ref named-templ-param "Named parameter"
     1098    ///\brief \ref named-func-param "Named parameter"
    10911099    ///for setting \ref ReachedMap object.
    10921100    ///
    1093     /// \ref named-templ-param "Named parameter"
     1101    /// \ref named-func-param "Named parameter"
    10941102    ///for setting \ref ReachedMap object.
    10951103    template<class T>
     
    10981106      Base::_reached=reinterpret_cast<void*>(const_cast<T*>(&t));
    10991107      return BfsWizard<SetReachedMapBase<T> >(*this);
     1108    }
     1109
     1110    template<class T>
     1111    struct SetDistMapBase : public Base {
     1112      typedef T DistMap;
     1113      static DistMap *createDistMap(const Digraph &) { return 0; };
     1114      SetDistMapBase(const TR &b) : TR(b) {}
     1115    };
     1116    ///\brief \ref named-func-param "Named parameter"
     1117    ///for setting \ref DistMap object.
     1118    ///
     1119    /// \ref named-func-param "Named parameter"
     1120    ///for setting \ref DistMap object.
     1121    template<class T>
     1122    BfsWizard<SetDistMapBase<T> > distMap(const T &t)
     1123    {
     1124      Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
     1125      return BfsWizard<SetDistMapBase<T> >(*this);
    11001126    }
    11011127
     
    11061132      SetProcessedMapBase(const TR &b) : TR(b) {}
    11071133    };
    1108     ///\brief \ref named-templ-param "Named parameter"
     1134    ///\brief \ref named-func-param "Named parameter"
    11091135    ///for setting \ref ProcessedMap object.
    11101136    ///
    1111     /// \ref named-templ-param "Named parameter"
     1137    /// \ref named-func-param "Named parameter"
    11121138    ///for setting \ref ProcessedMap object.
    11131139    template<class T>
     
    11191145
    11201146    template<class T>
    1121     struct SetDistMapBase : public Base {
    1122       typedef T DistMap;
    1123       static DistMap *createDistMap(const Digraph &) { return 0; };
    1124       SetDistMapBase(const TR &b) : TR(b) {}
    1125     };
    1126     ///\brief \ref named-templ-param "Named parameter"
    1127     ///for setting \ref DistMap object.
    1128     ///
    1129     /// \ref named-templ-param "Named parameter"
    1130     ///for setting \ref DistMap object.
     1147    struct SetPathBase : public Base {
     1148      typedef T Path;
     1149      SetPathBase(const TR &b) : TR(b) {}
     1150    };
     1151    ///\brief \ref named-func-param "Named parameter"
     1152    ///for getting the shortest path to the target node.
     1153    ///
     1154    ///\ref named-func-param "Named parameter"
     1155    ///for getting the shortest path to the target node.
    11311156    template<class T>
    1132     BfsWizard<SetDistMapBase<T> > distMap(const T &t)
    1133     {
    1134       Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
    1135       return BfsWizard<SetDistMapBase<T> >(*this);
     1157    BfsWizard<SetPathBase<T> > path(const T &t)
     1158    {
     1159      Base::_path=reinterpret_cast<void*>(const_cast<T*>(&t));
     1160      return BfsWizard<SetPathBase<T> >(*this);
     1161    }
     1162
     1163    ///\brief \ref named-func-param "Named parameter"
     1164    ///for getting the distance of the target node.
     1165    ///
     1166    ///\ref named-func-param "Named parameter"
     1167    ///for getting the distance of the target node.
     1168    BfsWizard dist(const int &d)
     1169    {
     1170      Base::_di=const_cast<int*>(&d);
     1171      return *this;
    11361172    }
    11371173
    11381174  };
    11391175
    1140   ///Function type interface for Bfs algorithm.
     1176  ///Function-type interface for BFS algorithm.
    11411177
    11421178  /// \ingroup search
    1143   ///Function type interface for Bfs algorithm.
     1179  ///Function-type interface for BFS algorithm.
    11441180  ///
    1145   ///This function also has several
    1146   ///\ref named-templ-func-param "named parameters",
     1181  ///This function also has several \ref named-func-param "named parameters",
    11471182  ///they are declared as the members of class \ref BfsWizard.
    1148   ///The following
    1149   ///example shows how to use these parameters.
     1183  ///The following examples show how to use these parameters.
    11501184  ///\code
    1151   ///  bfs(g,source).predMap(preds).run();
     1185  ///  // Compute shortest path from node s to each node
     1186  ///  bfs(g).predMap(preds).distMap(dists).run(s);
     1187  ///
     1188  ///  // Compute shortest path from s to t
     1189  ///  bool reached = bfs(g).path(p).dist(d).run(s,t);
    11521190  ///\endcode
    11531191  ///\warning Don't forget to put the \ref BfsWizard::run() "run()"
     
    11571195  template<class GR>
    11581196  BfsWizard<BfsWizardBase<GR> >
    1159   bfs(const GR &g,typename GR::Node s=INVALID)
     1197  bfs(const GR &digraph)
    11601198  {
    1161     return BfsWizard<BfsWizardBase<GR> >(g,s);
     1199    return BfsWizard<BfsWizardBase<GR> >(digraph);
    11621200  }
    11631201
  • lemon/concepts/path.h

    r236 r278  
    6767      /// \brief Template assigment
    6868      template <typename CPath>
    69       Path& operator=(const CPath& cpath) {}
     69      Path& operator=(const CPath& cpath) {
     70        ignore_unused_variable_warning(cpath);
     71        return *this;
     72      }
    7073
    7174      /// Length of the path ie. the number of arcs in the path.
  • lemon/dfs.h

    r258 r278  
    3030#include <lemon/assert.h>
    3131#include <lemon/maps.h>
     32#include <lemon/path.h>
    3233
    3334namespace lemon {
     
    117118  ///This class provides an efficient implementation of the %DFS algorithm.
    118119  ///
    119   ///There is also a \ref dfs() "function type interface" for the DFS
     120  ///There is also a \ref dfs() "function-type interface" for the DFS
    120121  ///algorithm, which is convenient in the simplier cases and it can be
    121122  ///used easier.
     
    776777    ///arcs of the %DFS paths.
    777778    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    778     ///
    779     typedef NullMap<typename Digraph::Node,typename Digraph::Arc> PredMap;
     779    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
    780780    ///Instantiates a \ref PredMap.
    781781
     
    784784    ///\ref PredMap.
    785785    ///\todo The digraph alone may be insufficient to initialize
    786 #ifdef DOXYGEN
    787786    static PredMap *createPredMap(const Digraph &g)
    788 #else
    789     static PredMap *createPredMap(const Digraph &)
    790 #endif
    791     {
    792       return new PredMap();
     787    {
     788      return new PredMap(g);
    793789    }
    794790
     
    797793    ///The type of the map that indicates which nodes are processed.
    798794    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     795    ///By default it is a NullMap.
    799796    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    800797    ///Instantiates a \ref ProcessedMap.
     
    831828    ///The type of the map that stores the distances of the nodes.
    832829    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    833     ///
    834     typedef NullMap<typename Digraph::Node,int> DistMap;
     830    typedef typename Digraph::template NodeMap<int> DistMap;
    835831    ///Instantiates a \ref DistMap.
    836832
     
    838834    ///\param g is the digraph, to which we would like to define
    839835    ///the \ref DistMap
    840 #ifdef DOXYGEN
    841836    static DistMap *createDistMap(const Digraph &g)
    842 #else
    843     static DistMap *createDistMap(const Digraph &)
    844 #endif
    845     {
    846       return new DistMap();
    847     }
     837    {
     838      return new DistMap(g);
     839    }
     840
     841    ///The type of the DFS paths.
     842
     843    ///The type of the DFS paths.
     844    ///It must meet the \ref concepts::Path "Path" concept.
     845    typedef lemon::Path<Digraph> Path;
    848846  };
    849847
     
    875873    //Pointer to the map of distances.
    876874    void *_dist;
    877     //Pointer to the source node.
    878     Node _source;
     875    //Pointer to the DFS path to the target node.
     876    void *_path;
     877    //Pointer to the distance of the target node.
     878    int *_di;
    879879
    880880    public:
     
    882882
    883883    /// This constructor does not require parameters, therefore it initiates
    884     /// all of the attributes to default values (0, INVALID).
     884    /// all of the attributes to \c 0.
    885885    DfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0),
    886                       _dist(0), _source(INVALID) {}
     886                      _dist(0), _path(0), _di(0) {}
    887887
    888888    /// Constructor.
    889889
    890     /// This constructor requires some parameters,
    891     /// listed in the parameters list.
    892     /// Others are initiated to 0.
     890    /// This constructor requires one parameter,
     891    /// others are initiated to \c 0.
    893892    /// \param g The digraph the algorithm runs on.
    894     /// \param s The source node.
    895     DfsWizardBase(const GR &g, Node s=INVALID) :
     893    DfsWizardBase(const GR &g) :
    896894      _g(reinterpret_cast<void*>(const_cast<GR*>(&g))),
    897       _reached(0), _processed(0), _pred(0), _dist(0), _source(s) {}
     895      _reached(0), _processed(0), _pred(0), _dist(0),  _path(0), _di(0) {}
    898896
    899897  };
    900898
    901   /// Auxiliary class for the function type interface of DFS algorithm.
    902 
    903   /// This auxiliary class is created to implement the function type
    904   /// interface of \ref Dfs algorithm. It uses the functions and features
    905   /// of the plain \ref Dfs, but it is much simpler to use it.
    906   /// It should only be used through the \ref dfs() function, which makes
    907   /// it easier to use the algorithm.
     899  /// Auxiliary class for the function-type interface of DFS algorithm.
     900
     901  /// This auxiliary class is created to implement the
     902  /// \ref dfs() "function-type interface" of \ref Dfs algorithm.
     903  /// It does not have own \ref run() method, it uses the functions
     904  /// and features of the plain \ref Dfs.
    908905  ///
    909   /// Simplicity means that the way to change the types defined
    910   /// in the traits class is based on functions that returns the new class
    911   /// and not on templatable built-in classes.
    912   /// When using the plain \ref Dfs
    913   /// the new class with the modified type comes from
    914   /// the original class by using the ::
    915   /// operator. In the case of \ref DfsWizard only
    916   /// a function have to be called, and it will
    917   /// return the needed class.
    918   ///
    919   /// It does not have own \ref run() method. When its \ref run() method
    920   /// is called, it initiates a plain \ref Dfs object, and calls the
    921   /// \ref Dfs::run() method of it.
     906  /// This class should only be used through the \ref dfs() function,
     907  /// which makes it easier to use the algorithm.
    922908  template<class TR>
    923909  class DfsWizard : public TR
     
    934920
    935921    ///\brief The type of the map that stores the predecessor
    936     ///arcs of the shortest paths.
     922    ///arcs of the DFS paths.
    937923    typedef typename TR::PredMap PredMap;
    938924    ///\brief The type of the map that stores the distances of the nodes.
     
    942928    ///\brief The type of the map that indicates which nodes are processed.
    943929    typedef typename TR::ProcessedMap ProcessedMap;
     930    ///The type of the DFS paths
     931    typedef typename TR::Path Path;
    944932
    945933  public:
     
    952940    /// Constructor that requires parameters.
    953941    /// These parameters will be the default values for the traits class.
    954     DfsWizard(const Digraph &g, Node s=INVALID) :
    955       TR(g,s) {}
     942    /// \param g The digraph the algorithm runs on.
     943    DfsWizard(const Digraph &g) :
     944      TR(g) {}
    956945
    957946    ///Copy constructor
     
    960949    ~DfsWizard() {}
    961950
    962     ///Runs DFS algorithm from a source node.
    963 
    964     ///Runs DFS algorithm from a source node.
    965     ///The node can be given with the \ref source() function.
     951    ///Runs DFS algorithm from the given source node.
     952
     953    ///This method runs DFS algorithm from node \c s
     954    ///in order to compute the DFS path to each node.
     955    void run(Node s)
     956    {
     957      Dfs<Digraph,TR> alg(*reinterpret_cast<const Digraph*>(Base::_g));
     958      if (Base::_pred)
     959        alg.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
     960      if (Base::_dist)
     961        alg.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
     962      if (Base::_reached)
     963        alg.reachedMap(*reinterpret_cast<ReachedMap*>(Base::_reached));
     964      if (Base::_processed)
     965        alg.processedMap(*reinterpret_cast<ProcessedMap*>(Base::_processed));
     966      if (s!=INVALID)
     967        alg.run(s);
     968      else
     969        alg.run();
     970    }
     971
     972    ///Finds the DFS path between \c s and \c t.
     973
     974    ///This method runs DFS algorithm from node \c s
     975    ///in order to compute the DFS path to node \c t
     976    ///(it stops searching when \c t is processed).
     977    ///
     978    ///\return \c true if \c t is reachable form \c s.
     979    bool run(Node s, Node t)
     980    {
     981      if (s==INVALID || t==INVALID) throw UninitializedParameter();
     982      Dfs<Digraph,TR> alg(*reinterpret_cast<const Digraph*>(Base::_g));
     983      if (Base::_pred)
     984        alg.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
     985      if (Base::_dist)
     986        alg.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
     987      if (Base::_reached)
     988        alg.reachedMap(*reinterpret_cast<ReachedMap*>(Base::_reached));
     989      if (Base::_processed)
     990        alg.processedMap(*reinterpret_cast<ProcessedMap*>(Base::_processed));
     991      alg.run(s,t);
     992      if (Base::_path)
     993        *reinterpret_cast<Path*>(Base::_path) = alg.path(t);
     994      if (Base::_di)
     995        *Base::_di = alg.dist(t);
     996      return alg.reached(t);
     997      }
     998
     999    ///Runs DFS algorithm to visit all nodes in the digraph.
     1000
     1001    ///This method runs DFS algorithm in order to compute
     1002    ///the DFS path to each node.
    9661003    void run()
    9671004    {
    968       if(Base::_source==INVALID) throw UninitializedParameter();
    969       Dfs<Digraph,TR> alg(*reinterpret_cast<const Digraph*>(Base::_g));
    970       if(Base::_reached)
    971         alg.reachedMap(*reinterpret_cast<ReachedMap*>(Base::_reached));
    972       if(Base::_processed)
    973         alg.processedMap(*reinterpret_cast<ProcessedMap*>(Base::_processed));
    974       if(Base::_pred)
    975         alg.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
    976       if(Base::_dist)
    977         alg.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
    978       alg.run(Base::_source);
    979     }
    980 
    981     ///Runs DFS algorithm from the given node.
    982 
    983     ///Runs DFS algorithm from the given node.
    984     ///\param s is the given source.
    985     void run(Node s)
    986     {
    987       Base::_source=s;
    988       run();
    989     }
    990 
    991     /// Sets the source node, from which the Dfs algorithm runs.
    992 
    993     /// Sets the source node, from which the Dfs algorithm runs.
    994     /// \param s is the source node.
    995     DfsWizard<TR> &source(Node s)
    996     {
    997       Base::_source=s;
    998       return *this;
     1005      run(INVALID);
    9991006    }
    10001007
     
    10051012      SetPredMapBase(const TR &b) : TR(b) {}
    10061013    };
    1007     ///\brief \ref named-templ-param "Named parameter"
     1014    ///\brief \ref named-func-param "Named parameter"
    10081015    ///for setting \ref PredMap object.
    10091016    ///
    1010     ///\ref named-templ-param "Named parameter"
     1017    ///\ref named-func-param "Named parameter"
    10111018    ///for setting \ref PredMap object.
    10121019    template<class T>
     
    10231030      SetReachedMapBase(const TR &b) : TR(b) {}
    10241031    };
    1025     ///\brief \ref named-templ-param "Named parameter"
     1032    ///\brief \ref named-func-param "Named parameter"
    10261033    ///for setting \ref ReachedMap object.
    10271034    ///
    1028     /// \ref named-templ-param "Named parameter"
     1035    /// \ref named-func-param "Named parameter"
    10291036    ///for setting \ref ReachedMap object.
    10301037    template<class T>
     
    10331040      Base::_reached=reinterpret_cast<void*>(const_cast<T*>(&t));
    10341041      return DfsWizard<SetReachedMapBase<T> >(*this);
     1042    }
     1043
     1044    template<class T>
     1045    struct SetDistMapBase : public Base {
     1046      typedef T DistMap;
     1047      static DistMap *createDistMap(const Digraph &) { return 0; };
     1048      SetDistMapBase(const TR &b) : TR(b) {}
     1049    };
     1050    ///\brief \ref named-func-param "Named parameter"
     1051    ///for setting \ref DistMap object.
     1052    ///
     1053    /// \ref named-func-param "Named parameter"
     1054    ///for setting \ref DistMap object.
     1055    template<class T>
     1056    DfsWizard<SetDistMapBase<T> > distMap(const T &t)
     1057    {
     1058      Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
     1059      return DfsWizard<SetDistMapBase<T> >(*this);
    10351060    }
    10361061
     
    10411066      SetProcessedMapBase(const TR &b) : TR(b) {}
    10421067    };
    1043     ///\brief \ref named-templ-param "Named parameter"
     1068    ///\brief \ref named-func-param "Named parameter"
    10441069    ///for setting \ref ProcessedMap object.
    10451070    ///
    1046     /// \ref named-templ-param "Named parameter"
     1071    /// \ref named-func-param "Named parameter"
    10471072    ///for setting \ref ProcessedMap object.
    10481073    template<class T>
     
    10541079
    10551080    template<class T>
    1056     struct SetDistMapBase : public Base {
    1057       typedef T DistMap;
    1058       static DistMap *createDistMap(const Digraph &) { return 0; };
    1059       SetDistMapBase(const TR &b) : TR(b) {}
    1060     };
    1061     ///\brief \ref named-templ-param "Named parameter"
    1062     ///for setting \ref DistMap object.
    1063     ///
    1064     ///\ref named-templ-param "Named parameter"
    1065     ///for setting \ref DistMap object.
     1081    struct SetPathBase : public Base {
     1082      typedef T Path;
     1083      SetPathBase(const TR &b) : TR(b) {}
     1084    };
     1085    ///\brief \ref named-func-param "Named parameter"
     1086    ///for getting the DFS path to the target node.
     1087    ///
     1088    ///\ref named-func-param "Named parameter"
     1089    ///for getting the DFS path to the target node.
    10661090    template<class T>
    1067     DfsWizard<SetDistMapBase<T> > distMap(const T &t)
    1068     {
    1069       Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
    1070       return DfsWizard<SetDistMapBase<T> >(*this);
     1091    DfsWizard<SetPathBase<T> > path(const T &t)
     1092    {
     1093      Base::_path=reinterpret_cast<void*>(const_cast<T*>(&t));
     1094      return DfsWizard<SetPathBase<T> >(*this);
     1095    }
     1096
     1097    ///\brief \ref named-func-param "Named parameter"
     1098    ///for getting the distance of the target node.
     1099    ///
     1100    ///\ref named-func-param "Named parameter"
     1101    ///for getting the distance of the target node.
     1102    DfsWizard dist(const int &d)
     1103    {
     1104      Base::_di=const_cast<int*>(&d);
     1105      return *this;
    10711106    }
    10721107
    10731108  };
    10741109
    1075   ///Function type interface for Dfs algorithm.
     1110  ///Function-type interface for DFS algorithm.
    10761111
    10771112  ///\ingroup search
    1078   ///Function type interface for Dfs algorithm.
     1113  ///Function-type interface for DFS algorithm.
    10791114  ///
    1080   ///This function also has several
    1081   ///\ref named-templ-func-param "named parameters",
     1115  ///This function also has several \ref named-func-param "named parameters",
    10821116  ///they are declared as the members of class \ref DfsWizard.
    1083   ///The following
    1084   ///example shows how to use these parameters.
     1117  ///The following examples show how to use these parameters.
    10851118  ///\code
    1086   ///  dfs(g,source).predMap(preds).run();
     1119  ///  // Compute the DFS tree
     1120  ///  dfs(g).predMap(preds).distMap(dists).run(s);
     1121  ///
     1122  ///  // Compute the DFS path from s to t
     1123  ///  bool reached = dfs(g).path(p).dist(d).run(s,t);
    10871124  ///\endcode
     1125
    10881126  ///\warning Don't forget to put the \ref DfsWizard::run() "run()"
    10891127  ///to the end of the parameter list.
     
    10921130  template<class GR>
    10931131  DfsWizard<DfsWizardBase<GR> >
    1094   dfs(const GR &g,typename GR::Node s=INVALID)
     1132  dfs(const GR &digraph)
    10951133  {
    1096     return DfsWizard<DfsWizardBase<GR> >(g,s);
     1134    return DfsWizard<DfsWizardBase<GR> >(digraph);
    10971135  }
    10981136
  • lemon/dijkstra.h

    r258 r278  
    3131#include <lemon/error.h>
    3232#include <lemon/maps.h>
     33#include <lemon/path.h>
    3334
    3435namespace lemon {
     
    200201  ///It is also possible to change the underlying priority heap.
    201202  ///
    202   ///There is also a \ref dijkstra() "function type interface" for the
     203  ///There is also a \ref dijkstra() "function-type interface" for the
    203204  ///%Dijkstra algorithm, which is convenient in the simplier cases and
    204205  ///it can be used easier.
     
    988989    ///arcs of the shortest paths.
    989990    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    990     typedef NullMap <typename Digraph::Node,typename Digraph::Arc> PredMap;
     991    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
    991992    ///Instantiates a \ref PredMap.
    992993
     
    995996    ///\ref PredMap.
    996997    ///\todo The digraph alone may be insufficient to initialize
    997 #ifdef DOXYGEN
    998998    static PredMap *createPredMap(const Digraph &g)
    999 #else
    1000     static PredMap *createPredMap(const Digraph &)
    1001 #endif
    1002     {
    1003       return new PredMap();
     999    {
     1000      return new PredMap(g);
    10041001    }
    10051002
     
    10311028    ///The type of the map that stores the distances of the nodes.
    10321029    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    1033     typedef NullMap<typename Digraph::Node,Value> DistMap;
     1030    typedef typename Digraph::template NodeMap<typename LM::Value> DistMap;
    10341031    ///Instantiates a \ref DistMap.
    10351032
     
    10371034    ///\param g is the digraph, to which we would like to define
    10381035    ///the \ref DistMap
    1039 #ifdef DOXYGEN
    10401036    static DistMap *createDistMap(const Digraph &g)
    1041 #else
    1042     static DistMap *createDistMap(const Digraph &)
    1043 #endif
    1044     {
    1045       return new DistMap();
    1046     }
     1037    {
     1038      return new DistMap(g);
     1039    }
     1040
     1041    ///The type of the shortest paths.
     1042
     1043    ///The type of the shortest paths.
     1044    ///It must meet the \ref concepts::Path "Path" concept.
     1045    typedef lemon::Path<Digraph> Path;
    10471046  };
    10481047
     
    10661065    //Pointer to the digraph the algorithm runs on.
    10671066    void *_g;
    1068     //Pointer to the length map
     1067    //Pointer to the length map.
    10691068    void *_length;
    10701069    //Pointer to the map of processed nodes.
     
    10741073    //Pointer to the map of distances.
    10751074    void *_dist;
    1076     //Pointer to the source node.
    1077     Node _source;
     1075    //Pointer to the shortest path to the target node.
     1076    void *_path;
     1077    //Pointer to the distance of the target node.
     1078    void *_di;
    10781079
    10791080  public:
     
    10811082
    10821083    /// This constructor does not require parameters, therefore it initiates
    1083     /// all of the attributes to default values (0, INVALID).
     1084    /// all of the attributes to \c 0.
    10841085    DijkstraWizardBase() : _g(0), _length(0), _processed(0), _pred(0),
    1085                            _dist(0), _source(INVALID) {}
     1086                           _dist(0), _path(0), _di(0) {}
    10861087
    10871088    /// Constructor.
    10881089
    1089     /// This constructor requires some parameters,
    1090     /// listed in the parameters list.
    1091     /// Others are initiated to 0.
     1090    /// This constructor requires two parameters,
     1091    /// others are initiated to \c 0.
    10921092    /// \param g The digraph the algorithm runs on.
    10931093    /// \param l The length map.
    1094     /// \param s The source node.
    1095     DijkstraWizardBase(const GR &g,const LM &l, Node s=INVALID) :
     1094    DijkstraWizardBase(const GR &g,const LM &l) :
    10961095      _g(reinterpret_cast<void*>(const_cast<GR*>(&g))),
    10971096      _length(reinterpret_cast<void*>(const_cast<LM*>(&l))),
    1098       _processed(0), _pred(0), _dist(0), _source(s) {}
     1097      _processed(0), _pred(0), _dist(0), _path(0), _di(0) {}
    10991098
    11001099  };
    11011100
    1102   /// Auxiliary class for the function type interface of Dijkstra algorithm.
    1103 
    1104   /// This auxiliary class is created to implement the function type
    1105   /// interface of \ref Dijkstra algorithm. It uses the functions and features
    1106   /// of the plain \ref Dijkstra, but it is much simpler to use it.
    1107   /// It should only be used through the \ref dijkstra() function, which makes
    1108   /// it easier to use the algorithm.
     1101  /// Auxiliary class for the function-type interface of Dijkstra algorithm.
     1102
     1103  /// This auxiliary class is created to implement the
     1104  /// \ref dijkstra() "function-type interface" of \ref Dijkstra algorithm.
     1105  /// It does not have own \ref run() method, it uses the functions
     1106  /// and features of the plain \ref Dijkstra.
    11091107  ///
    1110   /// Simplicity means that the way to change the types defined
    1111   /// in the traits class is based on functions that returns the new class
    1112   /// and not on templatable built-in classes.
    1113   /// When using the plain \ref Dijkstra
    1114   /// the new class with the modified type comes from
    1115   /// the original class by using the ::
    1116   /// operator. In the case of \ref DijkstraWizard only
    1117   /// a function have to be called, and it will
    1118   /// return the needed class.
    1119   ///
    1120   /// It does not have own \ref run() method. When its \ref run() method
    1121   /// is called, it initiates a plain \ref Dijkstra object, and calls the
    1122   /// \ref Dijkstra::run() method of it.
     1108  /// This class should only be used through the \ref dijkstra() function,
     1109  /// which makes it easier to use the algorithm.
    11231110  template<class TR>
    11241111  class DijkstraWizard : public TR
     
    11451132    ///The type of the map that indicates which nodes are processed.
    11461133    typedef typename TR::ProcessedMap ProcessedMap;
     1134    ///The type of the shortest paths
     1135    typedef typename TR::Path Path;
    11471136    ///The heap type used by the dijkstra algorithm.
    11481137    typedef typename TR::Heap Heap;
     
    11571146    /// Constructor that requires parameters.
    11581147    /// These parameters will be the default values for the traits class.
    1159     DijkstraWizard(const Digraph &g,const LengthMap &l, Node s=INVALID) :
    1160       TR(g,l,s) {}
     1148    /// \param g The digraph the algorithm runs on.
     1149    /// \param l The length map.
     1150    DijkstraWizard(const Digraph &g, const LengthMap &l) :
     1151      TR(g,l) {}
    11611152
    11621153    ///Copy constructor
     
    11651156    ~DijkstraWizard() {}
    11661157
    1167     ///Runs Dijkstra algorithm from a source node.
    1168 
    1169     ///Runs Dijkstra algorithm from a source node.
    1170     ///The node can be given with the \ref source() function.
    1171     void run()
    1172     {
    1173       if(Base::_source==INVALID) throw UninitializedParameter();
     1158    ///Runs Dijkstra algorithm from the given source node.
     1159
     1160    ///This method runs %Dijkstra algorithm from the given source node
     1161    ///in order to compute the shortest path to each node.
     1162    void run(Node s)
     1163    {
     1164      if (s==INVALID) throw UninitializedParameter();
    11741165      Dijkstra<Digraph,LengthMap,TR>
    1175         dij(*reinterpret_cast<const Digraph*>(Base::_g),
    1176             *reinterpret_cast<const LengthMap*>(Base::_length));
    1177       if(Base::_processed)
    1178         dij.processedMap(*reinterpret_cast<ProcessedMap*>(Base::_processed));
    1179       if(Base::_pred)
    1180         dij.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
    1181       if(Base::_dist)
    1182         dij.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
    1183       dij.run(Base::_source);
    1184     }
    1185 
    1186     ///Runs Dijkstra algorithm from the given node.
    1187 
    1188     ///Runs Dijkstra algorithm from the given node.
    1189     ///\param s is the given source.
    1190     void run(Node s)
    1191     {
    1192       Base::_source=s;
    1193       run();
    1194     }
    1195 
    1196     /// Sets the source node, from which the Dijkstra algorithm runs.
    1197 
    1198     /// Sets the source node, from which the Dijkstra algorithm runs.
    1199     /// \param s is the source node.
    1200     DijkstraWizard<TR> &source(Node s)
    1201     {
    1202       Base::_source=s;
    1203       return *this;
     1166        dijk(*reinterpret_cast<const Digraph*>(Base::_g),
     1167             *reinterpret_cast<const LengthMap*>(Base::_length));
     1168      if (Base::_pred)
     1169        dijk.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
     1170      if (Base::_dist)
     1171        dijk.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
     1172      if (Base::_processed)
     1173        dijk.processedMap(*reinterpret_cast<ProcessedMap*>(Base::_processed));
     1174      dijk.run(s);
     1175    }
     1176
     1177    ///Finds the shortest path between \c s and \c t.
     1178
     1179    ///This method runs the %Dijkstra algorithm from node \c s
     1180    ///in order to compute the shortest path to node \c t
     1181    ///(it stops searching when \c t is processed).
     1182    ///
     1183    ///\return \c true if \c t is reachable form \c s.
     1184    bool run(Node s, Node t)
     1185    {
     1186      if (s==INVALID || t==INVALID) throw UninitializedParameter();
     1187      Dijkstra<Digraph,LengthMap,TR>
     1188        dijk(*reinterpret_cast<const Digraph*>(Base::_g),
     1189             *reinterpret_cast<const LengthMap*>(Base::_length));
     1190      if (Base::_pred)
     1191        dijk.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
     1192      if (Base::_dist)
     1193        dijk.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
     1194      if (Base::_processed)
     1195        dijk.processedMap(*reinterpret_cast<ProcessedMap*>(Base::_processed));
     1196      dijk.run(s,t);
     1197      if (Base::_path)
     1198        *reinterpret_cast<Path*>(Base::_path) = dijk.path(t);
     1199      if (Base::_di)
     1200        *reinterpret_cast<Value*>(Base::_di) = dijk.dist(t);
     1201      return dijk.reached(t);
    12041202    }
    12051203
     
    12101208      SetPredMapBase(const TR &b) : TR(b) {}
    12111209    };
    1212     ///\brief \ref named-templ-param "Named parameter"
     1210    ///\brief \ref named-func-param "Named parameter"
    12131211    ///for setting \ref PredMap object.
    12141212    ///
    1215     ///\ref named-templ-param "Named parameter"
     1213    ///\ref named-func-param "Named parameter"
    12161214    ///for setting \ref PredMap object.
    12171215    template<class T>
     
    12201218      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
    12211219      return DijkstraWizard<SetPredMapBase<T> >(*this);
     1220    }
     1221
     1222    template<class T>
     1223    struct SetDistMapBase : public Base {
     1224      typedef T DistMap;
     1225      static DistMap *createDistMap(const Digraph &) { return 0; };
     1226      SetDistMapBase(const TR &b) : TR(b) {}
     1227    };
     1228    ///\brief \ref named-func-param "Named parameter"
     1229    ///for setting \ref DistMap object.
     1230    ///
     1231    ///\ref named-func-param "Named parameter"
     1232    ///for setting \ref DistMap object.
     1233    template<class T>
     1234    DijkstraWizard<SetDistMapBase<T> > distMap(const T &t)
     1235    {
     1236      Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
     1237      return DijkstraWizard<SetDistMapBase<T> >(*this);
    12221238    }
    12231239
     
    12281244      SetProcessedMapBase(const TR &b) : TR(b) {}
    12291245    };
    1230     ///\brief \ref named-templ-param "Named parameter"
     1246    ///\brief \ref named-func-param "Named parameter"
    12311247    ///for setting \ref ProcessedMap object.
    12321248    ///
    1233     /// \ref named-templ-param "Named parameter"
     1249    /// \ref named-func-param "Named parameter"
    12341250    ///for setting \ref ProcessedMap object.
    12351251    template<class T>
     
    12411257
    12421258    template<class T>
    1243     struct SetDistMapBase : public Base {
    1244       typedef T DistMap;
    1245       static DistMap *createDistMap(const Digraph &) { return 0; };
    1246       SetDistMapBase(const TR &b) : TR(b) {}
    1247     };
    1248     ///\brief \ref named-templ-param "Named parameter"
    1249     ///for setting \ref DistMap object.
    1250     ///
    1251     ///\ref named-templ-param "Named parameter"
    1252     ///for setting \ref DistMap object.
     1259    struct SetPathBase : public Base {
     1260      typedef T Path;
     1261      SetPathBase(const TR &b) : TR(b) {}
     1262    };
     1263    ///\brief \ref named-func-param "Named parameter"
     1264    ///for getting the shortest path to the target node.
     1265    ///
     1266    ///\ref named-func-param "Named parameter"
     1267    ///for getting the shortest path to the target node.
    12531268    template<class T>
    1254     DijkstraWizard<SetDistMapBase<T> > distMap(const T &t)
    1255     {
    1256       Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
    1257       return DijkstraWizard<SetDistMapBase<T> >(*this);
     1269    DijkstraWizard<SetPathBase<T> > path(const T &t)
     1270    {
     1271      Base::_path=reinterpret_cast<void*>(const_cast<T*>(&t));
     1272      return DijkstraWizard<SetPathBase<T> >(*this);
     1273    }
     1274
     1275    ///\brief \ref named-func-param "Named parameter"
     1276    ///for getting the distance of the target node.
     1277    ///
     1278    ///\ref named-func-param "Named parameter"
     1279    ///for getting the distance of the target node.
     1280    DijkstraWizard dist(const Value &d)
     1281    {
     1282      Base::_di=reinterpret_cast<void*>(const_cast<Value*>(&d));
     1283      return *this;
    12581284    }
    12591285
    12601286  };
    12611287
    1262   ///Function type interface for Dijkstra algorithm.
     1288  ///Function-type interface for Dijkstra algorithm.
    12631289
    12641290  /// \ingroup shortest_path
    1265   ///Function type interface for Dijkstra algorithm.
     1291  ///Function-type interface for Dijkstra algorithm.
    12661292  ///
    1267   ///This function also has several
    1268   ///\ref named-templ-func-param "named parameters",
     1293  ///This function also has several \ref named-func-param "named parameters",
    12691294  ///they are declared as the members of class \ref DijkstraWizard.
    1270   ///The following
    1271   ///example shows how to use these parameters.
     1295  ///The following examples show how to use these parameters.
    12721296  ///\code
    1273   ///  dijkstra(g,length,source).predMap(preds).run();
     1297  ///  // Compute shortest path from node s to each node
     1298  ///  dijkstra(g,length).predMap(preds).distMap(dists).run(s);
     1299  ///
     1300  ///  // Compute shortest path from s to t
     1301  ///  bool reached = dijkstra(g,length).path(p).dist(d).run(s,t);
    12741302  ///\endcode
    12751303  ///\warning Don't forget to put the \ref DijkstraWizard::run() "run()"
     
    12791307  template<class GR, class LM>
    12801308  DijkstraWizard<DijkstraWizardBase<GR,LM> >
    1281   dijkstra(const GR &g,const LM &l,typename GR::Node s=INVALID)
     1309  dijkstra(const GR &digraph, const LM &length)
    12821310  {
    1283     return DijkstraWizard<DijkstraWizardBase<GR,LM> >(g,l,s);
     1311    return DijkstraWizard<DijkstraWizardBase<GR,LM> >(digraph,length);
    12841312  }
    12851313
  • test/bfs_test.cc

    r228 r278  
    6363  BType::DistMap d(G);
    6464  BType::PredMap p(G);
    65   //  BType::PredNodeMap pn(G);
    6665
    6766  BType bfs_test(G);
     
    7372  n  = bfs_test.predNode(n);
    7473  d  = bfs_test.distMap();
    75 
    7674  p  = bfs_test.predMap();
    77   //  pn = bfs_test.predNodeMap();
    7875  b  = bfs_test.reached(n);
    7976
     
    8986
    9087  Digraph g;
    91   bfs(g,Node()).run();
    92   bfs(g).source(Node()).run();
     88  bool b;
     89  bfs(g).run(Node());
     90  b=bfs(g).run(Node(),Node());
     91  bfs(g).run();
    9392  bfs(g)
    94     .predMap(concepts::WriteMap<Node,Arc>())
    95     .distMap(concepts::WriteMap<Node,VType>())
     93    .predMap(concepts::ReadWriteMap<Node,Arc>())
     94    .distMap(concepts::ReadWriteMap<Node,VType>())
    9695    .reachedMap(concepts::ReadWriteMap<Node,bool>())
    9796    .processedMap(concepts::WriteMap<Node,bool>())
    9897    .run(Node());
     98  b=bfs(g)
     99    .predMap(concepts::ReadWriteMap<Node,Arc>())
     100    .distMap(concepts::ReadWriteMap<Node,VType>())
     101    .reachedMap(concepts::ReadWriteMap<Node,bool>())
     102    .processedMap(concepts::WriteMap<Node,bool>())
     103    .path(concepts::Path<Digraph>())
     104    .dist(VType())
     105    .run(Node(),Node());
     106  bfs(g)
     107    .predMap(concepts::ReadWriteMap<Node,Arc>())
     108    .distMap(concepts::ReadWriteMap<Node,VType>())
     109    .reachedMap(concepts::ReadWriteMap<Node,bool>())
     110    .processedMap(concepts::WriteMap<Node,bool>())
     111    .run();
    99112}
    100113
     
    115128  bfs_test.run(s);
    116129
    117   check(bfs_test.dist(t)==2,"Bfs found a wrong path." << bfs_test.dist(t));
     130  check(bfs_test.dist(t)==2,"Bfs found a wrong path.");
    118131
    119132  Path<Digraph> p = bfs_test.path(t);
     
    129142    check( !bfs_test.reached(u) ||
    130143           (bfs_test.dist(v) <= bfs_test.dist(u)+1),
    131            "Wrong output." << G.id(v) << ' ' << G.id(u));
     144           "Wrong output. " << G.id(u) << "->" << G.id(v));
    132145  }
    133146
     
    141154        check(bfs_test.dist(v) - bfs_test.dist(u) == 1,
    142155              "Wrong distance. Difference: "
    143               << std::abs(bfs_test.dist(v) - bfs_test.dist(u)
    144                           - 1));
     156              << std::abs(bfs_test.dist(v) - bfs_test.dist(u) - 1));
    145157      }
    146158    }
     159  }
     160
     161  {
     162    NullMap<Node,Arc> myPredMap;
     163    bfs(G).predMap(myPredMap).run(s);
    147164  }
    148165}
  • test/dfs_test.cc

    r228 r278  
    2121#include <lemon/list_graph.h>
    2222#include <lemon/lgf_reader.h>
    23 
    2423#include <lemon/dfs.h>
    2524#include <lemon/path.h>
     
    8988
    9089  Digraph g;
    91   dfs(g,Node()).run();
    92   dfs(g).source(Node()).run();
     90  bool b;
     91  dfs(g).run(Node());
     92  b=dfs(g).run(Node(),Node());
     93  dfs(g).run();
    9394  dfs(g)
    94     .predMap(concepts::WriteMap<Node,Arc>())
    95     .distMap(concepts::WriteMap<Node,VType>())
     95    .predMap(concepts::ReadWriteMap<Node,Arc>())
     96    .distMap(concepts::ReadWriteMap<Node,VType>())
    9697    .reachedMap(concepts::ReadWriteMap<Node,bool>())
    9798    .processedMap(concepts::WriteMap<Node,bool>())
    9899    .run(Node());
     100  b=dfs(g)
     101    .predMap(concepts::ReadWriteMap<Node,Arc>())
     102    .distMap(concepts::ReadWriteMap<Node,VType>())
     103    .reachedMap(concepts::ReadWriteMap<Node,bool>())
     104    .processedMap(concepts::WriteMap<Node,bool>())
     105    .path(concepts::Path<Digraph>())
     106    .dist(VType())
     107    .run(Node(),Node());
     108  dfs(g)
     109    .predMap(concepts::ReadWriteMap<Node,Arc>())
     110    .distMap(concepts::ReadWriteMap<Node,VType>())
     111    .reachedMap(concepts::ReadWriteMap<Node,bool>())
     112    .processedMap(concepts::WriteMap<Node,bool>())
     113    .run();
    99114}
    100115
     
    130145        check(dfs_test.dist(v) - dfs_test.dist(u) == 1,
    131146              "Wrong distance. (" << dfs_test.dist(u) << "->"
    132               <<dfs_test.dist(v) << ')');
     147              << dfs_test.dist(v) << ")");
    133148      }
    134149    }
     150  }
     151
     152  {
     153    NullMap<Node,Arc> myPredMap;
     154    dfs(G).predMap(myPredMap).run(s);
    135155  }
    136156}
  • test/dijkstra_test.cc

    r228 r278  
    2121#include <lemon/list_graph.h>
    2222#include <lemon/lgf_reader.h>
    23 
    2423#include <lemon/dijkstra.h>
    2524#include <lemon/path.h>
     
    6564  DType::DistMap d(G);
    6665  DType::PredMap p(G);
    67   //  DType::PredNodeMap pn(G);
    6866  LengthMap length;
    6967
     
    7775  d  = dijkstra_test.distMap();
    7876  p  = dijkstra_test.predMap();
    79   //  pn = dijkstra_test.predNodeMap();
    8077  b  = dijkstra_test.reached(n);
    8178
     
    9289
    9390  Digraph g;
    94   dijkstra(g,LengthMap(),Node()).run();
    95   dijkstra(g,LengthMap()).source(Node()).run();
     91  bool b;
     92  dijkstra(g,LengthMap()).run(Node());
     93  b=dijkstra(g,LengthMap()).run(Node(),Node());
    9694  dijkstra(g,LengthMap())
    97     .predMap(concepts::WriteMap<Node,Arc>())
    98     .distMap(concepts::WriteMap<Node,VType>())
     95    .predMap(concepts::ReadWriteMap<Node,Arc>())
     96    .distMap(concepts::ReadWriteMap<Node,VType>())
     97    .processedMap(concepts::WriteMap<Node,bool>())
    9998    .run(Node());
     99  b=dijkstra(g,LengthMap())
     100    .predMap(concepts::ReadWriteMap<Node,Arc>())
     101    .distMap(concepts::ReadWriteMap<Node,VType>())
     102    .processedMap(concepts::WriteMap<Node,bool>())
     103    .path(concepts::Path<Digraph>())
     104    .dist(VType())
     105    .run(Node(),Node());
    100106}
    101107
     
    123129
    124130  Path<Digraph> p = dijkstra_test.path(t);
    125   check(p.length()==3,"getPath() found a wrong path.");
     131  check(p.length()==3,"path() found a wrong path.");
    126132  check(checkPath(G, p),"path() found a wrong path.");
    127133  check(pathSource(G, p) == s,"path() found a wrong path.");
     
    133139    check( !dijkstra_test.reached(u) ||
    134140           (dijkstra_test.dist(v) - dijkstra_test.dist(u) <= length[e]),
    135            "dist(target)-dist(source)-arc_length= " <<
     141           "Wrong output. dist(target)-dist(source)-arc_length=" <<
    136142           dijkstra_test.dist(v) - dijkstra_test.dist(u) - length[e]);
    137143  }
Note: See TracChangeset for help on using the changeset viewer.