COIN-OR::LEMON - Graph Library

source: lemon-0.x/lemon/tolerance.h @ 2151:38ec4a930c05

Last change on this file since 2151:38ec4a930c05 was 2073:d886e4b131e6, checked in by Alpar Juttner, 14 years ago
  • fix bug #43: static and const in Tolerance class
  • fix return value of nonZero()
File size: 9.2 KB
Line 
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 */
18
19#ifndef LEMON_TOLERANCE_H
20#define LEMON_TOLERANCE_H
21
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"
28
29
30namespace lemon {
31
32  /// \addtogroup misc
33  /// @{
34 
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>
52
53  template<class T>
54  class Tolerance
55  {
56  public:
57    typedef T Value;
58
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.
63
64    ///@{
65
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;}
76
77    ///@}
78
79    ///Returns the zero value.
80    static Value zero() {return T();}
81
82    //   static bool finite(Value a) {}
83    //   static Value big() {}
84    //   static Value negativeBig() {}
85  };
86
87
88  ///Float specialization of \ref Tolerance.
89
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;
101
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) {}
106
107    ///Return the epsilon value.
108    Value epsilon() const {return _epsilon;}
109    ///Set the epsilon value.
110    void epsilon(Value e) {_epsilon=e;}
111
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;}
116
117    ///\name Comparisons
118    ///See class Tolerance for more details.
119
120    ///@{
121
122    ///Returns \c true if \c a is \e surely strictly less than \c b
123    bool less(Value a,Value b) const {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) const { return less(a,b)||less(b,a); }
126    ///Returns \c true if \c a is \e surely positive
127    bool positive(Value a) const { return _epsilon<a; }
128    ///Returns \c true if \c a is \e surely negative
129    bool negative(Value a) const { return -_epsilon>a; }
130    ///Returns \c true if \c a is \e surely non-zero
131    bool nonZero(Value a) const { return positive(a)||negative(a); };
132
133    ///@}
134
135    ///Returns zero
136    static Value zero() {return 0;}
137  };
138
139  ///Double specialization of \ref Tolerance.
140
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;
152
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) {}
157
158    ///Return the epsilon value.
159    Value epsilon() const {return _epsilon;}
160    ///Set the epsilon value.
161    void epsilon(Value e) {_epsilon=e;}
162
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;}
167
168    ///\name Comparisons
169    ///See class Tolerance for more details.
170
171    ///@{
172
173    ///Returns \c true if \c a is \e surely strictly less than \c b
174    bool less(Value a,Value b) const {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) const { return less(a,b)||less(b,a); }
177    ///Returns \c true if \c a is \e surely positive
178    bool positive(Value a) const { return _epsilon<a; }
179    ///Returns \c true if \c a is \e surely negative
180    bool negative(Value a) const { return -_epsilon>a; }
181    ///Returns \c true if \c a is \e surely non-zero
182    bool nonZero(Value a) const { return positive(a)||negative(a); };
183
184    ///@}
185
186    ///Returns zero
187    static Value zero() {return 0;}
188  };
189
190  ///Long double specialization of \ref Tolerance.
191
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;
203
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) {}
208
209    ///Return the epsilon value.
210    Value epsilon() const {return _epsilon;}
211    ///Set the epsilon value.
212    void epsilon(Value e) {_epsilon=e;}
213
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;}
218
219    ///\name Comparisons
220    ///See class Tolerance for more details.
221
222    ///@{
223
224    ///Returns \c true if \c a is \e surely strictly less than \c b
225    bool less(Value a,Value b) const {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) const { return less(a,b)||less(b,a); }
228    ///Returns \c true if \c a is \e surely positive
229    bool positive(Value a) const { return _epsilon<a; }
230    ///Returns \c true if \c a is \e surely negative
231    bool negative(Value a) const { return -_epsilon>a; }
232    ///Returns \c true if \c a is \e surely non-zero
233    bool nonZero(Value a) const { return positive(a)||negative(a); };
234
235    ///@}
236
237    ///Returns zero
238    static Value zero() {return 0;}
239  };
240
241  ///Integer specialization of \ref Tolerance.
242
243  ///Integer specialization of \ref 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 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#ifndef __STRICT_ANSI__
275
276  ///Long long integer specialization of \ref Tolerance.
277
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;
287
288    ///\name Comparisons
289    ///See \ref Tolerance for more details.
290
291    ///@{
292
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 bool nonZero(Value a) { return a!=0;};
303
304    ///@}
305
306    ///Returns zero
307    static Value zero() {return 0;}
308  };
309
310#endif
311
312  /// @}
313
314} //namespace lemon
315
316#endif //LEMON_TOLERANCE_H
Note: See TracBrowser for help on using the repository browser.