lemon/tolerance.h
changeset 821 072ec8120958
parent 440 88ed40ad0d4f
parent 486 7d7d9debb29a
equal deleted inserted replaced
8:62ef33300a5c 11:a041b6177753
    36   ///
    36   ///
    37   ///\ref Tolerance is a class to provide a basic way to
    37   ///\ref Tolerance is a class to provide a basic way to
    38   ///handle the comparison of numbers that are obtained
    38   ///handle the comparison of numbers that are obtained
    39   ///as a result of a probably inexact computation.
    39   ///as a result of a probably inexact computation.
    40   ///
    40   ///
    41   ///This is an abstract class, it should be specialized for all
    41   ///The general implementation is suitable only if the data type is exact,
    42   ///numerical data types. These specialized classes like
    42   ///like the integer types, otherwise a specialized version must be
       
    43   ///implemented. These specialized classes like
    43   ///Tolerance<double> may offer additional tuning parameters.
    44   ///Tolerance<double> may offer additional tuning parameters.
    44   ///
    45   ///
    45   ///\sa Tolerance<float>
    46   ///\sa Tolerance<float>
    46   ///\sa Tolerance<double>
    47   ///\sa Tolerance<double>
    47   ///\sa Tolerance<long double>
    48   ///\sa Tolerance<long double>
    48   ///\sa Tolerance<int>
       
    49   ///\sa Tolerance<long long int>
       
    50   ///\sa Tolerance<unsigned int>
       
    51   ///\sa Tolerance<unsigned long long int>
       
    52 
    49 
    53   template<class T>
    50   template<class T>
    54   class Tolerance
    51   class Tolerance
    55   {
    52   {
    56   public:
    53   public:
    62     ///during the computations.
    59     ///during the computations.
    63 
    60 
    64     ///@{
    61     ///@{
    65 
    62 
    66     ///Returns \c true if \c a is \e surely strictly less than \c b
    63     ///Returns \c true if \c a is \e surely strictly less than \c b
    67     static bool less(Value a,Value b) {return false;}
    64     static bool less(Value a,Value b) {return a<b;}
    68     ///Returns \c true if \c a is \e surely different from \c b
    65     ///Returns \c true if \c a is \e surely different from \c b
    69     static bool different(Value a,Value b) {return false;}
    66     static bool different(Value a,Value b) {return a!=b;}
    70     ///Returns \c true if \c a is \e surely positive
    67     ///Returns \c true if \c a is \e surely positive
    71     static bool positive(Value a) {return false;}
    68     static bool positive(Value a) {return static_cast<Value>(0) < a;}
    72     ///Returns \c true if \c a is \e surely negative
    69     ///Returns \c true if \c a is \e surely negative
    73     static bool negative(Value a) {return false;}
    70     static bool negative(Value a) {return a < static_cast<Value>(0);}
    74     ///Returns \c true if \c a is \e surely non-zero
    71     ///Returns \c true if \c a is \e surely non-zero
    75     static bool nonZero(Value a) {return false;}
    72     static bool nonZero(Value a) {return a != static_cast<Value>(0);}
    76 
    73 
    77     ///@}
    74     ///@}
    78 
    75 
    79     ///Returns the zero value.
    76     ///Returns the zero value.
    80     static Value zero() {return T();}
    77     static Value zero() {return static_cast<Value>(0);}
    81 
    78 
    82     //   static bool finite(Value a) {}
    79     //   static bool finite(Value a) {}
    83     //   static Value big() {}
    80     //   static Value big() {}
    84     //   static Value negativeBig() {}
    81     //   static Value negativeBig() {}
    85   };
    82   };
   236 
   233 
   237     ///Returns zero
   234     ///Returns zero
   238     static Value zero() {return 0;}
   235     static Value zero() {return 0;}
   239   };
   236   };
   240 
   237 
   241   ///Integer specialization of Tolerance.
       
   242 
       
   243   ///Integer specialization of Tolerance.
       
   244   ///\sa Tolerance
       
   245   template<>
       
   246   class Tolerance<int>
       
   247   {
       
   248   public:
       
   249     ///\e
       
   250     typedef int Value;
       
   251 
       
   252     ///\name Comparisons
       
   253     ///See \ref lemon::Tolerance "Tolerance" for more details.
       
   254 
       
   255     ///@{
       
   256 
       
   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 bool nonZero(Value a) { return a!=0; }
       
   267 
       
   268     ///@}
       
   269 
       
   270     ///Returns zero
       
   271     static Value zero() {return 0;}
       
   272   };
       
   273 
       
   274   ///Unsigned integer specialization of Tolerance.
       
   275 
       
   276   ///Unsigned integer specialization of Tolerance.
       
   277   ///\sa Tolerance
       
   278   template<>
       
   279   class Tolerance<unsigned int>
       
   280   {
       
   281   public:
       
   282     ///\e
       
   283     typedef unsigned int Value;
       
   284 
       
   285     ///\name Comparisons
       
   286     ///See \ref lemon::Tolerance "Tolerance" for more details.
       
   287 
       
   288     ///@{
       
   289 
       
   290     ///Returns \c true if \c a is \e surely strictly less than \c b
       
   291     static bool less(Value a,Value b) { return a<b;}
       
   292     ///Returns \c true if \c a is \e surely different from \c b
       
   293     static bool different(Value a,Value b) { return a!=b; }
       
   294     ///Returns \c true if \c a is \e surely positive
       
   295     static bool positive(Value a) { return 0<a; }
       
   296     ///Returns \c true if \c a is \e surely negative
       
   297     static bool negative(Value) { return false; }
       
   298     ///Returns \c true if \c a is \e surely non-zero
       
   299     static bool nonZero(Value a) { return a!=0; }
       
   300 
       
   301     ///@}
       
   302 
       
   303     ///Returns zero
       
   304     static Value zero() {return 0;}
       
   305   };
       
   306 
       
   307 
       
   308   ///Long integer specialization of Tolerance.
       
   309 
       
   310   ///Long integer specialization of Tolerance.
       
   311   ///\sa Tolerance
       
   312   template<>
       
   313   class Tolerance<long int>
       
   314   {
       
   315   public:
       
   316     ///\e
       
   317     typedef long int Value;
       
   318 
       
   319     ///\name Comparisons
       
   320     ///See \ref lemon::Tolerance "Tolerance" for more details.
       
   321 
       
   322     ///@{
       
   323 
       
   324     ///Returns \c true if \c a is \e surely strictly less than \c b
       
   325     static bool less(Value a,Value b) { return a<b;}
       
   326     ///Returns \c true if \c a is \e surely different from \c b
       
   327     static bool different(Value a,Value b) { return a!=b; }
       
   328     ///Returns \c true if \c a is \e surely positive
       
   329     static bool positive(Value a) { return 0<a; }
       
   330     ///Returns \c true if \c a is \e surely negative
       
   331     static bool negative(Value a) { return 0>a; }
       
   332     ///Returns \c true if \c a is \e surely non-zero
       
   333     static bool nonZero(Value a) { return a!=0;}
       
   334 
       
   335     ///@}
       
   336 
       
   337     ///Returns zero
       
   338     static Value zero() {return 0;}
       
   339   };
       
   340 
       
   341   ///Unsigned long integer specialization of Tolerance.
       
   342 
       
   343   ///Unsigned long integer specialization of Tolerance.
       
   344   ///\sa Tolerance
       
   345   template<>
       
   346   class Tolerance<unsigned long int>
       
   347   {
       
   348   public:
       
   349     ///\e
       
   350     typedef unsigned long int Value;
       
   351 
       
   352     ///\name Comparisons
       
   353     ///See \ref lemon::Tolerance "Tolerance" for more details.
       
   354 
       
   355     ///@{
       
   356 
       
   357     ///Returns \c true if \c a is \e surely strictly less than \c b
       
   358     static bool less(Value a,Value b) { return a<b;}
       
   359     ///Returns \c true if \c a is \e surely different from \c b
       
   360     static bool different(Value a,Value b) { return a!=b; }
       
   361     ///Returns \c true if \c a is \e surely positive
       
   362     static bool positive(Value a) { return 0<a; }
       
   363     ///Returns \c true if \c a is \e surely negative
       
   364     static bool negative(Value) { return false; }
       
   365     ///Returns \c true if \c a is \e surely non-zero
       
   366     static bool nonZero(Value a) { return a!=0;}
       
   367 
       
   368     ///@}
       
   369 
       
   370     ///Returns zero
       
   371     static Value zero() {return 0;}
       
   372   };
       
   373 
       
   374 #if defined __GNUC__ && !defined __STRICT_ANSI__
       
   375 
       
   376   ///Long long integer specialization of Tolerance.
       
   377 
       
   378   ///Long long integer specialization of Tolerance.
       
   379   ///\warning This class (more exactly, type <tt>long long</tt>)
       
   380   ///is not ansi compatible.
       
   381   ///\sa Tolerance
       
   382   template<>
       
   383   class Tolerance<long long int>
       
   384   {
       
   385   public:
       
   386     ///\e
       
   387     typedef long long int Value;
       
   388 
       
   389     ///\name Comparisons
       
   390     ///See \ref lemon::Tolerance "Tolerance" for more details.
       
   391 
       
   392     ///@{
       
   393 
       
   394     ///Returns \c true if \c a is \e surely strictly less than \c b
       
   395     static bool less(Value a,Value b) { return a<b;}
       
   396     ///Returns \c true if \c a is \e surely different from \c b
       
   397     static bool different(Value a,Value b) { return a!=b; }
       
   398     ///Returns \c true if \c a is \e surely positive
       
   399     static bool positive(Value a) { return 0<a; }
       
   400     ///Returns \c true if \c a is \e surely negative
       
   401     static bool negative(Value a) { return 0>a; }
       
   402     ///Returns \c true if \c a is \e surely non-zero
       
   403     static bool nonZero(Value a) { return a!=0;}
       
   404 
       
   405     ///@}
       
   406 
       
   407     ///Returns zero
       
   408     static Value zero() {return 0;}
       
   409   };
       
   410 
       
   411   ///Unsigned long long integer specialization of Tolerance.
       
   412 
       
   413   ///Unsigned long long integer specialization of Tolerance.
       
   414   ///\warning This class (more exactly, type <tt>unsigned long long</tt>)
       
   415   ///is not ansi compatible.
       
   416   ///\sa Tolerance
       
   417   template<>
       
   418   class Tolerance<unsigned long long int>
       
   419   {
       
   420   public:
       
   421     ///\e
       
   422     typedef unsigned long long int Value;
       
   423 
       
   424     ///\name Comparisons
       
   425     ///See \ref lemon::Tolerance "Tolerance" for more details.
       
   426 
       
   427     ///@{
       
   428 
       
   429     ///Returns \c true if \c a is \e surely strictly less than \c b
       
   430     static bool less(Value a,Value b) { return a<b;}
       
   431     ///Returns \c true if \c a is \e surely different from \c b
       
   432     static bool different(Value a,Value b) { return a!=b; }
       
   433     ///Returns \c true if \c a is \e surely positive
       
   434     static bool positive(Value a) { return 0<a; }
       
   435     ///Returns \c true if \c a is \e surely negative
       
   436     static bool negative(Value) { return false; }
       
   437     ///Returns \c true if \c a is \e surely non-zero
       
   438     static bool nonZero(Value a) { return a!=0;}
       
   439 
       
   440     ///@}
       
   441 
       
   442     ///Returns zero
       
   443     static Value zero() {return 0;}
       
   444   };
       
   445 
       
   446 #endif
       
   447 
       
   448   /// @}
   238   /// @}
   449 
   239 
   450 } //namespace lemon
   240 } //namespace lemon
   451 
   241 
   452 #endif //LEMON_TOLERANCE_H
   242 #endif //LEMON_TOLERANCE_H