COIN-OR::LEMON - Graph Library

About

Downloads

Documentation

Development

Issue Tracker

Browse Tickets

Custom Query

Roadmap

Browse Source

Local Info

Mailing Lists

Search

Changeset 497:7d7d9debb29a in lemon-main


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

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

File:
1 edited

Legend:

Unmodified
Added
Removed

  • lemon/tolerance.h

    r496 r497  
    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.