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