CLAW Library (a C++ Library Absolutely Wonderful) 1.5.5
|
00001 /* 00002 CLAW - a C++ Library Absolutely Wonderful 00003 00004 CLAW is a free library without any particular aim but being useful to 00005 anyone. 00006 00007 Copyright (C) 2005-2010 Julien Jorge 00008 00009 This library is free software; you can redistribute it and/or 00010 modify it under the terms of the GNU Lesser General Public 00011 License as published by the Free Software Foundation; either 00012 version 2.1 of the License, or (at your option) any later version. 00013 00014 This library is distributed in the hope that it will be useful, 00015 but WITHOUT ANY WARRANTY; without even the implied warranty of 00016 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00017 Lesser General Public License for more details. 00018 00019 You should have received a copy of the GNU Lesser General Public 00020 License along with this library; if not, write to the Free Software 00021 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 00022 00023 contact: julien_jorge@yahoo.fr 00024 */ 00030 #include <cmath> 00031 00032 /*----------------------------------------------------------------------------*/ 00036 template<typename T> 00037 claw::real_number<T>::real_number() 00038 : m_value(0), m_epsilon( make_epsilon<value_type>::value(m_value) ) 00039 { 00040 00041 } // real_number::real_number() 00042 00043 /*----------------------------------------------------------------------------*/ 00048 template<typename T> 00049 claw::real_number<T>::real_number( const value_type& v ) 00050 : m_value(v), m_epsilon( make_epsilon<T>::value(m_value) ) 00051 { 00052 00053 } // real_number::real_number() 00054 00055 /*----------------------------------------------------------------------------*/ 00060 template<typename T> 00061 claw::real_number<T>::real_number( const self_type& that ) 00062 : m_value(that.m_value), m_epsilon(that.m_epsilon) 00063 { 00064 00065 } // real_number::real_number() 00066 00067 /*----------------------------------------------------------------------------*/ 00071 template<typename T> 00072 typename claw::real_number<T>::self_type claw::real_number<T>::abs() const 00073 { 00074 return self_type( std::abs(m_value) ); 00075 } // real_number::abs() 00076 00077 /*----------------------------------------------------------------------------*/ 00082 template<typename T> 00083 bool claw::real_number<T>::operator<( const self_type& that ) const 00084 { 00085 if ( that.m_value == std::numeric_limits<value_type>::infinity() ) 00086 return m_value != std::numeric_limits<value_type>::infinity(); 00087 else if ( that.m_value == -std::numeric_limits<value_type>::infinity() ) 00088 return false; 00089 else if ( m_value == std::numeric_limits<value_type>::infinity() ) 00090 return false; 00091 else if ( m_value == -std::numeric_limits<value_type>::infinity() ) 00092 return that.m_value != -std::numeric_limits<value_type>::infinity(); 00093 else 00094 return m_value < (that.m_value - std::max(m_epsilon, that.m_epsilon)); 00095 } // real_number::operator<() 00096 00097 /*----------------------------------------------------------------------------*/ 00102 template<typename T> 00103 bool claw::real_number<T>::operator<=( const self_type& that ) const 00104 { 00105 return !(that < *this); 00106 } // real_number::operator<=() 00107 00108 /*----------------------------------------------------------------------------*/ 00113 template<typename T> 00114 bool claw::real_number<T>::operator>( const self_type& that ) const 00115 { 00116 return that < *this; 00117 } // real_number::operator>() 00118 00119 /*----------------------------------------------------------------------------*/ 00124 template<typename T> 00125 bool claw::real_number<T>::operator>=( const self_type& that ) const 00126 { 00127 return that <= *this; 00128 } // real_number::operator>=() 00129 00130 /*----------------------------------------------------------------------------*/ 00135 template<typename T> 00136 bool claw::real_number<T>::operator==( const self_type& that ) const 00137 { 00138 if ( that.m_value == std::numeric_limits<value_type>::infinity() ) 00139 return m_value == std::numeric_limits<value_type>::infinity(); 00140 else if ( that.m_value == -std::numeric_limits<value_type>::infinity() ) 00141 return m_value == -std::numeric_limits<value_type>::infinity(); 00142 else if ( m_value == that.m_value ) 00143 return true; 00144 else 00145 return std::abs(m_value - that.m_value) 00146 <= std::max(m_epsilon, that.m_epsilon); 00147 } // real_number::operator==() 00148 00149 /*----------------------------------------------------------------------------*/ 00154 template<typename T> 00155 bool claw::real_number<T>::operator!=( const self_type& that ) const 00156 { 00157 return !((*this) == that); 00158 } // real_number::operator!=() 00159 00160 /*----------------------------------------------------------------------------*/ 00165 template<typename T> 00166 typename claw::real_number<T>::self_type 00167 claw::real_number<T>::operator+( const self_type& that ) const 00168 { 00169 return self_type(m_value + that.m_value); 00170 } // real_number::operator+() 00171 00172 /*----------------------------------------------------------------------------*/ 00177 template<typename T> 00178 typename claw::real_number<T>::self_type 00179 claw::real_number<T>::operator-( const self_type& that ) const 00180 { 00181 return self_type(m_value - that.m_value); 00182 } // real_number::operator-() 00183 00184 /*----------------------------------------------------------------------------*/ 00189 template<typename T> 00190 typename claw::real_number<T>::self_type 00191 claw::real_number<T>::operator*( const self_type& that ) const 00192 { 00193 return self_type(m_value * that.m_value); 00194 } // real_number::operator*() 00195 00196 /*----------------------------------------------------------------------------*/ 00201 template<typename T> 00202 typename claw::real_number<T>::self_type 00203 claw::real_number<T>::operator/( const self_type& that ) const 00204 { 00205 return self_type(m_value / that.m_value); 00206 } // real_number::operator/() 00207 00208 /*----------------------------------------------------------------------------*/ 00213 template<typename T> 00214 typename claw::real_number<T>::self_type& 00215 claw::real_number<T>::operator+=( const self_type& that ) 00216 { 00217 m_value += that.m_value; 00218 m_epsilon = make_epsilon<value_type>::value(m_value); 00219 return *this; 00220 } // real_number::operator+=() 00221 00222 /*----------------------------------------------------------------------------*/ 00227 template<typename T> 00228 typename claw::real_number<T>::self_type& 00229 claw::real_number<T>::operator-=( const self_type& that ) 00230 { 00231 m_value -= that.m_value; 00232 m_epsilon = make_epsilon<value_type>::value(m_value); 00233 return *this; 00234 } // real_number::operator-=() 00235 00236 /*----------------------------------------------------------------------------*/ 00241 template<typename T> 00242 typename claw::real_number<T>::self_type& 00243 claw::real_number<T>::operator*=( const self_type& that ) 00244 { 00245 m_value *= that.m_value; 00246 m_epsilon = make_epsilon<value_type>::value(m_value); 00247 return *this; 00248 } // real_number::operator*=() 00249 00250 /*----------------------------------------------------------------------------*/ 00255 template<typename T> 00256 typename claw::real_number<T>::self_type& 00257 claw::real_number<T>::operator/=( const self_type& that ) 00258 { 00259 m_value /= that.m_value; 00260 m_epsilon = make_epsilon<value_type>::value(m_value); 00261 return *this; 00262 } // real_number::operator/=() 00263 00264 /*----------------------------------------------------------------------------*/ 00269 template<typename T> 00270 std::ostream& claw::real_number<T>::output( std::ostream& os ) const 00271 { 00272 return os << m_value; 00273 } // real_number::output() 00274 00275 /*----------------------------------------------------------------------------*/ 00279 template<typename T> 00280 template<typename U> 00281 claw::real_number<T>::operator U() const 00282 { 00283 return (U)m_value; 00284 } // real_number::operator U() 00285 00286 /*----------------------------------------------------------------------------*/ 00291 template<typename T> 00292 claw::real_number<T> std::abs( const claw::real_number<T>& v ) 00293 { 00294 return v.abs(); 00295 } // abs() 00296 00297 /*----------------------------------------------------------------------------*/ 00302 template<typename T> 00303 claw::real_number<T> operator-( const claw::real_number<T>& self ) 00304 { 00305 return claw::real_number<T>(0) - self; 00306 } // operator-() 00307 00308 /*----------------------------------------------------------------------------*/ 00314 template<typename T> 00315 claw::real_number<T> operator-( T v, const claw::real_number<T>& self ) 00316 { 00317 return claw::real_number<T>(v) - self; 00318 } // operator-() 00319 00320 /*----------------------------------------------------------------------------*/ 00326 template<typename T> 00327 std::ostream& operator<<( std::ostream& os, const claw::real_number<T>& self ) 00328 { 00329 return self.output(os); 00330 } // operator<<() 00331 00332 /*----------------------------------------------------------------------------*/ 00338 template<typename T> 00339 std::istream& operator>>( std::istream& is, claw::real_number<T>& self ) 00340 { 00341 return is >> self.m_value; 00342 } // operator>>()