Claw  1.7.3
real_number.tpp
1 /*
2  CLAW - a C++ Library Absolutely Wonderful
3 
4  CLAW is a free library without any particular aim but being useful to
5  anyone.
6 
7  Copyright (C) 2005-2011 Julien Jorge
8 
9  This library is free software; you can redistribute it and/or
10  modify it under the terms of the GNU Lesser General Public
11  License as published by the Free Software Foundation; either
12  version 2.1 of the License, or (at your option) any later version.
13 
14  This library is distributed in the hope that it will be useful,
15  but WITHOUT ANY WARRANTY; without even the implied warranty of
16  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  Lesser General Public License for more details.
18 
19  You should have received a copy of the GNU Lesser General Public
20  License along with this library; if not, write to the Free Software
21  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
22 
23  contact: julien.jorge@gamned.org
24 */
25 /**
26  * \file claw/impl/real_number.tpp
27  * \brief Implementation of the claw::real_number class.
28  * \author Julien Jorge
29  */
30 #include <cmath>
31 
32 /*----------------------------------------------------------------------------*/
33 /**
34  * \brief Constructuor.
35  */
36 template<typename T>
37 claw::real_number<T>::real_number()
38  : m_value(0), m_epsilon( make_epsilon<value_type>::value(m_value) )
39 {
40 
41 } // real_number::real_number()
42 
43 /*----------------------------------------------------------------------------*/
44 /**
45  * \brief Constructor.
46  * \param v The value of the number.
47  */
48 template<typename T>
49 claw::real_number<T>::real_number( const value_type& v )
50  : m_value(v), m_epsilon( make_epsilon<T>::value(m_value) )
51 {
52 
53 } // real_number::real_number()
54 
55 /*----------------------------------------------------------------------------*/
56 /**
57  * \brief Copy constructor.
58  * \param that The instance to copy from.
59  */
60 template<typename T>
61 claw::real_number<T>::real_number( const self_type& that )
62  : m_value(that.m_value), m_epsilon(that.m_epsilon)
63 {
64 
65 } // real_number::real_number()
66 
67 /*----------------------------------------------------------------------------*/
68 /**
69  * \brief Get the absolute value of the number.
70  */
71 template<typename T>
72 typename claw::real_number<T>::self_type claw::real_number<T>::abs() const
73 {
74  return self_type( std::abs(m_value) );
75 } // real_number::abs()
76 
77 /*----------------------------------------------------------------------------*/
78 /**
79  * \brief Tell if this number is stricty lower than an other number.
80  * \param that The other number.
81  */
82 template<typename T>
83 bool claw::real_number<T>::operator<( const self_type& that ) const
84 {
85  if ( that.m_value == std::numeric_limits<value_type>::infinity() )
86  return m_value != std::numeric_limits<value_type>::infinity();
87  else if ( that.m_value == -std::numeric_limits<value_type>::infinity() )
88  return false;
89  else if ( m_value == std::numeric_limits<value_type>::infinity() )
90  return false;
91  else if ( m_value == -std::numeric_limits<value_type>::infinity() )
92  return that.m_value != -std::numeric_limits<value_type>::infinity();
93  else
94  return m_value < (that.m_value - std::max(m_epsilon, that.m_epsilon));
95 } // real_number::operator<()
96 
97 /*----------------------------------------------------------------------------*/
98 /**
99  * \brief Tell if this number is lower or equal to an other number.
100  * \param that The other number.
101  */
102 template<typename T>
103 bool claw::real_number<T>::operator<=( const self_type& that ) const
104 {
105  return !(that < *this);
106 } // real_number::operator<=()
107 
108 /*----------------------------------------------------------------------------*/
109 /**
110  * \brief Tell if this number is stricty greater than an other number.
111  * \param that The other number.
112  */
113 template<typename T>
114 bool claw::real_number<T>::operator>( const self_type& that ) const
115 {
116  return that < *this;
117 } // real_number::operator>()
118 
119 /*----------------------------------------------------------------------------*/
120 /**
121  * \brief Tell if this number is greater or equal to an other number.
122  * \param that The other number.
123  */
124 template<typename T>
125 bool claw::real_number<T>::operator>=( const self_type& that ) const
126 {
127  return that <= *this;
128 } // real_number::operator>=()
129 
130 /*----------------------------------------------------------------------------*/
131 /**
132  * \brief Tell if this number is equal to an other number.
133  * \param that The other number.
134  */
135 template<typename T>
136 bool claw::real_number<T>::operator==( const self_type& that ) const
137 {
138  if ( that.m_value == std::numeric_limits<value_type>::infinity() )
139  return m_value == std::numeric_limits<value_type>::infinity();
140  else if ( that.m_value == -std::numeric_limits<value_type>::infinity() )
141  return m_value == -std::numeric_limits<value_type>::infinity();
142  else if ( m_value == that.m_value )
143  return true;
144  else
145  return std::abs(m_value - that.m_value)
146  <= std::max(m_epsilon, that.m_epsilon);
147 } // real_number::operator==()
148 
149 /*----------------------------------------------------------------------------*/
150 /**
151  * \brief Tell if this number is not equal to an other number.
152  * \param that The other number.
153  */
154 template<typename T>
155 bool claw::real_number<T>::operator!=( const self_type& that ) const
156 {
157  return !((*this) == that);
158 } // real_number::operator!=()
159 
160 /*----------------------------------------------------------------------------*/
161 /**
162  * \brief Sum two numbers.
163  * \param that The other number.
164  */
165 template<typename T>
166 typename claw::real_number<T>::self_type
167 claw::real_number<T>::operator+( const self_type& that ) const
168 {
169  return self_type(m_value + that.m_value);
170 } // real_number::operator+()
171 
172 /*----------------------------------------------------------------------------*/
173 /**
174  * \brief Get the difference of two numbers.
175  * \param that The other number.
176  */
177 template<typename T>
178 typename claw::real_number<T>::self_type
179 claw::real_number<T>::operator-( const self_type& that ) const
180 {
181  return self_type(m_value - that.m_value);
182 } // real_number::operator-()
183 
184 /*----------------------------------------------------------------------------*/
185 /**
186  * \brief Multiply two numbers.
187  * \param that The other number.
188  */
189 template<typename T>
190 typename claw::real_number<T>::self_type
191 claw::real_number<T>::operator*( const self_type& that ) const
192 {
193  return self_type(m_value * that.m_value);
194 } // real_number::operator*()
195 
196 /*----------------------------------------------------------------------------*/
197 /**
198  * \brief Divide by an other number.
199  * \param that The other number.
200  */
201 template<typename T>
202 typename claw::real_number<T>::self_type
203 claw::real_number<T>::operator/( const self_type& that ) const
204 {
205  return self_type(m_value / that.m_value);
206 } // real_number::operator/()
207 
208 /*----------------------------------------------------------------------------*/
209 /**
210  * \brief Add an other number.
211  * \param that The other number.
212  */
213 template<typename T>
214 typename claw::real_number<T>::self_type&
215 claw::real_number<T>::operator+=( const self_type& that )
216 {
217  m_value += that.m_value;
218  m_epsilon = make_epsilon<value_type>::value(m_value);
219  return *this;
220 } // real_number::operator+=()
221 
222 /*----------------------------------------------------------------------------*/
223 /**
224  * \brief Subtract an other number.
225  * \param that The other number.
226  */
227 template<typename T>
228 typename claw::real_number<T>::self_type&
229 claw::real_number<T>::operator-=( const self_type& that )
230 {
231  m_value -= that.m_value;
232  m_epsilon = make_epsilon<value_type>::value(m_value);
233  return *this;
234 } // real_number::operator-=()
235 
236 /*----------------------------------------------------------------------------*/
237 /**
238  * \brief Multiply by an other number.
239  * \param that The other number.
240  */
241 template<typename T>
242 typename claw::real_number<T>::self_type&
243 claw::real_number<T>::operator*=( const self_type& that )
244 {
245  m_value *= that.m_value;
246  m_epsilon = make_epsilon<value_type>::value(m_value);
247  return *this;
248 } // real_number::operator*=()
249 
250 /*----------------------------------------------------------------------------*/
251 /**
252  * \brief Divide by an other number.
253  * \param that The other number.
254  */
255 template<typename T>
256 typename claw::real_number<T>::self_type&
257 claw::real_number<T>::operator/=( const self_type& that )
258 {
259  m_value /= that.m_value;
260  m_epsilon = make_epsilon<value_type>::value(m_value);
261  return *this;
262 } // real_number::operator/=()
263 
264 /*----------------------------------------------------------------------------*/
265 /**
266  * \brief Output the value in a stream.
267  * \param os The stream in which the value is written.
268  */
269 template<typename T>
270 std::ostream& claw::real_number<T>::output( std::ostream& os ) const
271 {
272  return os << m_value;
273 } // real_number::output()
274 
275 /*----------------------------------------------------------------------------*/
276 /**
277  * \brief Cast the value.
278  */
279 template<typename T>
280 template<typename U>
281 claw::real_number<T>::operator U() const
282 {
283  return (U)m_value;
284 } // real_number::operator U()
285 
286 /*----------------------------------------------------------------------------*/
287 /**
288  * \brief Get the absolute value of a number.
289  * \param v The number.
290  */
291 template<typename T>
292 claw::real_number<T> std::abs( const claw::real_number<T>& v )
293 {
294  return v.abs();
295 } // abs()
296 
297 /*----------------------------------------------------------------------------*/
298 /**
299  * \brief Get the opposite value of a number.
300  * \param self The number.
301  */
302 template<typename T>
303 claw::real_number<T> operator-( const claw::real_number<T>& self )
304 {
305  return claw::real_number<T>(0) - self;
306 } // operator-()
307 
308 /*----------------------------------------------------------------------------*/
309 /**
310  * \brief Subtract a number to an other value.
311  * \param v The other value.
312  * \param self The number.
313  */
314 template<typename T>
315 claw::real_number<T> operator-( T v, const claw::real_number<T>& self )
316 {
317  return claw::real_number<T>(v) - self;
318 } // operator-()
319 
320 /*----------------------------------------------------------------------------*/
321 /**
322  * \brief Output a number in a stream.
323  * \param os The stream in which the value is written.
324  * \param self The number.
325  */
326 template<typename T>
327 std::ostream& operator<<( std::ostream& os, const claw::real_number<T>& self )
328 {
329  return self.output(os);
330 } // operator<<()
331 
332 /*----------------------------------------------------------------------------*/
333 /**
334  * \brief Read a number from a stream.
335  * \param is The stream from which the value is read.
336  * \param self The number.
337  */
338 template<typename T>
339 std::istream& operator>>( std::istream& is, claw::real_number<T>& self )
340 {
341  return is >> self.m_value;
342 } // operator>>()