34 |
34 |
35 ///\brief A class to provide a basic way to |
35 ///\brief A class to provide a basic way to |
36 ///handle the comparison of numbers that are obtained |
36 ///handle the comparison of numbers that are obtained |
37 ///as a result of a probably inexact computation. |
37 ///as a result of a probably inexact computation. |
38 /// |
38 /// |
39 ///Tolerance is a class to provide a basic way to |
39 ///\ref Tolerance is a class to provide a basic way to |
40 ///handle the comparison of numbers that are obtained |
40 ///handle the comparison of numbers that are obtained |
41 ///as a result of a probably inexact computation. |
41 ///as a result of a probably inexact computation. |
42 /// |
42 /// |
43 ///This is an abstract class, it should be specialized for all numerical |
43 ///This is an abstract class, it should be specialized for all numerical |
44 ///data types. These specialized classes like Tolerance<double> |
44 ///data types. These specialized classes like \ref Tolerance<double> |
45 ///may offer additional tuning parameters. |
45 ///may offer additional tuning parameters. |
46 /// |
46 /// |
47 ///\sa Tolerance<float> |
47 ///\sa Tolerance<float> |
48 ///\sa Tolerance<double> |
48 ///\sa Tolerance<double> |
49 ///\sa Tolerance<long double> |
49 ///\sa Tolerance<long double> |
50 ///\sa Tolerance<int> |
50 ///\sa Tolerance<int> |
51 #if defined __GNUC__ && !defined __STRICT_ANSI__ |
|
52 ///\sa Tolerance<long long int> |
51 ///\sa Tolerance<long long int> |
53 #endif |
|
54 ///\sa Tolerance<unsigned int> |
52 ///\sa Tolerance<unsigned int> |
55 #if defined __GNUC__ && !defined __STRICT_ANSI__ |
|
56 ///\sa Tolerance<unsigned long long int> |
53 ///\sa Tolerance<unsigned long long int> |
57 #endif |
|
58 |
54 |
59 template<class T> |
55 template<class T> |
60 class Tolerance |
56 class Tolerance |
61 { |
57 { |
62 public: |
58 public: |
63 typedef T Value; |
59 typedef T Value; |
64 |
60 |
65 ///\name Comparisons |
61 ///\name Comparisons |
66 ///The concept is that these bool functions return with \c true only if |
62 ///The concept is that these bool functions return \c true only if |
67 ///the related comparisons hold even if some numerical error appeared |
63 ///the related comparisons hold even if some numerical error appeared |
68 ///during the computations. |
64 ///during the computations. |
69 |
65 |
70 ///@{ |
66 ///@{ |
71 |
67 |
105 ///\e |
101 ///\e |
106 typedef float Value; |
102 typedef float Value; |
107 |
103 |
108 ///Constructor setting the epsilon tolerance to the default value. |
104 ///Constructor setting the epsilon tolerance to the default value. |
109 Tolerance() : _epsilon(def_epsilon) {} |
105 Tolerance() : _epsilon(def_epsilon) {} |
110 ///Constructor setting the epsilon tolerance. |
106 ///Constructor setting the epsilon tolerance to the given value. |
111 Tolerance(float e) : _epsilon(e) {} |
107 Tolerance(float e) : _epsilon(e) {} |
112 |
108 |
113 ///Return the epsilon value. |
109 ///Returns the epsilon value. |
114 Value epsilon() const {return _epsilon;} |
110 Value epsilon() const {return _epsilon;} |
115 ///Set the epsilon value. |
111 ///Sets the epsilon value. |
116 void epsilon(Value e) {_epsilon=e;} |
112 void epsilon(Value e) {_epsilon=e;} |
117 |
113 |
118 ///Return the default epsilon value. |
114 ///Returns the default epsilon value. |
119 static Value defaultEpsilon() {return def_epsilon;} |
115 static Value defaultEpsilon() {return def_epsilon;} |
120 ///Set the default epsilon value. |
116 ///Sets the default epsilon value. |
121 static void defaultEpsilon(Value e) {def_epsilon=e;} |
117 static void defaultEpsilon(Value e) {def_epsilon=e;} |
122 |
118 |
123 ///\name Comparisons |
119 ///\name Comparisons |
124 ///See class Tolerance for more details. |
120 ///See \ref Tolerance for more details. |
125 |
121 |
126 ///@{ |
122 ///@{ |
127 |
123 |
128 ///Returns \c true if \c a is \e surely strictly less than \c b |
124 ///Returns \c true if \c a is \e surely strictly less than \c b |
129 bool less(Value a,Value b) const {return a+_epsilon<b;} |
125 bool less(Value a,Value b) const {return a+_epsilon<b;} |
156 ///\e |
152 ///\e |
157 typedef double Value; |
153 typedef double Value; |
158 |
154 |
159 ///Constructor setting the epsilon tolerance to the default value. |
155 ///Constructor setting the epsilon tolerance to the default value. |
160 Tolerance() : _epsilon(def_epsilon) {} |
156 Tolerance() : _epsilon(def_epsilon) {} |
161 ///Constructor setting the epsilon tolerance. |
157 ///Constructor setting the epsilon tolerance to the given value. |
162 Tolerance(double e) : _epsilon(e) {} |
158 Tolerance(double e) : _epsilon(e) {} |
163 |
159 |
164 ///Return the epsilon value. |
160 ///Returns the epsilon value. |
165 Value epsilon() const {return _epsilon;} |
161 Value epsilon() const {return _epsilon;} |
166 ///Set the epsilon value. |
162 ///Sets the epsilon value. |
167 void epsilon(Value e) {_epsilon=e;} |
163 void epsilon(Value e) {_epsilon=e;} |
168 |
164 |
169 ///Return the default epsilon value. |
165 ///Returns the default epsilon value. |
170 static Value defaultEpsilon() {return def_epsilon;} |
166 static Value defaultEpsilon() {return def_epsilon;} |
171 ///Set the default epsilon value. |
167 ///Sets the default epsilon value. |
172 static void defaultEpsilon(Value e) {def_epsilon=e;} |
168 static void defaultEpsilon(Value e) {def_epsilon=e;} |
173 |
169 |
174 ///\name Comparisons |
170 ///\name Comparisons |
175 ///See class Tolerance for more details. |
171 ///See \ref Tolerance for more details. |
176 |
172 |
177 ///@{ |
173 ///@{ |
178 |
174 |
179 ///Returns \c true if \c a is \e surely strictly less than \c b |
175 ///Returns \c true if \c a is \e surely strictly less than \c b |
180 bool less(Value a,Value b) const {return a+_epsilon<b;} |
176 bool less(Value a,Value b) const {return a+_epsilon<b;} |
207 ///\e |
203 ///\e |
208 typedef long double Value; |
204 typedef long double Value; |
209 |
205 |
210 ///Constructor setting the epsilon tolerance to the default value. |
206 ///Constructor setting the epsilon tolerance to the default value. |
211 Tolerance() : _epsilon(def_epsilon) {} |
207 Tolerance() : _epsilon(def_epsilon) {} |
212 ///Constructor setting the epsilon tolerance. |
208 ///Constructor setting the epsilon tolerance to the given value. |
213 Tolerance(long double e) : _epsilon(e) {} |
209 Tolerance(long double e) : _epsilon(e) {} |
214 |
210 |
215 ///Return the epsilon value. |
211 ///Returns the epsilon value. |
216 Value epsilon() const {return _epsilon;} |
212 Value epsilon() const {return _epsilon;} |
217 ///Set the epsilon value. |
213 ///Sets the epsilon value. |
218 void epsilon(Value e) {_epsilon=e;} |
214 void epsilon(Value e) {_epsilon=e;} |
219 |
215 |
220 ///Return the default epsilon value. |
216 ///Returns the default epsilon value. |
221 static Value defaultEpsilon() {return def_epsilon;} |
217 static Value defaultEpsilon() {return def_epsilon;} |
222 ///Set the default epsilon value. |
218 ///Sets the default epsilon value. |
223 static void defaultEpsilon(Value e) {def_epsilon=e;} |
219 static void defaultEpsilon(Value e) {def_epsilon=e;} |
224 |
220 |
225 ///\name Comparisons |
221 ///\name Comparisons |
226 ///See class Tolerance for more details. |
222 ///See \ref Tolerance for more details. |
227 |
223 |
228 ///@{ |
224 ///@{ |
229 |
225 |
230 ///Returns \c true if \c a is \e surely strictly less than \c b |
226 ///Returns \c true if \c a is \e surely strictly less than \c b |
231 bool less(Value a,Value b) const {return a+_epsilon<b;} |
227 bool less(Value a,Value b) const {return a+_epsilon<b;} |