ETL/tags/ETL_0_04_08/ETL/ETL/_fixed.h

   1 /*! ========================================================================
   2 ** Extended Template and Library
   3 ** Fixed-Point Math Class Implementation
   4 ** $Id: _fixed.h,v 1.1.1.1 2005/01/04 01:31:47 darco Exp $
   5 **
   6 ** Copyright (c) 2002 Robert B. Quattlebaum Jr.
   7 **
   8 ** This package is free software; you can redistribute it and/or
   9 ** modify it under the terms of the GNU General Public License as
  10 ** published by the Free Software Foundation; either version 2 of
  11 ** the License, or (at your option) any later version.
  12 **
  13 ** This package is distributed in the hope that it will be useful,
  14 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16 ** General Public License for more details.
  17 **
  18 ** === N O T E S ===========================================================
  19 **
  20 ** This is an internal header file, included by other ETL headers.
  21 ** You should not attempt to use it directly.
  22 **
  23 ** ========================================================================= */
  24
  25 /* === S T A R T =========================================================== */
  26
  27 #ifndef __ETL__FIXED_H
  28 #define __ETL__FIXED_H
  29
  30 /* === H E A D E R S ======================================================= */
  31
  32 #include <cmath>
  33
  34 /* === M A C R O S ========================================================= */
  35
  36 #ifndef ETL_FIXED_TYPE
  37 # define ETL_FIXED_TYPE int
  38 #endif
  39
  40 #ifndef ETL_FIXED_BITS
  41 #define ETL_FIXED_BITS  12
  42 #endif
  43
  44 #ifndef ETL_FIXED_EPSILON
  45 #define ETL_FIXED_EPSILON               _EPSILON()
  46 #endif
  47
  48 #ifdef __GNUC___
  49 #define ETL_ATTRIB_CONST        __attribute__ ((const))
  50 #define ETL_ATTRIB_PURE         __attribute__ ((pure))
  51 #define ETL_ATTRIB_INLINE       __attribute__ ((always_inline))
  52 #else
  53 #define ETL_ATTRIB_CONST
  54 #define ETL_ATTRIB_PURE
  55 #define ETL_ATTRIB_INLINE
  56 #endif
  57
  58 /* === C L A S S E S & S T R U C T S ======================================= */
  59
  60 _ETL_BEGIN_NAMESPACE
  61
  62 // Forward declarations
  63 template<typename T, unsigned int FIXED_BITS> class fixed_base;
  64 //template<> class fixed_base<char>;
  65
  66 _ETL_END_NAMESPACE
  67
  68 _STD_BEGIN_NAMESPACE
  69 template<typename T, unsigned int FIXED_BITS> _ETL::fixed_base<T,FIXED_BITS> abs(const _ETL::fixed_base<T,FIXED_BITS>&);
  70 template<typename T, unsigned int FIXED_BITS> _ETL::fixed_base<T,FIXED_BITS> cos(const _ETL::fixed_base<T,FIXED_BITS>&);
  71 template<typename T, unsigned int FIXED_BITS> _ETL::fixed_base<T,FIXED_BITS> cosh(const _ETL::fixed_base<T,FIXED_BITS>&);
  72 template<typename T, unsigned int FIXED_BITS> _ETL::fixed_base<T,FIXED_BITS> exp(const _ETL::fixed_base<T,FIXED_BITS>&);
  73 template<typename T, unsigned int FIXED_BITS> _ETL::fixed_base<T,FIXED_BITS> log(const _ETL::fixed_base<T,FIXED_BITS>&);
  74 template<typename T, unsigned int FIXED_BITS> _ETL::fixed_base<T,FIXED_BITS> log10(const _ETL::fixed_base<T,FIXED_BITS>&);
  75 template<typename T, unsigned int FIXED_BITS> _ETL::fixed_base<T,FIXED_BITS> pow(const _ETL::fixed_base<T,FIXED_BITS>&, int);
  76 template<typename T, unsigned int FIXED_BITS> _ETL::fixed_base<T,FIXED_BITS> pow(const _ETL::fixed_base<T,FIXED_BITS>&, const T&);
  77 template<typename T, unsigned int FIXED_BITS> _ETL::fixed_base<T,FIXED_BITS> pow(const _ETL::fixed_base<T,FIXED_BITS>&,
  78                                         const _ETL::fixed_base<T,FIXED_BITS>&);
  79 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>&);
  80 template<typename T, unsigned int FIXED_BITS> _ETL::fixed_base<T,FIXED_BITS> sin(const _ETL::fixed_base<T,FIXED_BITS>&);
  81 template<typename T, unsigned int FIXED_BITS> _ETL::fixed_base<T,FIXED_BITS> sinh(const _ETL::fixed_base<T,FIXED_BITS>&);
  82 template<typename T, unsigned int FIXED_BITS> _ETL::fixed_base<T,FIXED_BITS> sqrt(const _ETL::fixed_base<T,FIXED_BITS>&);
  83 template<typename T, unsigned int FIXED_BITS> _ETL::fixed_base<T,FIXED_BITS> tan(const _ETL::fixed_base<T,FIXED_BITS>&);
  84 template<typename T, unsigned int FIXED_BITS> _ETL::fixed_base<T,FIXED_BITS> tanh(const _ETL::fixed_base<T,FIXED_BITS>&);
  85 _STD_END_NAMESPACE
  86 _ETL_BEGIN_NAMESPACE
  87
  88 /*! ========================================================================
  89 ** \class       fixed_base
  90 ** \brief       Fixed-point template base class
  91 **
  92 ** A more detailed description needs to be written.
  93 */
  94 template <class T,unsigned int FIXED_BITS>
  95 class fixed_base
  96 {
  97 public:
  98         typedef T value_type;
  99 private:
 100         T _data;
 101
 102         typedef fixed_base<T,FIXED_BITS> _fixed;
 103         typedef fixed_base<T,FIXED_BITS> self_type;
 104
 105         inline static bool _TYPE_SMALLER_THAN_INT() ETL_ATTRIB_CONST ETL_ATTRIB_INLINE;
 106         inline static bool _USING_ALL_BITS() ETL_ATTRIB_CONST ETL_ATTRIB_INLINE;
 107         inline static value_type _ONE() ETL_ATTRIB_CONST ETL_ATTRIB_INLINE;
 108         inline static value_type _F_MASK() ETL_ATTRIB_CONST ETL_ATTRIB_INLINE;
 109         inline static float _EPSILON() ETL_ATTRIB_CONST ETL_ATTRIB_INLINE;
 110
 111         class raw { };
 112 public:
 113         fixed_base()ETL_ATTRIB_INLINE;
 114         fixed_base(const float &f)ETL_ATTRIB_INLINE;
 115         fixed_base(const double &f)ETL_ATTRIB_INLINE;
 116         fixed_base(const long double &f)ETL_ATTRIB_INLINE;
 117         fixed_base(const int &i)ETL_ATTRIB_INLINE;
 118         fixed_base(const int &n,const int &d)ETL_ATTRIB_INLINE; //!< Fraction constructor
 119         fixed_base(const _fixed &x)ETL_ATTRIB_INLINE;
 120         fixed_base(value_type x,raw)ETL_ATTRIB_INLINE;
 121
 122         T &data() ETL_ATTRIB_PURE ETL_ATTRIB_INLINE;
 123         const T &data()const ETL_ATTRIB_PURE ETL_ATTRIB_INLINE;
 124
 125         const _fixed& operator+=(const _fixed &rhs) ETL_ATTRIB_INLINE;
 126         const _fixed& operator-=(const _fixed &rhs) ETL_ATTRIB_INLINE;
 127         template<typename U> const _fixed& operator*=(const U &rhs) ETL_ATTRIB_INLINE;
 128         template<typename U> const _fixed& operator/=(const U &rhs) ETL_ATTRIB_INLINE;
 129         const _fixed& operator*=(const _fixed &rhs) ETL_ATTRIB_INLINE;
 130         const _fixed& operator/=(const _fixed &rhs) ETL_ATTRIB_INLINE;
 131         const _fixed& operator*=(const int &rhs) ETL_ATTRIB_INLINE;
 132         const _fixed& operator/=(const int &rhs) ETL_ATTRIB_INLINE;
 133
 134
 135         template<typename U> _fixed operator+(const U &rhs)const ETL_ATTRIB_INLINE;
 136         template<typename U> _fixed operator-(const U &rhs)const ETL_ATTRIB_INLINE;
 137         template<typename U> _fixed operator*(const U &rhs)const ETL_ATTRIB_INLINE;
 138         template<typename U> _fixed operator/(const U &rhs)const ETL_ATTRIB_INLINE;
 139         _fixed operator+(const _fixed &rhs)const ETL_ATTRIB_INLINE;
 140         _fixed operator-(const _fixed &rhs)const ETL_ATTRIB_INLINE;
 141         _fixed operator*(const _fixed &rhs)const ETL_ATTRIB_INLINE;
 142         _fixed operator/(const _fixed &rhs)const ETL_ATTRIB_INLINE;
 143         _fixed operator*(const int &rhs)const ETL_ATTRIB_INLINE;
 144         _fixed operator/(const int &rhs)const ETL_ATTRIB_INLINE;
 145         _fixed operator*(const float &rhs)const ETL_ATTRIB_INLINE;
 146         _fixed operator*(const double &rhs)const ETL_ATTRIB_INLINE;
 147
 148         // Negation Operator
 149         _fixed operator-()const ETL_ATTRIB_INLINE;
 150
 151         // Casting Operators
 152         inline operator float()const ETL_ATTRIB_INLINE;
 153         inline operator double()const ETL_ATTRIB_INLINE;
 154         inline operator long double()const ETL_ATTRIB_INLINE;
 155         inline operator int()const ETL_ATTRIB_INLINE;
 156         inline operator bool()const ETL_ATTRIB_INLINE;
 157
 158         _fixed floor()const;
 159         _fixed ceil()const;
 160         _fixed round()const;
 161
 162         bool operator==(const _fixed &rhs)const { return data()==rhs.data(); }
 163         bool operator!=(const _fixed &rhs)const { return data()!=rhs.data(); }
 164         bool operator<(const _fixed &rhs)const { return data()<rhs.data(); }
 165         bool operator>(const _fixed &rhs)const { return data()>rhs.data(); }
 166         bool operator<=(const _fixed &rhs)const { return data()<=rhs.data(); }
 167         bool operator>=(const _fixed &rhs)const { return data()>=rhs.data(); }
 168 };
 169
 170
 171 template <class T,unsigned int FIXED_BITS>
 172 fixed_base<T,FIXED_BITS>::fixed_base()
 173 {}
 174
 175 template <class T,unsigned int FIXED_BITS>
 176 fixed_base<T,FIXED_BITS>::fixed_base(const _fixed &x):_data(x._data)
 177 {}
 178
 179 template <class T,unsigned int FIXED_BITS>
 180 fixed_base<T,FIXED_BITS>::fixed_base(const float &f):_data(static_cast<value_type>(f*_ONE()/*+0.5f*/))
 181 {}
 182
 183 template <class T,unsigned int FIXED_BITS>
 184 fixed_base<T,FIXED_BITS>::fixed_base(const double &f):_data(static_cast<value_type>(f*_ONE()/*+0.5*/))
 185 {}
 186
 187 template <class T,unsigned int FIXED_BITS>
 188 fixed_base<T,FIXED_BITS>::fixed_base(const long double &f):_data(static_cast<value_type>(f*_ONE()/*+0.5*/))
 189 {}
 190
 191 template <class T,unsigned int FIXED_BITS>
 192 fixed_base<T,FIXED_BITS>::fixed_base(const int &i):_data(i<<FIXED_BITS)
 193 {}
 194
 195 template <class T,unsigned int FIXED_BITS>
 196 fixed_base<T,FIXED_BITS>::fixed_base(value_type x,raw):_data(x) { }
 197
 198 template <class T,unsigned int FIXED_BITS>
 199 fixed_base<T,FIXED_BITS>::fixed_base(const int &n,const int &d):_data((n<<FIXED_BITS)/d) { }
 200
 201
 202
 203 template <class T,unsigned int FIXED_BITS> inline bool
 204 fixed_base<T,FIXED_BITS>::_TYPE_SMALLER_THAN_INT()
 205 {
 206         return sizeof(T)<sizeof(int);
 207 }
 208
 209 template <class T,unsigned int FIXED_BITS> inline bool
 210 fixed_base<T,FIXED_BITS>::_USING_ALL_BITS()
 211 {
 212         return sizeof(T)*8==FIXED_BITS;
 213 }
 214
 215 template <class T,unsigned int FIXED_BITS> inline T
 216 fixed_base<T,FIXED_BITS>::_ONE()
 217 {
 218         return static_cast<T>((_USING_ALL_BITS()?~T(0):1<<FIXED_BITS));
 219 }
 220
 221 template <class T,unsigned int FIXED_BITS> inline T
 222 fixed_base<T,FIXED_BITS>::_F_MASK()
 223 {
 224         return static_cast<T>(_USING_ALL_BITS()?~T(0):_ONE()-1);
 225 }
 226
 227 template <class T,unsigned int FIXED_BITS> inline float
 228 fixed_base<T,FIXED_BITS>::_EPSILON()
 229 {
 230         return 1.0f/((float)_ONE()*2);
 231 }
 232
 233
 234 template <class T,unsigned int FIXED_BITS>T &
 235 fixed_base<T,FIXED_BITS>::data()
 236 {
 237         return _data;
 238 }
 239
 240 template <class T,unsigned int FIXED_BITS>const T &
 241 fixed_base<T,FIXED_BITS>::data()const
 242 {
 243         return _data;
 244 }
 245
 246 //! fixed+=fixed
 247 template <class T,unsigned int FIXED_BITS>const fixed_base<T,FIXED_BITS> &
 248 fixed_base<T,FIXED_BITS>::operator+=(const fixed_base<T,FIXED_BITS> &rhs)
 249 {
 250         _data+=rhs._data;
 251         return *this;
 252 }
 253
 254 //! fixed-=fixed
 255 template <class T,unsigned int FIXED_BITS>const fixed_base<T,FIXED_BITS> &
 256 fixed_base<T,FIXED_BITS>::operator-=(const fixed_base<T,FIXED_BITS> &rhs)
 257 {
 258         _data-=rhs._data;
 259         return *this;
 260 }
 261
 262 //! fixed*=fixed
 263 template <class T,unsigned int FIXED_BITS>const fixed_base<T,FIXED_BITS> &
 264 fixed_base<T,FIXED_BITS>::operator*=(const fixed_base<T,FIXED_BITS> &rhs)
 265 {
 266         if(_TYPE_SMALLER_THAN_INT())
 267                 _data=static_cast<T>((int)_data*(int)rhs._data>>FIXED_BITS);
 268         else
 269         {
 270                 _data*=rhs._data;
 271                 _data>>=FIXED_BITS;
 272         }
 273
 274         return *this;
 275 }
 276
 277 //! fixed/=fixed
 278 template <class T,unsigned int FIXED_BITS>const fixed_base<T,FIXED_BITS> &
 279 fixed_base<T,FIXED_BITS>::operator/=(const fixed_base<T,FIXED_BITS> &rhs)
 280 {
 281         if(_TYPE_SMALLER_THAN_INT())
 282                 _data=static_cast<T>((int)_data/(int)rhs._data<<FIXED_BITS);
 283         else
 284         {
 285                 _data/=rhs._data;
 286                 _data<<=FIXED_BITS;
 287         }
 288         return *this;
 289 }
 290
 291 template <class T,unsigned int FIXED_BITS> template<typename U> const fixed_base<T,FIXED_BITS> &
 292 fixed_base<T,FIXED_BITS>::operator*=(const U &rhs)
 293 {
 294         return operator*=(fixed_base<T,FIXED_BITS>(rhs));
 295 }
 296
 297 template <class T,unsigned int FIXED_BITS> template<typename U> const fixed_base<T,FIXED_BITS> &
 298 fixed_base<T,FIXED_BITS>::operator/=(const U &rhs)
 299 {
 300         return operator/=(fixed_base<T,FIXED_BITS>(rhs));
 301 }
 302
 303 //! fixed*=int
 304 template <class T,unsigned int FIXED_BITS>const fixed_base<T,FIXED_BITS> &
 305 fixed_base<T,FIXED_BITS>::operator*=(const int &rhs)
 306 {
 307         _data*=rhs; return *this;
 308 }
 309
 310 //! fixed/=int
 311 template <class T,unsigned int FIXED_BITS>const fixed_base<T,FIXED_BITS> &
 312 fixed_base<T,FIXED_BITS>::operator/=(const int &rhs)
 313 {
 314         _data/=rhs; return *this;
 315 }
 316
 317
 318
 319
 320
 321
 322
 323 //! fixed + fixed
 324 template <class T,unsigned int FIXED_BITS>fixed_base<T,FIXED_BITS>
 325 fixed_base<T,FIXED_BITS>::operator+(const fixed_base<T,FIXED_BITS> &rhs)const
 326 {
 327         _fixed ret;
 328         ret._data=_data+rhs._data;
 329         return ret;
 330 }
 331
 332 //! fixed - fixed
 333 template <class T,unsigned int FIXED_BITS>fixed_base<T,FIXED_BITS>
 334 fixed_base<T,FIXED_BITS>::operator-(const fixed_base<T,FIXED_BITS> &rhs)const
 335 {
 336         _fixed ret;
 337         ret._data=_data-rhs._data;
 338         return ret;
 339 }
 340
 341 //! fixed * fixed
 342 template <class T,unsigned int FIXED_BITS>fixed_base<T,FIXED_BITS>
 343 fixed_base<T,FIXED_BITS>::operator*(const fixed_base<T,FIXED_BITS> &rhs)const
 344 {
 345         _fixed ret;
 346         ret._data=((_data*rhs._data)>>FIXED_BITS);
 347         return ret;
 348         //return reinterpret_cast<_fixed>((_data*rhs._data)>>FIXED_BITS);
 349 }
 350
 351 //! fixed / fixed
 352 template <class T,unsigned int FIXED_BITS>fixed_base<T,FIXED_BITS>
 353 fixed_base<T,FIXED_BITS>::operator/(const fixed_base<T,FIXED_BITS> &rhs)const
 354 {
 355         _fixed ret;
 356         ret._data=((_data/rhs._data)<<FIXED_BITS);
 357         return ret;
 358         //return reinterpret_cast<_fixed>((_data/rhs._data)<<FIXED_BITS);
 359 }
 360
 361 //! fixed + ...
 362 template <class T,unsigned int FIXED_BITS> template<typename U> fixed_base<T,FIXED_BITS>
 363 fixed_base<T,FIXED_BITS>::operator+(const U &rhs) const
 364 {
 365         return operator+(fixed_base<T,FIXED_BITS>(rhs));
 366 }
 367
 368 //! fixed - ...
 369 template <class T,unsigned int FIXED_BITS> template<typename U> fixed_base<T,FIXED_BITS>
 370 fixed_base<T,FIXED_BITS>::operator-(const U &rhs) const
 371 {
 372         return operator-(fixed_base<T,FIXED_BITS>(rhs));
 373 }
 374
 375 //! fixed * ...
 376 template <class T,unsigned int FIXED_BITS> template<typename U> fixed_base<T,FIXED_BITS>
 377 fixed_base<T,FIXED_BITS>::operator*(const U &rhs) const
 378 {
 379         return operator*(fixed_base<T,FIXED_BITS>(rhs));
 380 }
 381
 382 //! fixed / ...
 383 template <class T,unsigned int FIXED_BITS> template<typename U> fixed_base<T,FIXED_BITS>
 384 fixed_base<T,FIXED_BITS>::operator/(const U &rhs) const
 385 {
 386         return operator/(fixed_base<T,FIXED_BITS>(rhs));
 387 }
 388
 389 //! fixed * int
 390 template <class T,unsigned int FIXED_BITS>fixed_base<T,FIXED_BITS>
 391 fixed_base<T,FIXED_BITS>::operator*(const int &rhs)const
 392 {
 393         _fixed ret;
 394         ret._data=_data*rhs;
 395         return ret;
 396         //return reinterpret_cast<_fixed>(_data*rhs);
 397 }
 398
 399 //! fixed * float
 400 template <class T,unsigned int FIXED_BITS>fixed_base<T,FIXED_BITS>
 401 fixed_base<T,FIXED_BITS>::operator*(const float &rhs)const
 402 {
 403     return (*this)*_fixed(rhs);
 404 }
 405
 406 //! fixed * double
 407 template <class T,unsigned int FIXED_BITS>fixed_base<T,FIXED_BITS>
 408 fixed_base<T,FIXED_BITS>::operator*(const double &rhs)const
 409 {
 410     return (*this)*_fixed(rhs);
 411 }
 412
 413
 414 //! fixed / int
 415 template <class T,unsigned int FIXED_BITS>fixed_base<T,FIXED_BITS>
 416 fixed_base<T,FIXED_BITS>::operator/(const int &rhs)const
 417 {
 418         _fixed ret;
 419         ret._data=_data/rhs;
 420         return ret;
 421         //return reinterpret_cast<_fixed>(_data/rhs);
 422 }
 423
 424 //! float * fixed
 425 template <class T,unsigned int FIXED_BITS>fixed_base<T,FIXED_BITS>
 426 operator*(const float& lhs, const fixed_base<T,FIXED_BITS> &rhs)
 427 {
 428     return rhs*lhs;
 429 }
 430
 431 //! double * fixed
 432 template <class T,unsigned int FIXED_BITS>fixed_base<T,FIXED_BITS>
 433 operator*(const double& lhs, const fixed_base<T,FIXED_BITS> &rhs)
 434 {
 435     return rhs*lhs;
 436 }
 437
 438
 439
 440
 441
 442
 443 // Negation Operator
 444 template <class T,unsigned int FIXED_BITS>fixed_base<T,FIXED_BITS>
 445 fixed_base<T,FIXED_BITS>::operator-()const
 446 {
 447         _fixed ret; ret._data=-_data; return ret;
 448 }
 449
 450 // Casting Operators
 451 template <class T,unsigned int FIXED_BITS>
 452 fixed_base<T,FIXED_BITS>::operator float()const
 453 {
 454         return static_cast<float>(_data)/static_cast<float>(_ONE());
 455 }
 456
 457 template <class T,unsigned int FIXED_BITS>
 458 fixed_base<T,FIXED_BITS>::operator double()const
 459 {
 460         return static_cast<double>(_data)/static_cast<double>(_ONE());
 461 }
 462
 463 template <class T,unsigned int FIXED_BITS>
 464 fixed_base<T,FIXED_BITS>::operator long double()const
 465 {
 466         return static_cast<long double>(_data)/static_cast<long double>(_ONE());
 467 }
 468
 469 template <class T,unsigned int FIXED_BITS>
 470 fixed_base<T,FIXED_BITS>::operator int()const
 471 {
 472         return static_cast<int>(_data>>FIXED_BITS);
 473 }
 474
 475 template <class T,unsigned int FIXED_BITS>
 476 fixed_base<T,FIXED_BITS>::operator bool()const
 477 {
 478         return static_cast<bool>(_data);
 479 }
 480
 481
 482 template <class T,unsigned int FIXED_BITS> fixed_base<T,FIXED_BITS>
 483 fixed_base<T,FIXED_BITS>::floor()const
 484 {
 485         _fixed ret(*this);
 486         ret._data&=~_F_MASK();
 487         return ret;
 488 }
 489
 490 template <class T,unsigned int FIXED_BITS> fixed_base<T,FIXED_BITS>
 491 fixed_base<T,FIXED_BITS>::ceil()const
 492 {
 493         _fixed ret(*this);
 494         if(ret._data&_F_MASK())
 495                 ret._data=(ret._data&~_F_MASK()) + _ONE();
 496         else
 497                 ret._data&=~_F_MASK();
 498         return ret;
 499 }
 500
 501 template <class T,unsigned int FIXED_BITS> fixed_base<T,FIXED_BITS>
 502 fixed_base<T,FIXED_BITS>::round()const
 503 {
 504         _fixed ret(*this);
 505         ret._data+=_ONE()>>1;
 506         ret._data&=~_F_MASK();
 507         return ret;
 508 }
 509
 510
 511
 512
 513
 514
 515
 516
 517
 518
 519
 520
 521
 522
 523
 524
 525
 526
 527
 528
 529
 530
 531
 532
 533
 534
 535 typedef fixed_base<ETL_FIXED_TYPE,ETL_FIXED_BITS> fixed;
 536
 537 _ETL_END_NAMESPACE
 538
 539 _STD_BEGIN_NAMESPACE
 540
 541 template <class T,unsigned int FIXED_BITS>
 542 inline _ETL::fixed_base<T,FIXED_BITS>
 543 ceil(const _ETL::fixed_base<T,FIXED_BITS> &rhs)
 544 { return rhs.ceil(); }
 545
 546 template <class T,unsigned int FIXED_BITS>
 547 _ETL::fixed_base<T,FIXED_BITS>
 548 floor(const _ETL::fixed_base<T,FIXED_BITS> &rhs)
 549 { return rhs.floor(); }
 550
 551 template <class T,unsigned int FIXED_BITS>
 552 _ETL::fixed_base<T,FIXED_BITS>
 553 round(const _ETL::fixed_base<T,FIXED_BITS> &rhs)
 554 { return rhs.round(); }
 555
 556 template <class T,unsigned int FIXED_BITS>
 557 _ETL::fixed_base<T,FIXED_BITS>
 558 abs(const _ETL::fixed_base<T,FIXED_BITS> &rhs)
 559 { return rhs<_ETL::fixed_base<T,FIXED_BITS>(0)?-rhs:rhs; }
 560
 561 _STD_END_NAMESPACE
 562
 563 /*
 564 template <class T,unsigned int FIXED_BITS, typename U> bool
 565 operator==(const _ETL::fixed_base<T,FIXED_BITS>& lhs, const _ETL::fixed_base<T,FIXED_BITS>& rhs)
 566 { return lhs.data()==rhs.data(); }
 567
 568 template <class T,unsigned int FIXED_BITS, typename U> bool
 569 operator!=(const _ETL::fixed_base<T,FIXED_BITS>& lhs, const _ETL::fixed_base<T,FIXED_BITS>& rhs)
 570 { return lhs.data()!=rhs.data(); }
 571
 572 template <class T,unsigned int FIXED_BITS, typename U> bool
 573 operator>(const _ETL::fixed_base<T,FIXED_BITS>& lhs, const _ETL::fixed_base<T,FIXED_BITS>& rhs)
 574 { return lhs.data()>rhs.data(); }
 575
 576 template <class T,unsigned int FIXED_BITS, typename U> bool
 577 operator<(const _ETL::fixed_base<T,FIXED_BITS>& lhs, const _ETL::fixed_base<T,FIXED_BITS>& rhs)
 578 { return lhs.data()<rhs.data(); }
 579
 580 template <class T,unsigned int FIXED_BITS, typename U> bool
 581 operator>=(const _ETL::fixed_base<T,FIXED_BITS>& lhs, const _ETL::fixed_base<T,FIXED_BITS>& rhs)
 582 { return lhs.data()>=rhs.data(); }
 583
 584 template <class T,unsigned int FIXED_BITS, typename U> bool
 585 operator<=(const _ETL::fixed_base<T,FIXED_BITS>& lhs, const _ETL::fixed_base<T,FIXED_BITS>& rhs)
 586 { return lhs.data()<=rhs.data(); }
 587 */
 588
 589
 590 #if defined(__GNUC__) && __GNUC__ == 3
 591 template <class T,unsigned int FIXED_BITS, typename U> U
 592 operator*(const U &a,const _ETL::fixed_base<T,FIXED_BITS> &b)
 593         { return a*static_cast<double>(b); }
 594
 595 template <class T,unsigned int FIXED_BITS, typename U> U
 596 operator/(const U &a,const _ETL::fixed_base<T,FIXED_BITS> &b)
 597         { return a/static_cast<double>(b); }
 598
 599 template <class T,unsigned int FIXED_BITS, typename U> U
 600 operator+(const U &a,const _ETL::fixed_base<T,FIXED_BITS> &b)
 601         { return a+static_cast<double>(b); }
 602
 603 template <class T,unsigned int FIXED_BITS, typename U> U
 604 operator-(const U &a,const _ETL::fixed_base<T,FIXED_BITS> &b)
 605         { return a-static_cast<double>(b); }
 606
 607
 608 /*
 609 inline const float &
 610 operator*=(float &a,const _ETL::fixed &b)
 611         { a*=(float)b; return a; }
 612
 613 inline const float &
 614 operator/=(float &a,const _ETL::fixed &b)
 615         { a/=(float)b; return a; }
 616
 617 inline const float &
 618 operator-=(float &a,const _ETL::fixed &b)
 619         { a-=(float)b; return a; }
 620
 621 inline const float &
 622 operator+=(float &a,const _ETL::fixed &b)
 623         { a+=(float)b; return a; }
 624 */
 625 #endif
 626
 627 /* === E N D =============================================================== */
 628
 629 #endif