# HG changeset patch
# User alpar
# Date 1155221796 0
# Node ID 3aa8ee4853dcdb10df14788aa9c62eb2f743f8f5
# Parent  0048a1aa96f96d57be3f37c1f783a5c86972d9ce
Some clean files added.

diff -r 0048a1aa96f9 -r 3aa8ee4853dc doc/namespaces.dox
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/doc/namespaces.dox	Thu Aug 10 14:56:36 2006 +0000
@@ -0,0 +1,12 @@
+/// The namespace of LEMON
+
+/// The namespace of LEMON
+///
+namespace lemon {
+
+  /// The namespace of LEMON concepts and concept checking classes
+
+  /// The namespace of LEMON concepts and concept checking classes
+  ///
+  namespace concept {}
+}
diff -r 0048a1aa96f9 -r 3aa8ee4853dc lemon/Makefile.am
--- a/lemon/Makefile.am	Wed Jul 19 13:08:10 2006 +0000
+++ b/lemon/Makefile.am	Thu Aug 10 14:56:36 2006 +0000
@@ -6,10 +6,11 @@
 
 lib_LTLIBRARIES += lemon/libemon.la
 
-lemon_libemon_la_SOURCES =
+lemon_libemon_la_SOURCES = \
 ##	lemon/lp_base.cc \
 ##	lemon/lp_skeleton.cc \
-##	lemon/base.cc \
+	lemon/base.cc \
+	lemon/color.cc
 ##	lemon/eps.cc \
 ##	lemon/bits/mingw32_rand.cc \
 ##	lemon/bits/mingw32_time.cc
@@ -25,7 +26,7 @@
 ##lemon_libemon_la_SOURCES += lemon/lp_cplex.cc
 endif
 
-lemon_HEADERS +=
+lemon_HEADERS += \
 ##	lemon/bellman_ford.h \
 ##	lemon/bezier.h \
 ##	lemon/bfs.h \
@@ -33,7 +34,7 @@
 ##	lemon/bipartite_matching.h \
 ##	lemon/bpugraph_adaptor.h \
 ##	lemon/bucket_heap.h \
-##	lemon/color.h \
+	lemon/color.h \
 ##	lemon/config.h \
 ##	lemon/counter.h \
 ##	lemon/dag_shortest_path.h \
@@ -86,7 +87,7 @@
 ##	lemon/suurballe.h \
 ##	lemon/tabu_search.h \
 ##	lemon/time_measure.h \
-##	lemon/tolerance.h \
+	lemon/tolerance.h
 ##	lemon/topology.h \
 ##	lemon/ugraph_adaptor.h \
 ##	lemon/unionfind.h \
@@ -100,7 +101,7 @@
 ##	lemon/bits/edge_set_extender.h \
 ##	lemon/bits/graph_adaptor_extender.h \
 ##	lemon/bits/graph_extender.h \
-##	lemon/bits/invalid.h \
+	lemon/bits/invalid.h
 ##	lemon/bits/item_reader.h \
 ##	lemon/bits/item_writer.h \
 ##	lemon/bits/map_extender.h \
diff -r 0048a1aa96f9 -r 3aa8ee4853dc lemon/base.cc
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/lemon/base.cc	Thu Aug 10 14:56:36 2006 +0000
@@ -0,0 +1,34 @@
+/* -*- C++ -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library
+ *
+ * Copyright (C) 2003-2006
+ * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
+ * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ *
+ * Permission to use, modify and distribute this software is granted
+ * provided that this copyright notice appears in all copies. For
+ * precise terms see the accompanying LICENSE file.
+ *
+ * This software is provided "AS IS" with no warranty of any kind,
+ * express or implied, and with no claim as to its suitability for any
+ * purpose.
+ *
+ */
+
+///\file
+///\brief Some basic non inline function and static global data.
+
+#include<lemon/tolerance.h>
+#include<lemon/bits/invalid.h>
+namespace lemon {
+
+  float Tolerance<float>::def_epsilon = 1e-4;
+  double Tolerance<double>::def_epsilon = 1e-10;
+  long double Tolerance<long double>::def_epsilon = 1e-14;
+
+#ifndef LEMON_ONLY_TEMPLATES
+  const Invalid INVALID = Invalid();
+#endif
+
+} //namespace lemon
diff -r 0048a1aa96f9 -r 3aa8ee4853dc lemon/bits/invalid.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/lemon/bits/invalid.h	Thu Aug 10 14:56:36 2006 +0000
@@ -0,0 +1,54 @@
+/* -*- C++ -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library
+ *
+ * Copyright (C) 2003-2006
+ * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
+ * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ *
+ * Permission to use, modify and distribute this software is granted
+ * provided that this copyright notice appears in all copies. For
+ * precise terms see the accompanying LICENSE file.
+ *
+ * This software is provided "AS IS" with no warranty of any kind,
+ * express or implied, and with no claim as to its suitability for any
+ * purpose.
+ *
+ */
+
+#ifndef LEMON_BITS_INVALID_H
+#define LEMON_BITS_INVALID_H
+
+///\file
+///\brief Definition of INVALID.
+
+namespace lemon {
+
+  /// \brief Dummy type to make it easier to make invalid iterators.
+  ///
+  /// See \ref INVALID for the usage.
+  struct Invalid {
+  public:
+    bool operator==(Invalid) { return true;  }
+    bool operator!=(Invalid) { return false; }
+    bool operator< (Invalid) { return false; }
+  };
+  
+  /// Invalid iterators.
+  
+  /// \ref Invalid is a global type that converts to each iterator
+  /// in such a way that the value of the target iterator will be invalid.
+
+  //Some people didn't like this:
+  //const Invalid &INVALID = *(Invalid *)0;
+
+#ifdef LEMON_ONLY_TEMPLATES
+  const Invalid INVALID = Invalid();
+#else
+  extern const Invalid INVALID;
+#endif
+
+} //namespace lemon
+
+#endif
+  
diff -r 0048a1aa96f9 -r 3aa8ee4853dc lemon/color.cc
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/lemon/color.cc	Thu Aug 10 14:56:36 2006 +0000
@@ -0,0 +1,44 @@
+ /* -*- C++ -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library
+ *
+ * Copyright (C) 2003-2006
+ * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
+ * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ *
+ * Permission to use, modify and distribute this software is granted
+ * provided that this copyright notice appears in all copies. For
+ * precise terms see the accompanying LICENSE file.
+ *
+ * This software is provided "AS IS" with no warranty of any kind,
+ * express or implied, and with no claim as to its suitability for any
+ * purpose.
+ *
+ */
+
+///\file
+///\brief Color constants
+
+#include<lemon/color.h>
+
+namespace lemon {
+
+  const Color WHITE(1,1,1);
+  
+  const Color BLACK(0,0,0);
+  const Color RED(1,0,0);
+  const Color GREEN(0,1,0);
+  const Color BLUE(0,0,1);
+  const Color YELLOW(1,1,0);
+  const Color MAGENTA(1,0,1);
+  const Color CYAN(0,1,1);
+
+  const Color GREY(0,0,0);
+  const Color DARK_RED(.5,0,0);
+  const Color DARK_GREEN(0,.5,0);
+  const Color DARK_BLUE(0,0,.5);
+  const Color DARK_YELLOW(.5,.5,0);
+  const Color DARK_MAGENTA(.5,0,.5);
+  const Color DARK_CYAN(0,.5,.5);
+    
+} //namespace lemon
diff -r 0048a1aa96f9 -r 3aa8ee4853dc lemon/color.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/lemon/color.h	Thu Aug 10 14:56:36 2006 +0000
@@ -0,0 +1,211 @@
+/* -*- C++ -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library
+ *
+ * Copyright (C) 2003-2006
+ * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
+ * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ *
+ * Permission to use, modify and distribute this software is granted
+ * provided that this copyright notice appears in all copies. For
+ * precise terms see the accompanying LICENSE file.
+ *
+ * This software is provided "AS IS" with no warranty of any kind,
+ * express or implied, and with no claim as to its suitability for any
+ * purpose.
+ *
+ */
+
+#ifndef LEMON_COLOR_H
+#define LEMON_COLOR_H
+
+#include <sys/time.h>
+
+#include<iostream>
+#include<fstream>
+#include<sstream>
+#include<algorithm>
+#include<vector>
+
+#include <ctime>
+#include <cmath>
+
+#include<lemon/bits/invalid.h>
+#include<lemon/xy.h>
+#include<lemon/maps.h>
+#include<lemon/bezier.h>
+
+
+///\ingroup misc
+///\file
+///\brief Tools to manage RGB colors.
+///
+///\author Alpar Juttner
+
+namespace lemon {
+
+  /// \addtogroup misc
+  /// @{
+
+///Data structure representing RGB colors.
+
+///Data structure representing RGB colors.
+///\ingroup misc
+class Color
+{
+  double _r,_g,_b;
+public:
+  ///Default constructor
+  Color() {}
+  ///Constructor
+  Color(double r,double g,double b) :_r(r),_g(g),_b(b) {};
+  ///Set the red component
+  double & red() {return _r;}
+  ///Return the red component
+  const double & red() const {return _r;}
+  ///Set the green component
+  double & green() {return _g;}
+  ///Return the green component
+  const double & green() const {return _g;}
+  ///Set the blue component
+  double & blue() {return _b;}
+  ///Return the blue component
+  const double & blue() const {return _b;}
+  ///Set the color components
+  void set(double r,double g,double b) { _r=r;_g=g;_b=b; };
+};
+
+  /// White color constant
+  extern const Color WHITE;  
+  /// Black color constant
+  extern const Color BLACK;
+  /// Red color constant
+  extern const Color RED;
+  /// Green color constant
+  extern const Color GREEN;
+  /// Blue color constant
+  extern const Color BLUE;
+  /// Yellow color constant
+  extern const Color YELLOW;
+  /// Magenta color constant
+  extern const Color MAGENTA;
+  /// Cyan color constant
+  extern const Color CYAN;
+  /// Grey color constant
+  extern const Color GREY;
+  /// Dark red color constant
+  extern const Color DARK_RED;
+  /// Dark green color constant
+  extern const Color DARK_GREEN;
+  /// Drak blue color constant
+  extern const Color DARK_BLUE;
+  /// Dark yellow color constant
+  extern const Color DARK_YELLOW;
+  /// Dark magenta color constant
+  extern const Color DARK_MAGENTA;
+  /// Dark cyan color constant
+  extern const Color DARK_CYAN;
+
+///Maps <tt>int</tt>s to different \ref Color "Color"s
+
+///This map assigns one of the predefined \ref Color "Color"s
+///to each <tt>int</tt>. It is possible to change the colors as well as their
+///number. The integer range is cyclically mapped to the provided set of colors.
+///
+///This is a true \ref concept::ReferenceMap "reference map", so you can also
+///change the actual colors.
+
+class Palette : public MapBase<int,Color>
+{
+  std::vector<Color> colors;
+public:
+  ///Constructor
+
+  ///Constructor
+  ///\param have_white indicates whether white is
+  ///amongst the provided color (\c true) or not (\c false). If it is true,
+  ///white will be assigned to \c 0.
+  ///\param num the number of the allocated colors. If it is \c 0,
+  ///the default color configuration is set up (26 color plus the white).
+  ///If \c num is less then 26/27 then the default color list is cut. Otherwise
+  ///the color list is filled repeatedly with the default color list.
+  ///(The colors can be changed later on.)
+  Palette(bool have_white=false,int num=0)
+  {
+    do {
+      if(have_white) colors.push_back(Color(1,1,1));
+
+      colors.push_back(Color(0,0,0));
+      colors.push_back(Color(1,0,0));
+      colors.push_back(Color(0,1,0));
+      colors.push_back(Color(0,0,1));
+      colors.push_back(Color(1,1,0));
+      colors.push_back(Color(1,0,1));
+      colors.push_back(Color(0,1,1));
+      
+      colors.push_back(Color(.5,0,0));
+      colors.push_back(Color(0,.5,0));
+      colors.push_back(Color(0,0,.5));
+      colors.push_back(Color(.5,.5,0));
+      colors.push_back(Color(.5,0,.5));
+      colors.push_back(Color(0,.5,.5));
+      
+      colors.push_back(Color(.5,.5,.5));
+      colors.push_back(Color(1,.5,.5));
+      colors.push_back(Color(.5,1,.5));
+      colors.push_back(Color(.5,.5,1));
+      colors.push_back(Color(1,1,.5));
+      colors.push_back(Color(1,.5,1));
+      colors.push_back(Color(.5,1,1));
+      
+      colors.push_back(Color(1,.5,0));
+      colors.push_back(Color(.5,1,0));
+      colors.push_back(Color(1,0,.5));
+      colors.push_back(Color(0,1,.5));
+      colors.push_back(Color(0,.5,1));
+      colors.push_back(Color(.5,0,1));
+    } while(int(colors.size())<num);
+    //    colors.push_back(Color(1,1,1));
+    if(num>0) colors.resize(num);
+  }
+  ///\e
+  Color &operator[](int i)
+  {
+    return colors[i%colors.size()];
+  }
+  ///\e
+  const Color &operator[](int i) const
+  {
+    return colors[i%colors.size()];
+  }
+  ///\e
+  void set(int i,const Color &c)
+  {
+    colors[i%colors.size()]=c;
+  }
+  ///Sets the number of the exiting colors.
+  void resize(int s) { colors.resize(s);}
+  ///Returns the number of the existing colors.
+  std::size_t size() const { return colors.size();}
+};
+
+///Returns a visible distinct \ref Color
+
+///Returns a \ref Color which is as different from the given parameter
+///as it is possible.
+inline Color distantColor(const Color &c) 
+{
+  return Color(c.red()<.5?1:0,c.green()<.5?1:0,c.blue()<.5?1:0);
+}
+///Returns black for light colors and white for the dark ones.
+
+///Returns black for light colors and white for the dark ones.
+inline Color distantBW(const Color &c){
+  return (.2125*c.red()+.7154*c.green()+.0721*c.blue())<.5 ? WHITE : BLACK;
+}
+
+/// @}
+
+} //END OF NAMESPACE LEMON
+
+#endif // LEMON_COLOR_H
diff -r 0048a1aa96f9 -r 3aa8ee4853dc lemon/tolerance.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/lemon/tolerance.h	Thu Aug 10 14:56:36 2006 +0000
@@ -0,0 +1,387 @@
+/* -*- C++ -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library
+ *
+ * Copyright (C) 2003-2006
+ * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
+ * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ *
+ * Permission to use, modify and distribute this software is granted
+ * provided that this copyright notice appears in all copies. For
+ * precise terms see the accompanying LICENSE file.
+ *
+ * This software is provided "AS IS" with no warranty of any kind,
+ * express or implied, and with no claim as to its suitability for any
+ * purpose.
+ *
+ */
+
+#ifndef LEMON_TOLERANCE_H
+#define LEMON_TOLERANCE_H
+
+///\ingroup misc
+///\file
+///\brief A basic tool to handle the anomalies of calculation with
+///floating point numbers.
+///
+///\todo It should be in a module like "Basic tools"
+
+
+namespace lemon {
+
+  /// \addtogroup misc
+  /// @{
+  
+  ///\brief A class to provide a basic way to
+  ///handle the comparison of numbers that are obtained
+  ///as a result of a probably inexact computation.
+  ///
+  ///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 \ref 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;
+
+    ///\name Comparisons
+    ///The concept is that these bool functions return with \c true only if
+    ///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;}
+    ///Returns \c true if \c a is \e surely different from \c b
+    static bool different(Value a,Value b) {return false;}
+    ///Returns \c true if \c a is \e surely positive
+    static bool positive(Value a) {return false;}
+    ///Returns \c true if \c a is \e surely negative
+    static bool negative(Value a) {return false;}
+    ///Returns \c true if \c a is \e surely non-zero
+    static bool nonZero(Value a) {return false;}
+
+    ///@}
+
+    ///Returns the zero value.
+    static Value zero() {return T();}
+
+    //   static bool finite(Value a) {}
+    //   static Value big() {}
+    //   static Value negativeBig() {}
+  };
+
+
+  ///Float specialization of \ref Tolerance.
+
+  ///Float specialization of \ref Tolerance.
+  ///\sa Tolerance
+  ///\relates Tolerance
+  template<>
+  class Tolerance<float>
+  {
+    static float def_epsilon;
+    float _epsilon;
+  public:
+    ///\e
+    typedef float Value;
+
+    ///Constructor setting the epsilon tolerance to the default value.
+    Tolerance() : _epsilon(def_epsilon) {}
+    ///Constructor setting the epsilon tolerance.
+    Tolerance(float e) : _epsilon(e) {}
+
+    ///Return the epsilon value.
+    Value epsilon() const {return _epsilon;}
+    ///Set the epsilon value.
+    void epsilon(Value e) {_epsilon=e;}
+
+    ///Return the default epsilon value.
+    static Value defaultEpsilon() {return def_epsilon;}
+    ///Set the default epsilon value.
+    static void defaultEpsilon(Value e) {def_epsilon=e;}
+
+    ///\name Comparisons
+    ///See class Tolerance for more details.
+
+    ///@{
+
+    ///Returns \c true if \c a is \e surely strictly less than \c b
+    bool less(Value a,Value b) const {return a+_epsilon<b;}
+    ///Returns \c true if \c a is \e surely different from \c b
+    bool different(Value a,Value b) const { return less(a,b)||less(b,a); }
+    ///Returns \c true if \c a is \e surely positive
+    bool positive(Value a) const { return _epsilon<a; }
+    ///Returns \c true if \c a is \e surely negative
+    bool negative(Value a) const { return -_epsilon>a; }
+    ///Returns \c true if \c a is \e surely non-zero
+    bool nonZero(Value a) const { return positive(a)||negative(a); };
+
+    ///@}
+
+    ///Returns zero
+    static Value zero() {return 0;}
+  };
+
+  ///Double specialization of \ref Tolerance.
+
+  ///Double specialization of \ref Tolerance.
+  ///\sa Tolerance
+  ///\relates Tolerance
+  template<>
+  class Tolerance<double>
+  {
+    static double def_epsilon;
+    double _epsilon;
+  public:
+    ///\e
+    typedef double Value;
+
+    ///Constructor setting the epsilon tolerance to the default value.
+    Tolerance() : _epsilon(def_epsilon) {}
+    ///Constructor setting the epsilon tolerance.
+    Tolerance(double e) : _epsilon(e) {}
+
+    ///Return the epsilon value.
+    Value epsilon() const {return _epsilon;}
+    ///Set the epsilon value.
+    void epsilon(Value e) {_epsilon=e;}
+
+    ///Return the default epsilon value.
+    static Value defaultEpsilon() {return def_epsilon;}
+    ///Set the default epsilon value.
+    static void defaultEpsilon(Value e) {def_epsilon=e;}
+
+    ///\name Comparisons
+    ///See class Tolerance for more details.
+
+    ///@{
+
+    ///Returns \c true if \c a is \e surely strictly less than \c b
+    bool less(Value a,Value b) const {return a+_epsilon<b;}
+    ///Returns \c true if \c a is \e surely different from \c b
+    bool different(Value a,Value b) const { return less(a,b)||less(b,a); }
+    ///Returns \c true if \c a is \e surely positive
+    bool positive(Value a) const { return _epsilon<a; }
+    ///Returns \c true if \c a is \e surely negative
+    bool negative(Value a) const { return -_epsilon>a; }
+    ///Returns \c true if \c a is \e surely non-zero
+    bool nonZero(Value a) const { return positive(a)||negative(a); };
+
+    ///@}
+
+    ///Returns zero
+    static Value zero() {return 0;}
+  };
+
+  ///Long double specialization of \ref Tolerance.
+
+  ///Long double specialization of \ref Tolerance.
+  ///\sa Tolerance
+  ///\relates Tolerance
+  template<>
+  class Tolerance<long double>
+  {
+    static long double def_epsilon;
+    long double _epsilon;
+  public:
+    ///\e
+    typedef long double Value;
+
+    ///Constructor setting the epsilon tolerance to the default value.
+    Tolerance() : _epsilon(def_epsilon) {}
+    ///Constructor setting the epsilon tolerance.
+    Tolerance(long double e) : _epsilon(e) {}
+
+    ///Return the epsilon value.
+    Value epsilon() const {return _epsilon;}
+    ///Set the epsilon value.
+    void epsilon(Value e) {_epsilon=e;}
+
+    ///Return the default epsilon value.
+    static Value defaultEpsilon() {return def_epsilon;}
+    ///Set the default epsilon value.
+    static void defaultEpsilon(Value e) {def_epsilon=e;}
+
+    ///\name Comparisons
+    ///See class Tolerance for more details.
+
+    ///@{
+
+    ///Returns \c true if \c a is \e surely strictly less than \c b
+    bool less(Value a,Value b) const {return a+_epsilon<b;}
+    ///Returns \c true if \c a is \e surely different from \c b
+    bool different(Value a,Value b) const { return less(a,b)||less(b,a); }
+    ///Returns \c true if \c a is \e surely positive
+    bool positive(Value a) const { return _epsilon<a; }
+    ///Returns \c true if \c a is \e surely negative
+    bool negative(Value a) const { return -_epsilon>a; }
+    ///Returns \c true if \c a is \e surely non-zero
+    bool nonZero(Value a) const { return positive(a)||negative(a); };
+
+    ///@}
+
+    ///Returns zero
+    static Value zero() {return 0;}
+  };
+
+  ///Integer specialization of \ref Tolerance.
+
+  ///Integer specialization of \ref Tolerance.
+  ///\sa Tolerance
+  template<>
+  class Tolerance<int>
+  {
+  public:
+    ///\e
+    typedef int Value;
+
+    ///\name Comparisons
+    ///See \ref 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 \ref Tolerance.
+
+  ///Unsigned integer specialization of \ref Tolerance.
+  ///\sa Tolerance
+  template<>
+  class Tolerance<unsigned int>
+  {
+  public:
+    ///\e
+    typedef unsigned int Value;
+
+    ///\name Comparisons
+    ///See \ref 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;}
+  };
+
+#ifndef __STRICT_ANSI__
+
+  ///Long long integer specialization of \ref Tolerance.
+
+  ///Long long integer specialization of \ref 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 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 \ref Tolerance.
+
+  ///Unsigned long long integer specialization of \ref 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 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