Fix doxygen warnings for ETL sources.

[synfig.git] / ETL / trunk / ETL / _fixed.h

diff --git a/ETL/trunk/ETL/_fixed.h b/ETL/trunk/ETL/_fixed.h
index 642e164..92f781e 100644 (file)
--- a/ETL/trunk/ETL/_fixed.h
+++ b/ETL/trunk/ETL/_fixed.h
@@ -1,7 +1,7 @@
 /*! ========================================================================
 ** Extended Template and Library
 ** Fixed-Point Math Class Implementation
-** $Id: _fixed.h,v 1.1.1.1 2005/01/04 01:31:47 darco Exp $
+** $Id$
 **
 ** Copyright (c) 2002 Robert B. Quattlebaum Jr.
 **
@@ -33,6 +33,10 @@
 
 /* === M A C R O S ========================================================= */
 
+// the "+0.5" code was commented out - maybe to make thing run faster?
+// it can be re-enabled by uncommenting this next line:
+// #define ROUND_TO_NEAREST_INTEGER
+
 #ifndef ETL_FIXED_TYPE
 # define ETL_FIXED_TYPE        int
 #endif
@@ -74,7 +78,7 @@ template<typename T, unsigned int FIXED_BITS> _ETL::fixed_base<T,FIXED_BITS> log
 template<typename T, unsigned int FIXED_BITS> _ETL::fixed_base<T,FIXED_BITS> log10(const _ETL::fixed_base<T,FIXED_BITS>&);
 template<typename T, unsigned int FIXED_BITS> _ETL::fixed_base<T,FIXED_BITS> pow(const _ETL::fixed_base<T,FIXED_BITS>&, int);
 template<typename T, unsigned int FIXED_BITS> _ETL::fixed_base<T,FIXED_BITS> pow(const _ETL::fixed_base<T,FIXED_BITS>&, const T&);
-template<typename T, unsigned int FIXED_BITS> _ETL::fixed_base<T,FIXED_BITS> pow(const _ETL::fixed_base<T,FIXED_BITS>&, 
+template<typename T, unsigned int FIXED_BITS> _ETL::fixed_base<T,FIXED_BITS> pow(const _ETL::fixed_base<T,FIXED_BITS>&,
                                        const _ETL::fixed_base<T,FIXED_BITS>&);
 template<typename T, unsigned int FIXED_BITS> _ETL::fixed_base<T,FIXED_BITS> pow(const _ETL::fixed_base<T,FIXED_BITS>&, const _ETL::fixed_base<T,FIXED_BITS>&);
 template<typename T, unsigned int FIXED_BITS> _ETL::fixed_base<T,FIXED_BITS> sin(const _ETL::fixed_base<T,FIXED_BITS>&);
@@ -98,7 +102,7 @@ public:
        typedef T value_type;
 private:
        T _data;
-       
+
        typedef fixed_base<T,FIXED_BITS> _fixed;
        typedef fixed_base<T,FIXED_BITS> self_type;
 
@@ -119,7 +123,7 @@ public:
        fixed_base(const _fixed &x)ETL_ATTRIB_INLINE;
        fixed_base(value_type x,raw)ETL_ATTRIB_INLINE;
 
-       T &data() ETL_ATTRIB_PURE ETL_ATTRIB_INLINE;    
+       T &data() ETL_ATTRIB_PURE ETL_ATTRIB_INLINE;
        const T &data()const ETL_ATTRIB_PURE ETL_ATTRIB_INLINE;
 
        const _fixed& operator+=(const _fixed &rhs) ETL_ATTRIB_INLINE;
@@ -144,7 +148,7 @@ public:
        _fixed operator/(const int &rhs)const ETL_ATTRIB_INLINE;
        _fixed operator*(const float &rhs)const ETL_ATTRIB_INLINE;
        _fixed operator*(const double &rhs)const ETL_ATTRIB_INLINE;
-       
+
        // Negation Operator
        _fixed operator-()const ETL_ATTRIB_INLINE;
 
@@ -158,7 +162,7 @@ public:
        _fixed floor()const;
        _fixed ceil()const;
        _fixed round()const;
-       
+
        bool operator==(const _fixed &rhs)const { return data()==rhs.data(); }
        bool operator!=(const _fixed &rhs)const { return data()!=rhs.data(); }
        bool operator<(const _fixed &rhs)const { return data()<rhs.data(); }
@@ -170,23 +174,32 @@ public:
 
 template <class T,unsigned int FIXED_BITS>
 fixed_base<T,FIXED_BITS>::fixed_base()
-{}     
+{}
 
 template <class T,unsigned int FIXED_BITS>
 fixed_base<T,FIXED_BITS>::fixed_base(const _fixed &x):_data(x._data)
 {}
 
 template <class T,unsigned int FIXED_BITS>
-fixed_base<T,FIXED_BITS>::fixed_base(const float &f):_data(static_cast<value_type>(f*_ONE()/*+0.5f*/))
-{}
+fixed_base<T,FIXED_BITS>::fixed_base(const float &f):_data(static_cast<value_type>(f*_ONE()
+#ifdef ROUND_TO_NEAREST_INTEGER
+                                                                                                                                                                  +0.5f
+#endif
+                                                                       )) {}
 
 template <class T,unsigned int FIXED_BITS>
-fixed_base<T,FIXED_BITS>::fixed_base(const double &f):_data(static_cast<value_type>(f*_ONE()/*+0.5*/))
-{}
+fixed_base<T,FIXED_BITS>::fixed_base(const double &f):_data(static_cast<value_type>(f*_ONE()
+#ifdef ROUND_TO_NEAREST_INTEGER
+                                                                                                                                                                       +0.5
+#endif
+                                                                       )) {}
 
 template <class T,unsigned int FIXED_BITS>
-fixed_base<T,FIXED_BITS>::fixed_base(const long double &f):_data(static_cast<value_type>(f*_ONE()/*+0.5*/))
-{}
+fixed_base<T,FIXED_BITS>::fixed_base(const long double &f):_data(static_cast<value_type>(f*_ONE()
+#ifdef ROUND_TO_NEAREST_INTEGER
+                                                                                                                                                                                +0.5
+#endif
+                                                                       )) {}
 
 template <class T,unsigned int FIXED_BITS>
 fixed_base<T,FIXED_BITS>::fixed_base(const int &i):_data(i<<FIXED_BITS)
@@ -197,55 +210,55 @@ fixed_base<T,FIXED_BITS>::fixed_base(value_type x,raw):_data(x) { }
 
 template <class T,unsigned int FIXED_BITS>
 fixed_base<T,FIXED_BITS>::fixed_base(const int &n,const int &d):_data((n<<FIXED_BITS)/d) { }
-       
-       
+
+
 
 template <class T,unsigned int FIXED_BITS> inline bool
-fixed_base<T,FIXED_BITS>::_TYPE_SMALLER_THAN_INT() 
+fixed_base<T,FIXED_BITS>::_TYPE_SMALLER_THAN_INT()
 {
        return sizeof(T)<sizeof(int);
-}      
+}
 
 template <class T,unsigned int FIXED_BITS> inline bool
-fixed_base<T,FIXED_BITS>::_USING_ALL_BITS() 
+fixed_base<T,FIXED_BITS>::_USING_ALL_BITS()
 {
        return sizeof(T)*8==FIXED_BITS;
 }
 
 template <class T,unsigned int FIXED_BITS> inline T
-fixed_base<T,FIXED_BITS>::_ONE() 
+fixed_base<T,FIXED_BITS>::_ONE()
 {
        return static_cast<T>((_USING_ALL_BITS()?~T(0):1<<FIXED_BITS));
 }
 
 template <class T,unsigned int FIXED_BITS> inline T
-fixed_base<T,FIXED_BITS>::_F_MASK() 
+fixed_base<T,FIXED_BITS>::_F_MASK()
 {
        return static_cast<T>(_USING_ALL_BITS()?~T(0):_ONE()-1);
 }
 
 template <class T,unsigned int FIXED_BITS> inline float
-fixed_base<T,FIXED_BITS>::_EPSILON() 
+fixed_base<T,FIXED_BITS>::_EPSILON()
 {
        return 1.0f/((float)_ONE()*2);
 }
 
 
 template <class T,unsigned int FIXED_BITS>T &
-fixed_base<T,FIXED_BITS>::data() 
+fixed_base<T,FIXED_BITS>::data()
 {
        return _data;
 }
 
 template <class T,unsigned int FIXED_BITS>const T &
-fixed_base<T,FIXED_BITS>::data()const 
+fixed_base<T,FIXED_BITS>::data()const
 {
        return _data;
 }
 
 //! fixed+=fixed
 template <class T,unsigned int FIXED_BITS>const fixed_base<T,FIXED_BITS> &
-fixed_base<T,FIXED_BITS>::operator+=(const fixed_base<T,FIXED_BITS> &rhs) 
+fixed_base<T,FIXED_BITS>::operator+=(const _fixed &rhs)
 {
        _data+=rhs._data;
        return *this;
@@ -253,7 +266,7 @@ fixed_base<T,FIXED_BITS>::operator+=(const fixed_base<T,FIXED_BITS> &rhs)
 
 //! fixed-=fixed
 template <class T,unsigned int FIXED_BITS>const fixed_base<T,FIXED_BITS> &
-fixed_base<T,FIXED_BITS>::operator-=(const fixed_base<T,FIXED_BITS> &rhs) 
+fixed_base<T,FIXED_BITS>::operator-=(const _fixed &rhs)
 {
        _data-=rhs._data;
        return *this;
@@ -261,7 +274,7 @@ fixed_base<T,FIXED_BITS>::operator-=(const fixed_base<T,FIXED_BITS> &rhs)
 
 //! fixed*=fixed
 template <class T,unsigned int FIXED_BITS>const fixed_base<T,FIXED_BITS> &
-fixed_base<T,FIXED_BITS>::operator*=(const fixed_base<T,FIXED_BITS> &rhs) 
+fixed_base<T,FIXED_BITS>::operator*=(const _fixed &rhs)
 {
        if(_TYPE_SMALLER_THAN_INT())
                _data=static_cast<T>((int)_data*(int)rhs._data>>FIXED_BITS);
@@ -270,13 +283,13 @@ fixed_base<T,FIXED_BITS>::operator*=(const fixed_base<T,FIXED_BITS> &rhs)
                _data*=rhs._data;
                _data>>=FIXED_BITS;
        }
-               
+
        return *this;
 }
 
 //! fixed/=fixed
 template <class T,unsigned int FIXED_BITS>const fixed_base<T,FIXED_BITS> &
-fixed_base<T,FIXED_BITS>::operator/=(const fixed_base<T,FIXED_BITS> &rhs) 
+fixed_base<T,FIXED_BITS>::operator/=(const _fixed &rhs)
 {
        if(_TYPE_SMALLER_THAN_INT())
                _data=static_cast<T>((int)_data/(int)rhs._data<<FIXED_BITS);
@@ -289,27 +302,27 @@ fixed_base<T,FIXED_BITS>::operator/=(const fixed_base<T,FIXED_BITS> &rhs)
 }
 
 template <class T,unsigned int FIXED_BITS> template<typename U> const fixed_base<T,FIXED_BITS> &
-fixed_base<T,FIXED_BITS>::operator*=(const U &rhs) 
+fixed_base<T,FIXED_BITS>::operator*=(const U &rhs)
 {
        return operator*=(fixed_base<T,FIXED_BITS>(rhs));
 }
 
 template <class T,unsigned int FIXED_BITS> template<typename U> const fixed_base<T,FIXED_BITS> &
-fixed_base<T,FIXED_BITS>::operator/=(const U &rhs) 
+fixed_base<T,FIXED_BITS>::operator/=(const U &rhs)
 {
        return operator/=(fixed_base<T,FIXED_BITS>(rhs));
 }
 
 //! fixed*=int
 template <class T,unsigned int FIXED_BITS>const fixed_base<T,FIXED_BITS> &
-fixed_base<T,FIXED_BITS>::operator*=(const int &rhs) 
+fixed_base<T,FIXED_BITS>::operator*=(const int &rhs)
 {
        _data*=rhs; return *this;
 }
 
 //! fixed/=int
 template <class T,unsigned int FIXED_BITS>const fixed_base<T,FIXED_BITS> &
-fixed_base<T,FIXED_BITS>::operator/=(const int &rhs) 
+fixed_base<T,FIXED_BITS>::operator/=(const int &rhs)
 {
        _data/=rhs; return *this;
 }
@@ -322,7 +335,7 @@ fixed_base<T,FIXED_BITS>::operator/=(const int &rhs)
 
 //! fixed + fixed
 template <class T,unsigned int FIXED_BITS>fixed_base<T,FIXED_BITS>
-fixed_base<T,FIXED_BITS>::operator+(const fixed_base<T,FIXED_BITS> &rhs)const 
+fixed_base<T,FIXED_BITS>::operator+(const _fixed &rhs)const
 {
        _fixed ret;
        ret._data=_data+rhs._data;
@@ -331,7 +344,7 @@ fixed_base<T,FIXED_BITS>::operator+(const fixed_base<T,FIXED_BITS> &rhs)const
 
 //! fixed - fixed
 template <class T,unsigned int FIXED_BITS>fixed_base<T,FIXED_BITS>
-fixed_base<T,FIXED_BITS>::operator-(const fixed_base<T,FIXED_BITS> &rhs)const 
+fixed_base<T,FIXED_BITS>::operator-(const _fixed &rhs)const
 {
        _fixed ret;
        ret._data=_data-rhs._data;
@@ -340,7 +353,7 @@ fixed_base<T,FIXED_BITS>::operator-(const fixed_base<T,FIXED_BITS> &rhs)const
 
 //! fixed * fixed
 template <class T,unsigned int FIXED_BITS>fixed_base<T,FIXED_BITS>
-fixed_base<T,FIXED_BITS>::operator*(const fixed_base<T,FIXED_BITS> &rhs)const 
+fixed_base<T,FIXED_BITS>::operator*(const _fixed &rhs)const
 {
        _fixed ret;
        ret._data=((_data*rhs._data)>>FIXED_BITS);
@@ -350,7 +363,7 @@ fixed_base<T,FIXED_BITS>::operator*(const fixed_base<T,FIXED_BITS> &rhs)const
 
 //! fixed / fixed
 template <class T,unsigned int FIXED_BITS>fixed_base<T,FIXED_BITS>
-fixed_base<T,FIXED_BITS>::operator/(const fixed_base<T,FIXED_BITS> &rhs)const 
+fixed_base<T,FIXED_BITS>::operator/(const _fixed &rhs)const
 {
        _fixed ret;
        ret._data=((_data/rhs._data)<<FIXED_BITS);
@@ -388,7 +401,7 @@ fixed_base<T,FIXED_BITS>::operator/(const U &rhs) const
 
 //! fixed * int
 template <class T,unsigned int FIXED_BITS>fixed_base<T,FIXED_BITS>
-fixed_base<T,FIXED_BITS>::operator*(const int &rhs)const 
+fixed_base<T,FIXED_BITS>::operator*(const int &rhs)const
 {
        _fixed ret;
        ret._data=_data*rhs;
@@ -398,14 +411,14 @@ fixed_base<T,FIXED_BITS>::operator*(const int &rhs)const
 
 //! fixed * float
 template <class T,unsigned int FIXED_BITS>fixed_base<T,FIXED_BITS>
-fixed_base<T,FIXED_BITS>::operator*(const float &rhs)const 
+fixed_base<T,FIXED_BITS>::operator*(const float &rhs)const
 {
     return (*this)*_fixed(rhs);
 }
 
 //! fixed * double
 template <class T,unsigned int FIXED_BITS>fixed_base<T,FIXED_BITS>
-fixed_base<T,FIXED_BITS>::operator*(const double &rhs)const 
+fixed_base<T,FIXED_BITS>::operator*(const double &rhs)const
 {
     return (*this)*_fixed(rhs);
 }
@@ -413,7 +426,7 @@ fixed_base<T,FIXED_BITS>::operator*(const double &rhs)const
 
 //! fixed / int
 template <class T,unsigned int FIXED_BITS>fixed_base<T,FIXED_BITS>
-fixed_base<T,FIXED_BITS>::operator/(const int &rhs)const 
+fixed_base<T,FIXED_BITS>::operator/(const int &rhs)const
 {
        _fixed ret;
        ret._data=_data/rhs;
@@ -423,14 +436,14 @@ fixed_base<T,FIXED_BITS>::operator/(const int &rhs)const
 
 //! float * fixed
 template <class T,unsigned int FIXED_BITS>fixed_base<T,FIXED_BITS>
-operator*(const float& lhs, const fixed_base<T,FIXED_BITS> &rhs) 
+operator*(const float& lhs, const fixed_base<T,FIXED_BITS> &rhs)
 {
     return rhs*lhs;
 }
 
 //! double * fixed
 template <class T,unsigned int FIXED_BITS>fixed_base<T,FIXED_BITS>
-operator*(const double& lhs, const fixed_base<T,FIXED_BITS> &rhs) 
+operator*(const double& lhs, const fixed_base<T,FIXED_BITS> &rhs)
 {
     return rhs*lhs;
 }
@@ -442,38 +455,38 @@ operator*(const double& lhs, const fixed_base<T,FIXED_BITS> &rhs)
 
 // Negation Operator
 template <class T,unsigned int FIXED_BITS>fixed_base<T,FIXED_BITS>
-fixed_base<T,FIXED_BITS>::operator-()const 
+fixed_base<T,FIXED_BITS>::operator-()const
 {
        _fixed ret; ret._data=-_data; return ret;
 }
 
 // Casting Operators
 template <class T,unsigned int FIXED_BITS>
-fixed_base<T,FIXED_BITS>::operator float()const 
+fixed_base<T,FIXED_BITS>::operator float()const
 {
        return static_cast<float>(_data)/static_cast<float>(_ONE());
-}      
+}
 
 template <class T,unsigned int FIXED_BITS>
-fixed_base<T,FIXED_BITS>::operator double()const 
+fixed_base<T,FIXED_BITS>::operator double()const
 {
        return static_cast<double>(_data)/static_cast<double>(_ONE());
-}      
+}
 
 template <class T,unsigned int FIXED_BITS>
-fixed_base<T,FIXED_BITS>::operator long double()const 
+fixed_base<T,FIXED_BITS>::operator long double()const
 {
        return static_cast<long double>(_data)/static_cast<long double>(_ONE());
-}      
+}
 
 template <class T,unsigned int FIXED_BITS>
-fixed_base<T,FIXED_BITS>::operator int()const 
+fixed_base<T,FIXED_BITS>::operator int()const
 {
        return static_cast<int>(_data>>FIXED_BITS);
 }
 
 template <class T,unsigned int FIXED_BITS>
-fixed_base<T,FIXED_BITS>::operator bool()const 
+fixed_base<T,FIXED_BITS>::operator bool()const
 {
        return static_cast<bool>(_data);
 }