real_number.tpp

Go to the documentation of this file.
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>>()