diff -r 3f411aa35bd7 -r 4d461e9867da lemon/tolerance.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/lemon/tolerance.h	Thu Dec 20 15:59:06 2007 +0000
@@ -0,0 +1,454 @@
+/* -*- C++ -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library
+ *
+ * Copyright (C) 2003-2007
+ * 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;}
+  };
+  
+
+  ///Long integer specialization of \ref Tolerance.
+
+  ///Long integer specialization of \ref Tolerance.
+  ///\sa Tolerance
+  template<>
+  class Tolerance<long int>
+  {
+  public:
+    ///\e
+    typedef 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 integer specialization of \ref Tolerance.
+
+  ///Unsigned long integer specialization of \ref Tolerance.
+  ///\sa Tolerance
+  template<>
+  class Tolerance<unsigned long int>
+  {
+  public:
+    ///\e
+    typedef unsigned 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;}
+  };
+
+#if defined __GNUC__ && !defined __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