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 */
36template<typename T>
37claw::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 */
48template<typename T>
49claw::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 */
60template<typename T>
61claw::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 */
71template<typename T>
72typename 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 */
82template<typename T>
83bool 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 */
102template<typename T>
103bool 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 */
113template<typename T>
114bool 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 */
124template<typename T>
125bool 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 */
135template<typename T>
136bool 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 */
154template<typename T>
155bool 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 */
165template<typename T>
166typename claw::real_number<T>::self_type
167claw::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 */
177template<typename T>
178typename claw::real_number<T>::self_type
179claw::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 */
189template<typename T>
190typename claw::real_number<T>::self_type
191claw::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 */
201template<typename T>
202typename claw::real_number<T>::self_type
203claw::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 */
213template<typename T>
214typename claw::real_number<T>::self_type&
215claw::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 */
227template<typename T>
228typename claw::real_number<T>::self_type&
229claw::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 */
241template<typename T>
242typename claw::real_number<T>::self_type&
243claw::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 */
255template<typename T>
256typename claw::real_number<T>::self_type&
257claw::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 */
269template<typename T>
270std::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 */
279template<typename T>
280template<typename U>
281claw::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 */
291template<typename T>
292claw::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 */
302template<typename T>
303claw::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 */
314template<typename T>
315claw::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 */
326template<typename T>
327std::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 */
338template<typename T>
339std::istream& operator>>( std::istream& is, claw::real_number<T>& self )
340{
341 return is >> self.m_value;
342} // operator>>()