COIN-OR::LEMON - Graph Library

Changeset 516:7d7d9debb29a in lemon


Ignore:
Timestamp:
02/20/09 19:06:10 (9 years ago)
Author:
Alpar Juttner <alpar@…>
Branch:
default
Message:

Default implementation of Tolerance<> is used for integer types (#229)

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lemon/tolerance.h

    r515 r516  
    3939  ///as a result of a probably inexact computation. 
    4040  /// 
    41   ///This is an abstract class, it should be specialized for all 
    42   ///numerical data types. These specialized classes like 
     41  ///The general implementation is suitable only if the data type is exact, 
     42  ///like the integer types, otherwise a specialized version must be 
     43  ///implemented. These specialized classes like 
    4344  ///Tolerance<double> may offer additional tuning parameters. 
    4445  /// 
     
    4647  ///\sa Tolerance<double> 
    4748  ///\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> 
    5249 
    5350  template<class T> 
     
    6562 
    6663    ///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;} 
     64    static bool less(Value a,Value b) {return a<b;} 
     65    ///Returns \c true if \c a is \e surely different from \c b 
     66    static bool different(Value a,Value b) {return a!=b;} 
     67    ///Returns \c true if \c a is \e surely positive 
     68    static bool positive(Value a) {return static_cast<Value>(0) < a;} 
     69    ///Returns \c true if \c a is \e surely negative 
     70    static bool negative(Value a) {return a < static_cast<Value>(0);} 
     71    ///Returns \c true if \c a is \e surely non-zero 
     72    static bool nonZero(Value a) {return a != static_cast<Value>(0);} 
    7673 
    7774    ///@} 
    7875 
    7976    ///Returns the zero value. 
    80     static Value zero() {return T();} 
     77    static Value zero() {return static_cast<Value>(0);} 
    8178 
    8279    //   static bool finite(Value a) {} 
     
    239236  }; 
    240237 
    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 HAVE_LONG_LONG  
    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  
    448238  /// @} 
    449239 
Note: See TracChangeset for help on using the changeset viewer.