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 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 |
|
448 /// @} |
238 /// @} |
449 |
239 |
450 } //namespace lemon |
240 } //namespace lemon |
451 |
241 |
452 #endif //LEMON_TOLERANCE_H |
242 #endif //LEMON_TOLERANCE_H |