lemon-0.x: lemon/tolerance.h@d7442141d9ef

     1 /* -*- C++ -*-

     2  *

     3  * This file is a part of LEMON, a generic C++ optimization library

     4  *

     5  * Copyright (C) 2003-2006

     6  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

     7  * (Egervary Research Group on Combinatorial Optimization, EGRES).

     8  *

     9  * Permission to use, modify and distribute this software is granted

    10  * provided that this copyright notice appears in all copies. For

    11  * precise terms see the accompanying LICENSE file.

    12  *

    13  * This software is provided "AS IS" with no warranty of any kind,

    14  * express or implied, and with no claim as to its suitability for any

    15  * purpose.

    16  *

    17  */

    19 #ifndef LEMON_TOLERANCE_H

    20 #define LEMON_TOLERANCE_H

    22 ///\ingroup misc

    23 ///\file

    24 ///\brief A basic tool to handle the anomalies of calculation with

    25 ///floating point numbers.

    26 ///

    27 ///\todo It should be in a module like "Basic tools"

    30 namespace lemon {

    32   /// \addtogroup misc

    33   /// @{

    35   ///\brief A class to provide a basic way to

    36   ///handle the comparison of numbers that are obtained

    37   ///as a result of a probably inexact computation.

    38   ///

    39   ///Tolerance is a class to provide a basic way to

    40   ///handle the comparison of numbers that are obtained

    41   ///as a result of a probably inexact computation.

    42   ///

    43   ///This is an abstract class, it should be specialized for all numerical

    44   ///data types. These specialized classes like \ref Tolerance\<double\>

    45   ///may offer additional tuning parameters.

    46   ///

    47   ///\sa Tolerance<float>

    48   ///\sa Tolerance<double>

    49   ///\sa Tolerance<long double>

    50   ///\sa Tolerance<int>

    51   ///\sa Tolerance<long long int>

    53   template<class T>

    54   class Tolerance

    55   {

    56   public:

    57     typedef T Value;

    59     ///\name Comparisons

    60     ///The concept is that these bool functions return with \c true only if

    61     ///the related comparisons hold even if some numerical error appeared

    62     ///during the computations.

    64     ///@{

    66     ///Returns \c true if \c a is \e surely strictly less than \c b

    67     static bool less(Value a,Value b) {return false;}

    68     ///Returns \c true if \c a is \e surely different from \c b

    69     static bool different(Value a,Value b) {return false;}

    70     ///Returns \c true if \c a is \e surely positive

    71     static bool positive(Value a) {return false;}

    72     ///Returns \c true if \c a is \e surely negative

    73     static bool negative(Value a) {return false;}

    74     ///Returns \c true if \c a is \e surely non-zero

    75     static bool nonZero(Value a) {return false;}

    77     ///@}

    79     ///Returns the zero value.

    80     static Value zero() {return T();}

    82     //   static bool finite(Value a) {}

    83     //   static Value big() {}

    84     //   static Value negativeBig() {}

    85   };

    88   ///Float specialization of \ref Tolerance.

    90   ///Float specialization of \ref Tolerance.

    91   ///\sa Tolerance

    92   ///\relates Tolerance

    93   template<>

    94   class Tolerance<float>

    95   {

    96     static float def_epsilon;

    97     float _epsilon;

    98   public:

    99     ///\e

   100     typedef float Value;

   102     ///Constructor setting the epsilon tolerance to the default value.

   103     Tolerance() : _epsilon(def_epsilon) {}

   104     ///Constructor setting the epsilon tolerance.

   105     Tolerance(float e) : _epsilon(e) {}

   107     ///Return the epsilon value.

   108     Value epsilon() {return _epsilon;}

   109     ///Set the epsilon value.

   110     void epsilon(Value e) {_epsilon=e;}

   112     ///Return the default epsilon value.

   113     static Value defaultEpsilon() {return def_epsilon;}

   114     ///Set the default epsilon value.

   115     static void defaultEpsilon(Value e) {def_epsilon=e;}

   117     ///\name Comparisons

   118     ///See class Tolerance for more details.

   120     ///@{

   122     ///Returns \c true if \c a is \e surely strictly less than \c b

   123     bool less(Value a,Value b) {return a+_epsilon<b;}

   124     ///Returns \c true if \c a is \e surely different from \c b

   125     bool different(Value a,Value b) { return less(a,b)||less(b,a); }

   126     ///Returns \c true if \c a is \e surely positive

   127     bool positive(Value a) { return _epsilon<a; }

   128     ///Returns \c true if \c a is \e surely negative

   129     bool negative(Value a) { return -_epsilon>a; }

   130     ///Returns \c true if \c a is \e surely non-zero

   131     Value nonZero(Value a) { return positive(a)||negative(a); };

   133     ///@}

   135     ///Returns zero

   136     static Value zero() {return 0;}

   137   };

   139   ///Double specialization of \ref Tolerance.

   141   ///Double specialization of \ref Tolerance.

   142   ///\sa Tolerance

   143   ///\relates Tolerance

   144   template<>

   145   class Tolerance<double>

   146   {

   147     static double def_epsilon;

   148     double _epsilon;

   149   public:

   150     ///\e

   151     typedef double Value;

   153     ///Constructor setting the epsilon tolerance to the default value.

   154     Tolerance() : _epsilon(def_epsilon) {}

   155     ///Constructor setting the epsilon tolerance.

   156     Tolerance(double e) : _epsilon(e) {}

   158     ///Return the epsilon value.

   159     Value epsilon() {return _epsilon;}

   160     ///Set the epsilon value.

   161     void epsilon(Value e) {_epsilon=e;}

   163     ///Return the default epsilon value.

   164     static Value defaultEpsilon() {return def_epsilon;}

   165     ///Set the default epsilon value.

   166     static void defaultEpsilon(Value e) {def_epsilon=e;}

   168     ///\name Comparisons

   169     ///See class Tolerance for more details.

   171     ///@{

   173     ///Returns \c true if \c a is \e surely strictly less than \c b

   174     bool less(Value a,Value b) {return a+_epsilon<b;}

   175     ///Returns \c true if \c a is \e surely different from \c b

   176     bool different(Value a,Value b) { return less(a,b)||less(b,a); }

   177     ///Returns \c true if \c a is \e surely positive

   178     bool positive(Value a) { return _epsilon<a; }

   179     ///Returns \c true if \c a is \e surely negative

   180     bool negative(Value a) { return -_epsilon>a; }

   181     ///Returns \c true if \c a is \e surely non-zero

   182     Value nonZero(Value a) { return positive(a)||negative(a); };

   184     ///@}

   186     ///Returns zero

   187     static Value zero() {return 0;}

   188   };

   190   ///Long double specialization of \ref Tolerance.

   192   ///Long double specialization of \ref Tolerance.

   193   ///\sa Tolerance

   194   ///\relates Tolerance

   195   template<>

   196   class Tolerance<long double>

   197   {

   198     static long double def_epsilon;

   199     long double _epsilon;

   200   public:

   201     ///\e

   202     typedef long double Value;

   204     ///Constructor setting the epsilon tolerance to the default value.

   205     Tolerance() : _epsilon(def_epsilon) {}

   206     ///Constructor setting the epsilon tolerance.

   207     Tolerance(long double e) : _epsilon(e) {}

   209     ///Return the epsilon value.

   210     Value epsilon() {return _epsilon;}

   211     ///Set the epsilon value.

   212     void epsilon(Value e) {_epsilon=e;}

   214     ///Return the default epsilon value.

   215     static Value defaultEpsilon() {return def_epsilon;}

   216     ///Set the default epsilon value.

   217     static void defaultEpsilon(Value e) {def_epsilon=e;}

   219     ///\name Comparisons

   220     ///See class Tolerance for more details.

   222     ///@{

   224     ///Returns \c true if \c a is \e surely strictly less than \c b

   225     bool less(Value a,Value b) {return a+_epsilon<b;}

   226     ///Returns \c true if \c a is \e surely different from \c b

   227     bool different(Value a,Value b) { return less(a,b)||less(b,a); }

   228     ///Returns \c true if \c a is \e surely positive

   229     bool positive(Value a) { return _epsilon<a; }

   230     ///Returns \c true if \c a is \e surely negative

   231     bool negative(Value a) { return -_epsilon>a; }

   232     ///Returns \c true if \c a is \e surely non-zero

   233     Value nonZero(Value a) { return positive(a)||negative(a); };

   235     ///@}

   237     ///Returns zero

   238     static Value zero() {return 0;}

   239   };

   241   ///Integer specialization of \ref Tolerance.

   243   ///Integer specialization of \ref Tolerance.

   244   ///\sa Tolerance

   245   template<>

   246   class Tolerance<int>

   247   {

   248   public:

   249     ///\e

   250     typedef int Value;

   252     ///\name Comparisons

   253     ///See \ref Tolerance for more details.

   255     ///@{

   257     ///Returns \c true if \c a is \e surely strictly less than \c b

   258     static bool less(Value a,Value b) { return a<b;}

   259     ///Returns \c true if \c a is \e surely different from \c b

   260     static bool different(Value a,Value b) { return a!=b; }

   261     ///Returns \c true if \c a is \e surely positive

   262     static bool positive(Value a) { return 0<a; }

   263     ///Returns \c true if \c a is \e surely negative

   264     static bool negative(Value a) { return 0>a; }

   265     ///Returns \c true if \c a is \e surely non-zero

   266     static Value nonZero(Value a) { return a!=0;};

   268     ///@}

   270     ///Returns zero

   271     static Value zero() {return 0;}

   272   };

   274 #ifndef __STRICT_ANSI__

   276   ///Long long integer specialization of \ref Tolerance.

   278   ///Long long integer specialization of \ref Tolerance.

   279   ///\warning This class is not ansi compatible.

   280   ///\sa Tolerance

   281   template<>

   282   class Tolerance<long long int>

   283   {

   284   public:

   285     ///\e

   286     typedef long long int Value;

   288     ///\name Comparisons

   289     ///See \ref Tolerance for more details.

   291     ///@{

   293     ///Returns \c true if \c a is \e surely strictly less than \c b

   294     static bool less(Value a,Value b) { return a<b;}

   295     ///Returns \c true if \c a is \e surely different from \c b

   296     static bool different(Value a,Value b) { return a!=b; }

   297     ///Returns \c true if \c a is \e surely positive

   298     static bool positive(Value a) { return 0<a; }

   299     ///Returns \c true if \c a is \e surely negative

   300     static bool negative(Value a) { return 0>a; }

   301     ///Returns \c true if \c a is \e surely non-zero

   302     static Value nonZero(Value a) { return a!=0;};

   304     ///@}

   306     ///Returns zero

   307     static Value zero() {return 0;}

   308   };

   310 #endif

   312   /// @}

   314 } //namespace lemon

   316 #endif //LEMON_TOLERANCE_H

author	deba
	Wed, 01 Mar 2006 10:25:30 +0000
changeset 1991	d7442141d9ef
parent 1956	a055123339d5
child 2073	d886e4b131e6
permissions	-rw-r--r--