LEMON/LEMON-main Changeset - r517:2b6d5d22bb23

Repositories » LEMON » LEMON-main

Summary
Changelog
Files
Switch To
- loading...
Options
- Lightweight changelog
- Search
Pull Requests

Changeset - r517:2b6d5d22bb23

« 499:b1ef32
« 495:dab9e6

518:8668e1 »

r517:2b6d5d22bb23

Fri, 20 Feb 2009 22:37:19

[Not Reviewed]

0 comments (0 inline)

alpar (Alpar Juttner)
alpar@cs.elte.hu

Merge

0 12 0

merge default

11 files changed with 255 insertions and 403 deletions:

.hgignore

CMakeLists.txt

configure.ac

lemon/bits/default_map.h

lemon/bits/windows.cc

lemon/config.h.cmake

lemon/config.h.in

lemon/lgf_reader.h

lemon/lgf_writer.h

lemon/path.h

lemon/random.h

lemon/tolerance.h

219

↑ Collapse diff ↑

0 comments (0 inline)

@@ -19,12 +19,13 @@
 		libtool
 		stamp-h1
 		lemon/lemon.pc
 		lemon/libemon.la
 		lemon/stamp-h2
 		doc/Doxyfile
 		cmake/cmake.version
 		.dirstamp
 		.libs/*
 		.deps/*
 		demo/*.eps
 		m4/libtool.m4
 		m4/ltoptions.m4

@@ -29,12 +29,15 @@
 		IF(GLPK_FOUND)
 		  SET(HAVE_LP TRUE)
 		  SET(HAVE_MIP TRUE)
 		  SET(HAVE_GLPK TRUE)
 		ENDIF(GLPK_FOUND)
 		INCLUDE(CheckTypeSize)
 		CHECK_TYPE_SIZE("long long" LONG_LONG)
 		ENABLE_TESTING()
 		ADD_SUBDIRECTORY(lemon)
 		ADD_SUBDIRECTORY(demo)
 		ADD_SUBDIRECTORY(doc)
 		ADD_SUBDIRECTORY(test)

@@ -19,12 +19,18 @@
 		AC_CONFIG_SRCDIR([lemon/list_graph.h])
 		AC_CONFIG_HEADERS([config.h lemon/config.h])
 		dnl Do compilation tests using the C++ compiler.
 		AC_LANG([C++])
 		dnl Check the existence of long long type.
 		AC_CHECK_TYPE(long long, [long_long_found=yes], [long_long_found=no])
 		if test x"$long_long_found" = x"yes"; then
 		  AC_DEFINE([HAVE_LONG_LONG], [1], [Define to 1 if you have long long.])
 		fi
 		dnl Checks for programs.
 		AC_PROG_CXX
 		AC_PROG_CXXCPP
 		AC_PROG_INSTALL
 		AC_DISABLE_SHARED
 		AC_PROG_LIBTOOL
@@ -116,12 +122,14 @@
 		echo
 		echo Package version............... : $PACKAGE-$VERSION
 		echo
 		echo C++ compiler.................. : $CXX
 		echo C++ compiles flags............ : $WARNINGCXXFLAGS $CXXFLAGS
 		echo
 		echo Compiler supports long long... : $long_long_found
 		echo
 		echo GLPK support.................. : $lx_glpk_found
 		echo CPLEX support................. : $lx_cplex_found
 		echo SOPLEX support................ : $lx_soplex_found
 		echo CLP support................... : $lx_clp_found
 		echo
 		echo Build demo programs........... : $enable_demo

@@ -93,13 +93,13 @@
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, unsigned long> {
 		    typedef VectorMap<_Graph, _Item, unsigned long> Map;
 		  };
-		#if defined __GNUC__ && !defined __STRICT_ANSI__
+		#if defined HAVE_LONG_LONG
 		  // long long
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, signed long long> {
 		    typedef VectorMap<_Graph, _Item, signed long long> Map;
 		  };

@@ -25,13 +25,21 @@
 		#ifndef WIN32_LEAN_AND_MEAN
 		#define WIN32_LEAN_AND_MEAN
 		#endif
 		#ifndef NOMINMAX
 		#define NOMINMAX
 		#endif
 		#ifdef UNICODE
 		#undef UNICODE
 		#endif
 		#include <windows.h>
 		#ifdef LOCALE_INVARIANT
 		#define MY_LOCALE LOCALE_INVARIANT
 		#else
 		#define MY_LOCALE LOCALE_NEUTRAL
 		#endif
 		#else
 		#include <unistd.h>
 		#include <ctime>
 		#include <sys/times.h>
 		#include <sys/time.h>
 		#endif
@@ -84,33 +92,21 @@
 		    std::string getWinFormattedDate()
+		    {
 		      std::ostringstream os;
 		#ifdef WIN32
 		      SYSTEMTIME time;
 		      GetSystemTime(&time);
 		#if defined(_MSC_VER) && (_MSC_VER < 1500)
 		      LPWSTR buf1, buf2, buf3;
 		      if (GetDateFormat(LOCALE_USER_DEFAULT, 0, &time,
 		                        L"ddd MMM dd", buf1, 11) &&
 		          GetTimeFormat(LOCALE_USER_DEFAULT, 0, &time,
 		                        L"HH':'mm':'ss", buf2, 9) &&
 		          GetDateFormat(LOCALE_USER_DEFAULT, 0, &time,
 		                        L"yyyy", buf3, 5)) {
 		      char buf1[11], buf2[9], buf3[5];
 			  if (GetDateFormat(MY_LOCALE, 0, &time,
 		                        ("ddd MMM dd"), buf1, 11) &&
 		          GetTimeFormat(MY_LOCALE, 0, &time,
 		                        ("HH':'mm':'ss"), buf2, 9) &&
 		          GetDateFormat(MY_LOCALE, 0, &time,
 		                        ("yyyy"), buf3, 5)) {
 		        os << buf1 << ' ' << buf2 << ' ' << buf3;
+		      }
 		#else
 		      char buf1[11], buf2[9], buf3[5];
 		      if (GetDateFormat(LOCALE_USER_DEFAULT, 0, &time,
 		                        "ddd MMM dd", buf1, 11) &&
 		          GetTimeFormat(LOCALE_USER_DEFAULT, 0, &time,
 		                        "HH':'mm':'ss", buf2, 9) &&
 		          GetDateFormat(LOCALE_USER_DEFAULT, 0, &time,
 		                        "yyyy", buf3, 5)) {
 		        os << buf1 << ' ' << buf2 << ' ' << buf3;
+		      }
 		#endif
 		      else os << "unknown";
 		#else
 		      timeval tv;
 		      gettimeofday(&tv, 0);
 		      char cbuf[26];

RhodeCode

Login to your account

 		#cmakedefine HAVE_LP 1
 		#cmakedefine HAVE_MIP 1
-		#cmakedefine HAVE_GLPK 1
+		#cmakedefine HAVE_LONG_LONG 1
 		#cmakedefine HAVE_LP 1
 		#cmakedefine HAVE_MIP 1
 		#cmakedefine HAVE_GLPK 1

 		/* Define to 1 if you have long long */
 		#undef HAVE_LONG_LONG
 		/* Define to 1 if you have any LP solver. */
 		#undef HAVE_LP
 		/* Define to 1 if you have any MIP solver. */
 		#undef HAVE_MIP

@@ -387,43 +387,19 @@
+		  }
 		  template <typename Digraph>
 		  class DigraphReader;
 		  /// \brief Return a \ref DigraphReader class
 		  ///
 		  /// This function just returns a \ref DigraphReader class.
 		  /// \relates DigraphReader
 		  template <typename Digraph>
 		  DigraphReader<Digraph> digraphReader(Digraph& digraph,
 		                                       std::istream& is = std::cin) {
 		    DigraphReader<Digraph> tmp(digraph, is);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref DigraphReader class
 		  ///
 		  /// This function just returns a \ref DigraphReader class.
 		  /// \relates DigraphReader
 		  DigraphReader<Digraph> digraphReader(Digraph& digraph,
 		                                       std::istream& is = std::cin);
 		  template <typename Digraph>
 		  DigraphReader<Digraph> digraphReader(Digraph& digraph,
 		                                       const std::string& fn) {
 		    DigraphReader<Digraph> tmp(digraph, fn);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref DigraphReader class
 		  ///
 		  /// This function just returns a \ref DigraphReader class.
 		  /// \relates DigraphReader
 		  DigraphReader<Digraph> digraphReader(Digraph& digraph, const std::string& fn);
 		  template <typename Digraph>
 		  DigraphReader<Digraph> digraphReader(Digraph& digraph, const char* fn) {
 		    DigraphReader<Digraph> tmp(digraph, fn);
 		    return tmp;
+		  }
 		  DigraphReader<Digraph> digraphReader(Digraph& digraph, const char *fn);
 		  /// \ingroup lemon_io
 		  ///
 		  /// \brief \ref lgf-format "LGF" reader for directed graphs
 		  ///
 		  /// This utility reads an \ref lgf-format "LGF" file.
@@ -581,18 +557,19 @@
+		      }
+		    }
 		  private:
 		    friend DigraphReader<Digraph> digraphReader<>(Digraph& digraph,
 		                                                  std::istream& is);
 		    friend DigraphReader<Digraph> digraphReader<>(Digraph& digraph,
 		                                                  const std::string& fn);
 		    friend DigraphReader<Digraph> digraphReader<>(Digraph& digraph,
 		                                                  const char *fn);
 		    template <typename DGR>
 		    friend DigraphReader<DGR> digraphReader(DGR& digraph, std::istream& is);
 		    template <typename DGR>
 		    friend DigraphReader<DGR> digraphReader(DGR& digraph,
 		                                            const std::string& fn);
 		    template <typename DGR>
 		    friend DigraphReader<DGR> digraphReader(DGR& digraph, const char *fn);
 		    DigraphReader(DigraphReader& other)
 		      : _is(other._is), local_is(other.local_is), _digraph(other._digraph),
 		        _use_nodes(other._use_nodes), _use_arcs(other._use_arcs),
 		        _skip_nodes(other._skip_nodes), _skip_arcs(other._skip_arcs) {
@@ -1209,44 +1186,53 @@
+		    }
 		    /// @}
 		  };
 		  /// \brief Return a \ref DigraphReader class
 		  ///
 		  /// This function just returns a \ref DigraphReader class.
 		  /// \relates DigraphReader
 		  template <typename Digraph>
 		  DigraphReader<Digraph> digraphReader(Digraph& digraph, std::istream& is) {
 		    DigraphReader<Digraph> tmp(digraph, is);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref DigraphReader class
 		  ///
 		  /// This function just returns a \ref DigraphReader class.
 		  /// \relates DigraphReader
 		  template <typename Digraph>
 		  DigraphReader<Digraph> digraphReader(Digraph& digraph,
 		                                       const std::string& fn) {
 		    DigraphReader<Digraph> tmp(digraph, fn);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref DigraphReader class
 		  ///
 		  /// This function just returns a \ref DigraphReader class.
 		  /// \relates DigraphReader
 		  template <typename Digraph>
 		  DigraphReader<Digraph> digraphReader(Digraph& digraph, const char* fn) {
 		    DigraphReader<Digraph> tmp(digraph, fn);
 		    return tmp;
+		  }
 		  template <typename Graph>
 		  class GraphReader;
 		  /// \brief Return a \ref GraphReader class
 		  ///
 		  /// This function just returns a \ref GraphReader class.
-		  /// \relates GraphReader
 		  template <typename Graph>
 		  GraphReader<Graph> graphReader(Graph& graph, std::istream& is = std::cin) {
 		    GraphReader<Graph> tmp(graph, is);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref GraphReader class
 		  ///
 		  /// This function just returns a \ref GraphReader class.
-		  /// \relates GraphReader
+		  GraphReader<Graph> graphReader(Graph& graph,
 		                                 std::istream& is = std::cin);
 		  template <typename Graph>
 		  GraphReader<Graph> graphReader(Graph& graph, const std::string& fn) {
 		    GraphReader<Graph> tmp(graph, fn);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref GraphReader class
 		  ///
 		  /// This function just returns a \ref GraphReader class.
-		  /// \relates GraphReader
+		  GraphReader<Graph> graphReader(Graph& graph, const std::string& fn);
 		  template <typename Graph>
 		  GraphReader<Graph> graphReader(Graph& graph, const char* fn) {
 		    GraphReader<Graph> tmp(graph, fn);
 		    return tmp;
+		  }
 		  GraphReader<Graph> graphReader(Graph& graph, const char *fn);
 		  /// \ingroup lemon_io
 		  ///
 		  /// \brief \ref lgf-format "LGF" reader for undirected graphs
 		  ///
 		  /// This utility reads an \ref lgf-format "LGF" file.
@@ -1367,16 +1353,18 @@
 		        delete _is;
+		      }
+		    }
 		  private:
 		    friend GraphReader<Graph> graphReader<>(Graph& graph, std::istream& is);
 		    friend GraphReader<Graph> graphReader<>(Graph& graph,
 		                                            const std::string& fn);
 		    friend GraphReader<Graph> graphReader<>(Graph& graph, const char *fn);
 		    template <typename GR>
 		    friend GraphReader<GR> graphReader(GR& graph, std::istream& is);
 		    template <typename GR>
 		    friend GraphReader<GR> graphReader(GR& graph, const std::string& fn);
 		    template <typename GR>
 		    friend GraphReader<GR> graphReader(GR& graph, const char *fn);
 		    GraphReader(GraphReader& other)
 		      : _is(other._is), local_is(other.local_is), _graph(other._graph),
 		        _use_nodes(other._use_nodes), _use_edges(other._use_edges),
 		        _skip_nodes(other._skip_nodes), _skip_edges(other._skip_edges) {
@@ -2041,12 +2029,42 @@
+		    }
 		    /// @}
 		  };
 		  /// \brief Return a \ref GraphReader class
 		  ///
 		  /// This function just returns a \ref GraphReader class.
 		  /// \relates GraphReader
 		  template <typename Graph>
 		  GraphReader<Graph> graphReader(Graph& graph, std::istream& is) {
 		    GraphReader<Graph> tmp(graph, is);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref GraphReader class
 		  ///
 		  /// This function just returns a \ref GraphReader class.
 		  /// \relates GraphReader
 		  template <typename Graph>
 		  GraphReader<Graph> graphReader(Graph& graph, const std::string& fn) {
 		    GraphReader<Graph> tmp(graph, fn);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref GraphReader class
 		  ///
 		  /// This function just returns a \ref GraphReader class.
 		  /// \relates GraphReader
 		  template <typename Graph>
 		  GraphReader<Graph> graphReader(Graph& graph, const char* fn) {
 		    GraphReader<Graph> tmp(graph, fn);
 		    return tmp;
+		  }
 		  class SectionReader;
 		  SectionReader sectionReader(std::istream& is);
 		  SectionReader sectionReader(const std::string& fn);
 		  SectionReader sectionReader(const char* fn);

@@ -347,44 +347,23 @@
+		  }
 		  template <typename Digraph>
 		  class DigraphWriter;
 		  /// \brief Return a \ref DigraphWriter class
 		  ///
 		  /// This function just returns a \ref DigraphWriter class.
 		  /// \relates DigraphWriter
 		  template <typename Digraph>
 		  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
 		                                       std::ostream& os = std::cout) {
 		    DigraphWriter<Digraph> tmp(digraph, os);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref DigraphWriter class
 		  ///
 		  /// This function just returns a \ref DigraphWriter class.
-		  /// \relates DigraphWriter
+		                                       std::ostream& os = std::cout);
 		  template <typename Digraph>
 		  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
 		                                       const std::string& fn) {
 		    DigraphWriter<Digraph> tmp(digraph, fn);
 		    return tmp;
+		  }
 		                                       const std::string& fn);
 		  /// \brief Return a \ref DigraphWriter class
 		  ///
 		  /// This function just returns a \ref DigraphWriter class.
 		  /// \relates DigraphWriter
 		  template <typename Digraph>
 		  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
 		                                       const char* fn) {
 		    DigraphWriter<Digraph> tmp(digraph, fn);
 		    return tmp;
+		  }
 		                                       const char* fn);
 		  /// \ingroup lemon_io
 		  ///
 		  /// \brief \ref lgf-format "LGF" writer for directed graphs
 		  ///
 		  /// This utility writes an \ref lgf-format "LGF" file.
@@ -523,18 +502,21 @@
 		        delete _os;
+		      }
+		    }
 		  private:
 		    friend DigraphWriter<Digraph> digraphWriter<>(const Digraph& digraph,
 		                                                  std::ostream& os);
 		    friend DigraphWriter<Digraph> digraphWriter<>(const Digraph& digraph,
 		                                                  const std::string& fn);
 		    friend DigraphWriter<Digraph> digraphWriter<>(const Digraph& digraph,
 		                                                  const char *fn);
 		    template <typename DGR>
 		    friend DigraphWriter<DGR> digraphWriter(const DGR& digraph,
 		                                            std::ostream& os);
 		    template <typename DGR>
 		    friend DigraphWriter<DGR> digraphWriter(const DGR& digraph,
 		                                            const std::string& fn);
 		    template <typename DGR>
 		    friend DigraphWriter<DGR> digraphWriter(const DGR& digraph,
 		                                            const char *fn);
 		    DigraphWriter(DigraphWriter& other)
 		      : _os(other._os), local_os(other.local_os), _digraph(other._digraph),
 		        _skip_nodes(other._skip_nodes), _skip_arcs(other._skip_arcs) {
 		      other._os = 0;
@@ -930,45 +912,55 @@
 		      return *_os;
+		    }
 		    /// @}
 		  };
 		  /// \brief Return a \ref DigraphWriter class
 		  ///
 		  /// This function just returns a \ref DigraphWriter class.
 		  /// \relates DigraphWriter
 		  template <typename Digraph>
 		  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
 		                                       std::ostream& os) {
 		    DigraphWriter<Digraph> tmp(digraph, os);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref DigraphWriter class
 		  ///
 		  /// This function just returns a \ref DigraphWriter class.
 		  /// \relates DigraphWriter
 		  template <typename Digraph>
 		  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
 		                                       const std::string& fn) {
 		    DigraphWriter<Digraph> tmp(digraph, fn);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref DigraphWriter class
 		  ///
 		  /// This function just returns a \ref DigraphWriter class.
 		  /// \relates DigraphWriter
 		  template <typename Digraph>
 		  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
 		                                       const char* fn) {
 		    DigraphWriter<Digraph> tmp(digraph, fn);
 		    return tmp;
+		  }
 		  template <typename Graph>
 		  class GraphWriter;
 		  /// \brief Return a \ref GraphWriter class
 		  ///
 		  /// This function just returns a \ref GraphWriter class.
 		  /// \relates GraphWriter
 		  template <typename Graph>
 		  GraphWriter<Graph> graphWriter(const Graph& graph,
 		                                 std::ostream& os = std::cout) {
 		    GraphWriter<Graph> tmp(graph, os);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref GraphWriter class
 		  ///
 		  /// This function just returns a \ref GraphWriter class.
-		  /// \relates GraphWriter
+		                                 std::ostream& os = std::cout);
 		  template <typename Graph>
 		  GraphWriter<Graph> graphWriter(const Graph& graph, const std::string& fn) {
 		    GraphWriter<Graph> tmp(graph, fn);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref GraphWriter class
 		  ///
 		  /// This function just returns a \ref GraphWriter class.
-		  /// \relates GraphWriter
+		  GraphWriter<Graph> graphWriter(const Graph& graph, const std::string& fn);
 		  template <typename Graph>
 		  GraphWriter<Graph> graphWriter(const Graph& graph, const char* fn) {
 		    GraphWriter<Graph> tmp(graph, fn);
 		    return tmp;
+		  }
 		  GraphWriter<Graph> graphWriter(const Graph& graph, const char* fn);
 		  /// \ingroup lemon_io
 		  ///
 		  /// \brief \ref lgf-format "LGF" writer for directed graphs
 		  ///
 		  /// This utility writes an \ref lgf-format "LGF" file.
@@ -1078,19 +1070,22 @@
 		        delete _os;
+		      }
+		    }
 		  private:
 		    friend GraphWriter<Graph> graphWriter<>(const Graph& graph,
 		                                            std::ostream& os);
 		    friend GraphWriter<Graph> graphWriter<>(const Graph& graph,
 		                                            const std::string& fn);
 		    friend GraphWriter<Graph> graphWriter<>(const Graph& graph,
 		                                            const char *fn);
+		    template <typename GR>
 		    friend GraphWriter<GR> graphWriter(const GR& graph,
 		                                       std::ostream& os);
 		    template <typename GR>
 		    friend GraphWriter<GR> graphWriter(const GR& graph,
 		                                       const std::string& fn);
 		    template <typename GR>
 		    friend GraphWriter<GR> graphWriter(const GR& graph,
 		                                       const char *fn);
 		    GraphWriter(GraphWriter& other)
 		      : _os(other._os), local_os(other.local_os), _graph(other._graph),
 		        _skip_nodes(other._skip_nodes), _skip_edges(other._skip_edges) {
 		      other._os = 0;
 		      other.local_os = false;
@@ -1531,12 +1526,43 @@
 		      return *_os;
+		    }
 		    /// @}
 		  };
 		  /// \brief Return a \ref GraphWriter class
 		  ///
 		  /// This function just returns a \ref GraphWriter class.
 		  /// \relates GraphWriter
 		  template <typename Graph>
 		  GraphWriter<Graph> graphWriter(const Graph& graph,
 		                                 std::ostream& os) {
 		    GraphWriter<Graph> tmp(graph, os);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref GraphWriter class
 		  ///
 		  /// This function just returns a \ref GraphWriter class.
 		  /// \relates GraphWriter
 		  template <typename Graph>
 		  GraphWriter<Graph> graphWriter(const Graph& graph, const std::string& fn) {
 		    GraphWriter<Graph> tmp(graph, fn);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref GraphWriter class
 		  ///
 		  /// This function just returns a \ref GraphWriter class.
 		  /// \relates GraphWriter
 		  template <typename Graph>
 		  GraphWriter<Graph> graphWriter(const Graph& graph, const char* fn) {
 		    GraphWriter<Graph> tmp(graph, fn);
 		    return tmp;
+		  }
 		  class SectionWriter;
 		  SectionWriter sectionWriter(std::istream& is);
 		  SectionWriter sectionWriter(const std::string& fn);
 		  SectionWriter sectionWriter(const char* fn);

@@ -926,49 +926,65 @@
 		      typename enable_if<typename Path::BuildTag, void>::type
 		    > {
 		      static const bool value = true;
 		    };
 		    template <typename Target, typename Source,
 		              bool buildEnable = BuildTagIndicator<Target>::value,
 		              bool revEnable = RevPathTagIndicator<Source>::value>
-		    struct PathCopySelector {
+		              bool buildEnable = BuildTagIndicator<Target>::value>
 		    struct PathCopySelectorForward {
 		      static void copy(Target& target, const Source& source) {
 		        target.clear();
 		        for (typename Source::ArcIt it(source); it != INVALID; ++it) {
 		          target.addBack(it);
+		        }
+		      }
 		    };
 		    template <typename Target, typename Source>
-		    struct PathCopySelector<Target, Source, false, true> {
+		    struct PathCopySelectorForward<Target, Source, true> {
 		      static void copy(Target& target, const Source& source) {
 		        target.clear();
 		        target.build(source);
+		      }
 		    };
 		    template <typename Target, typename Source,
 		              bool buildEnable = BuildTagIndicator<Target>::value>
 		    struct PathCopySelectorBackward {
 		      static void copy(Target& target, const Source& source) {
 		        target.clear();
 		        for (typename Source::RevArcIt it(source); it != INVALID; ++it) {
 		          target.addFront(it);
+		        }
+		      }
 		    };
 		    template <typename Target, typename Source>
 		    struct PathCopySelector<Target, Source, true, false> {
 		      static void copy(Target& target, const Source& source) {
 		        target.clear();
 		        target.build(source);
+		      }
 		    };
 		    template <typename Target, typename Source>
-		    struct PathCopySelector<Target, Source, true, true> {
+		    struct PathCopySelectorBackward<Target, Source, true> {
 		      static void copy(Target& target, const Source& source) {
 		        target.clear();
 		        target.buildRev(source);
+		      }
 		    };
 		    template <typename Target, typename Source,
 		              bool revEnable = RevPathTagIndicator<Source>::value>
 		    struct PathCopySelector {
 		      static void copy(Target& target, const Source& source) {
 		        PathCopySelectorForward<Target, Source>::copy(target, source);
+		      }
 		    };
 		    template <typename Target, typename Source>
 		    struct PathCopySelector<Target, Source, true> {
 		      static void copy(Target& target, const Source& source) {
 		        PathCopySelectorBackward<Target, Source>::copy(target, source);
+		      }
 		    };
+		  }
 		  /// \brief Make a copy of a path.
 		  ///
 		  ///  This function makes a copy of a path.

@@ -341,62 +341,52 @@
 		          num = rnd() & mask;
 		        } while (num > max);
 		        return num;
+		      }
 		    };
-		    template <typename Result, int exp, bool pos = (exp >= 0)>
 		    template <typename Result, int exp>
 		    struct ShiftMultiplier {
 		      static const Result multiplier() {
 		        Result res = ShiftMultiplier<Result, exp / 2>::multiplier();
 		        res *= res;
 		        if ((exp & 1) == 1) res *= static_cast<Result>(2.0);
 		        return res;
+		      }
 		    };
 		    template <typename Result, int exp>
 		    struct ShiftMultiplier<Result, exp, false> {
 		      static const Result multiplier() {
 		        Result res = ShiftMultiplier<Result, exp / 2>::multiplier();
 		        res *= res;
 		        if ((exp & 1) == 1) res *= static_cast<Result>(0.5);
 		        return res;
+		      }
 		    };
 		    template <typename Result>
-		    struct ShiftMultiplier<Result, 0, true> {
 		    struct ShiftMultiplier<Result, 0> {
 		      static const Result multiplier() {
 		        return static_cast<Result>(1.0);
+		      }
 		    };
 		    template <typename Result>
-		    struct ShiftMultiplier<Result, -20, true> {
 		    struct ShiftMultiplier<Result, 20> {
 		      static const Result multiplier() {
 		        return static_cast<Result>(1.0/1048576.0);
+		      }
 		    };
 		    template <typename Result>
-		    struct ShiftMultiplier<Result, -32, true> {
 		    struct ShiftMultiplier<Result, 32> {
 		      static const Result multiplier() {
-		        return static_cast<Result>(1.0/424967296.0);
+		        return static_cast<Result>(1.0/4294967296.0);
+		      }
 		    };
 		    template <typename Result>
-		    struct ShiftMultiplier<Result, -53, true> {
 		    struct ShiftMultiplier<Result, 53> {
 		      static const Result multiplier() {
 		        return static_cast<Result>(1.0/9007199254740992.0);
+		      }
 		    };
 		    template <typename Result>
-		    struct ShiftMultiplier<Result, -64, true> {
 		    struct ShiftMultiplier<Result, 64> {
 		      static const Result multiplier() {
 		        return static_cast<Result>(1.0/18446744073709551616.0);
+		      }
 		    };
 		    template <typename Result, int exp>
@@ -410,23 +400,23 @@
 		              int rest = std::numeric_limits<Result>::digits, int shift = 0,
 		              bool last = rest <= std::numeric_limits<Word>::digits>
 		    struct RealConversion{
 		      static const int bits = std::numeric_limits<Word>::digits;
 		      static Result convert(RandomCore<Word>& rnd) {
-		        return Shifting<Result, - shift - rest>::
+		        return Shifting<Result, shift + rest>::
 		          shift(static_cast<Result>(rnd() >> (bits - rest)));
+		      }
 		    };
 		    template <typename Result, typename Word, int rest, int shift>
 		    struct RealConversion<Result, Word, rest, shift, false> {
 		      static const int bits = std::numeric_limits<Word>::digits;
 		      static Result convert(RandomCore<Word>& rnd) {
-		        return Shifting<Result, - shift - bits>::
+		        return Shifting<Result, shift + bits>::
 		          shift(static_cast<Result>(rnd())) +
 		          RealConversion<Result, Word, rest-bits, shift + bits>::
 		          convert(rnd);
+		      }
 		    };

@@ -35,23 +35,20 @@
 		  ///as a result of a probably inexact computation.
 		  ///
 		  ///\ref Tolerance is a class to provide a basic way to
 		  ///handle the comparison of numbers that are obtained
 		  ///as a result of a probably inexact computation.
 		  ///
 		  ///This is an abstract class, it should be specialized for all
 		  ///numerical data types. These specialized classes like
 		  ///The general implementation is suitable only if the data type is exact,
 		  ///like the integer types, otherwise a specialized version must be
 		  ///implemented. These specialized classes like
 		  ///Tolerance<double> may offer additional tuning parameters.
 		  ///
 		  ///\sa Tolerance<float>
 		  ///\sa Tolerance<double>
 		  ///\sa Tolerance<long double>
 		  ///\sa Tolerance<int>
 		  ///\sa Tolerance<long long int>
 		  ///\sa Tolerance<unsigned int>
 		  ///\sa Tolerance<unsigned long long int>
 		  template<class T>
 		  class Tolerance
+		  {
 		  public:
 		    typedef T Value;
@@ -61,26 +58,26 @@
 		    ///the related comparisons hold even if some numerical error appeared
 		    ///during the computations.
 		    ///@{
 		    ///Returns \c true if \c a is \e surely strictly less than \c b
-		    static bool less(Value a,Value b) {return false;}
+		    static bool less(Value a,Value b) {return a<b;}
 		    ///Returns \c true if \c a is \e surely different from \c b
-		    static bool different(Value a,Value b) {return false;}
+		    static bool different(Value a,Value b) {return a!=b;}
 		    ///Returns \c true if \c a is \e surely positive
-		    static bool positive(Value a) {return false;}
+		    static bool positive(Value a) {return static_cast<Value>(0) < a;}
 		    ///Returns \c true if \c a is \e surely negative
-		    static bool negative(Value a) {return false;}
+		    static bool negative(Value a) {return a < static_cast<Value>(0);}
 		    ///Returns \c true if \c a is \e surely non-zero
-		    static bool nonZero(Value a) {return false;}
+		    static bool nonZero(Value a) {return a != static_cast<Value>(0);}
 		    ///@}
 		    ///Returns the zero value.
-		    static Value zero() {return T();}
+		    static Value zero() {return static_cast<Value>(0);}
 		    //   static bool finite(Value a) {}
 		    //   static Value big() {}
 		    //   static Value negativeBig() {}
 		  };
@@ -235,218 +232,11 @@
 		    ///@}
 		    ///Returns zero
 		    static Value zero() {return 0;}
 		  };
 		  ///Integer specialization of Tolerance.
 		  ///Integer specialization of Tolerance.
 		  ///\sa Tolerance
 		  template<>
 		  class Tolerance<int>
+		  {
 		  public:
 		    ///\e
 		    typedef int Value;
 		    ///\name Comparisons
 		    ///See \ref lemon::Tolerance "Tolerance" for more details.
 		    ///@{
 		    ///Returns \c true if \c a is \e surely strictly less than \c b
 		    static bool less(Value a,Value b) { return a<b;}
 		    ///Returns \c true if \c a is \e surely different from \c b
 		    static bool different(Value a,Value b) { return a!=b; }
 		    ///Returns \c true if \c a is \e surely positive
 		    static bool positive(Value a) { return 0<a; }
 		    ///Returns \c true if \c a is \e surely negative
 		    static bool negative(Value a) { return 0>a; }
 		    ///Returns \c true if \c a is \e surely non-zero
 		    static bool nonZero(Value a) { return a!=0; }
 		    ///@}
 		    ///Returns zero
 		    static Value zero() {return 0;}
 		  };
 		  ///Unsigned integer specialization of Tolerance.
 		  ///Unsigned integer specialization of Tolerance.
 		  ///\sa Tolerance
 		  template<>
 		  class Tolerance<unsigned int>
+		  {
 		  public:
 		    ///\e
 		    typedef unsigned int Value;
 		    ///\name Comparisons
 		    ///See \ref lemon::Tolerance "Tolerance" for more details.
 		    ///@{
 		    ///Returns \c true if \c a is \e surely strictly less than \c b
 		    static bool less(Value a,Value b) { return a<b;}
 		    ///Returns \c true if \c a is \e surely different from \c b
 		    static bool different(Value a,Value b) { return a!=b; }
 		    ///Returns \c true if \c a is \e surely positive
 		    static bool positive(Value a) { return 0<a; }
 		    ///Returns \c true if \c a is \e surely negative
 		    static bool negative(Value) { return false; }
 		    ///Returns \c true if \c a is \e surely non-zero
 		    static bool nonZero(Value a) { return a!=0; }
 		    ///@}
 		    ///Returns zero
 		    static Value zero() {return 0;}
 		  };
 		  ///Long integer specialization of Tolerance.
 		  ///Long integer specialization of Tolerance.
 		  ///\sa Tolerance
 		  template<>
 		  class Tolerance<long int>
+		  {
 		  public:
 		    ///\e
 		    typedef long int Value;
 		    ///\name Comparisons
 		    ///See \ref lemon::Tolerance "Tolerance" for more details.
 		    ///@{
 		    ///Returns \c true if \c a is \e surely strictly less than \c b
 		    static bool less(Value a,Value b) { return a<b;}
 		    ///Returns \c true if \c a is \e surely different from \c b
 		    static bool different(Value a,Value b) { return a!=b; }
 		    ///Returns \c true if \c a is \e surely positive
 		    static bool positive(Value a) { return 0<a; }
 		    ///Returns \c true if \c a is \e surely negative
 		    static bool negative(Value a) { return 0>a; }
 		    ///Returns \c true if \c a is \e surely non-zero
 		    static bool nonZero(Value a) { return a!=0;}
 		    ///@}
 		    ///Returns zero
 		    static Value zero() {return 0;}
 		  };
 		  ///Unsigned long integer specialization of Tolerance.
 		  ///Unsigned long integer specialization of Tolerance.
 		  ///\sa Tolerance
 		  template<>
 		  class Tolerance<unsigned long int>
+		  {
 		  public:
 		    ///\e
 		    typedef unsigned long int Value;
 		    ///\name Comparisons
 		    ///See \ref lemon::Tolerance "Tolerance" for more details.
 		    ///@{
 		    ///Returns \c true if \c a is \e surely strictly less than \c b
 		    static bool less(Value a,Value b) { return a<b;}
 		    ///Returns \c true if \c a is \e surely different from \c b
 		    static bool different(Value a,Value b) { return a!=b; }
 		    ///Returns \c true if \c a is \e surely positive
 		    static bool positive(Value a) { return 0<a; }
 		    ///Returns \c true if \c a is \e surely negative
 		    static bool negative(Value) { return false; }
 		    ///Returns \c true if \c a is \e surely non-zero
 		    static bool nonZero(Value a) { return a!=0;}
 		    ///@}
 		    ///Returns zero
 		    static Value zero() {return 0;}
 		  };
 		#if defined __GNUC__ && !defined __STRICT_ANSI__
 		  ///Long long integer specialization of Tolerance.
 		  ///Long long integer specialization of Tolerance.
 		  ///\warning This class (more exactly, type <tt>long long</tt>)
 		  ///is not ansi compatible.
 		  ///\sa Tolerance
 		  template<>
 		  class Tolerance<long long int>
+		  {
 		  public:
 		    ///\e
 		    typedef long long int Value;
 		    ///\name Comparisons
 		    ///See \ref lemon::Tolerance "Tolerance" for more details.
 		    ///@{
 		    ///Returns \c true if \c a is \e surely strictly less than \c b
 		    static bool less(Value a,Value b) { return a<b;}
 		    ///Returns \c true if \c a is \e surely different from \c b
 		    static bool different(Value a,Value b) { return a!=b; }
 		    ///Returns \c true if \c a is \e surely positive
 		    static bool positive(Value a) { return 0<a; }
 		    ///Returns \c true if \c a is \e surely negative
 		    static bool negative(Value a) { return 0>a; }
 		    ///Returns \c true if \c a is \e surely non-zero
 		    static bool nonZero(Value a) { return a!=0;}
 		    ///@}
 		    ///Returns zero
 		    static Value zero() {return 0;}
 		  };
 		  ///Unsigned long long integer specialization of Tolerance.
 		  ///Unsigned long long integer specialization of Tolerance.
 		  ///\warning This class (more exactly, type <tt>unsigned long long</tt>)
 		  ///is not ansi compatible.
 		  ///\sa Tolerance
 		  template<>
 		  class Tolerance<unsigned long long int>
+		  {
 		  public:
 		    ///\e
 		    typedef unsigned long long int Value;
 		    ///\name Comparisons
 		    ///See \ref lemon::Tolerance "Tolerance" for more details.
 		    ///@{
 		    ///Returns \c true if \c a is \e surely strictly less than \c b
 		    static bool less(Value a,Value b) { return a<b;}
 		    ///Returns \c true if \c a is \e surely different from \c b
 		    static bool different(Value a,Value b) { return a!=b; }
 		    ///Returns \c true if \c a is \e surely positive
 		    static bool positive(Value a) { return 0<a; }
 		    ///Returns \c true if \c a is \e surely negative
 		    static bool negative(Value) { return false; }
 		    ///Returns \c true if \c a is \e surely non-zero
 		    static bool nonZero(Value a) { return a!=0;}
 		    ///@}
 		    ///Returns zero
 		    static Value zero() {return 0;}
 		  };
 		#endif
 		  /// @}
 		} //namespace lemon
 		#endif //LEMON_TOLERANCE_H