?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ale_fixed.h: Revise so that 'long long' only appears when necessary for a given confi...
[Ale.git] / ale_fixed.h
blob8ef965f795bbabeb534ebd4afa8d2940a46a10b8
1 // Copyright 2007 David Hilvert <dhilvert@auricle.dyndns.org>,
2 // <dhilvert@ugcs.caltech.edu>
3
4 /* This file is part of the Anti-Lamenessing Engine.
5
6 The Anti-Lamenessing Engine is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 The Anti-Lamenessing Engine is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with the Anti-Lamenessing Engine; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21 #ifndef __ale_fixed_h__
22 #define __ale_fixed_h__
23
24 #include <assert.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27
28 #include "ale_math.h"
29
30 #define FIXED16 4
31 #define FIXED32 5
32
33 #define DEBUG_FIXED_POINT 0
34
35 /*
36 * Define a fixed point data type.
37 */
38
39 class ale_fixed_16 {
40 public:
41 typedef short bits_t;
42 typedef int mulbits_t;
43 static bits_t posinf() {
44 return 32767;
45 }
46 static bits_t neginf() {
47 return -32766;
48 }
49 static bits_t nan() {
50 return -32767;
51 }
52 static bits_t rint(double d) {
53 return (bits_t) lrint(d);
54 }
55 };
56
57 class ale_fixed_16_calc {
58 public:
59 typedef int bits_t;
60 typedef int mulbits_t;
61 static bits_t posinf() {
62 return 2147483647;
63 }
64 static bits_t neginf() {
65 return -2147483646;
66 }
67 static bits_t nan() {
68 return -2147483647;
69 }
70 static bits_t rint(double d) {
71 return (bits_t) lrint(d);
72 }
73 };
74
75 #if ALE_COLORS == FIXED16
76 class ale_fixed_16_accum {
77 public:
78 typedef int bits_t;
79 typedef long long mulbits_t;
80 static bits_t posinf() {
81 return 2147483647;
82 }
83 static bits_t neginf() {
84 return -2147483646;
85 }
86 static bits_t nan() {
87 return -2147483647;
88 }
89 static bits_t rint(double d) {
90 return (bits_t) lrint(d);
91 }
92 };
93 #endif
94
95 #if ALE_COLORS == FIXED32 || ALE_COORDINATES == FIXED32
96 class ale_fixed_32 {
97 public:
98 typedef int bits_t;
99 typedef long long mulbits_t;
100 static bits_t posinf() {
101 return 2147483647;
102 }
103 static bits_t neginf() {
104 return -2147483646;
105 }
106 static bits_t nan() {
107 return -2147483647;
108 }
109 static bits_t rint(double d) {
110 return (bits_t) lrint(d);
111 }
112 };
113 #endif
114
115 #if ALE_COLORS == FIXED32
116 class ale_fixed_32_accum {
117 public:
118 typedef long long bits_t;
119 typedef long long mulbits_t;
120 static bits_t posinf() {
121 return 9223372036854775807LL;
122 }
123 static bits_t neginf() {
124 return -9223372036854775806LL;
125 }
126 static bits_t nan() {
127 return -9223372036854775807LL;
128 }
129 static bits_t rint(double d) {
130 return (bits_t) llrint(d);
131 }
132 };
133 #endif
134
135 #define ALE_FIXED_NAN (fixed_type::nan())
136 #define ALE_FIXED_POSINF (fixed_type::posinf())
137 #define ALE_FIXED_NEGINF (fixed_type::neginf())
138
139 template<class fixed_type, unsigned int N>
140 class ale_fixed {
141 static int casting_disabled;
142
143 public:
144
145 typedef typename fixed_type::bits_t bits_t;
146 typedef typename fixed_type::mulbits_t mulbits_t;
147
148 bits_t bits;
149
150 /*
151 * Constructors.
152 */
153 ale_fixed() {
154 bits = 0;
155 }
156
157 ale_fixed(const ale_fixed &f) {
158 bits = f.bits;
159 }
160
161 ale_fixed& operator=(const ale_fixed &f) {
162 bits = f.bits;
163
164 return (*this);
165 }
166
167 /*
168 * Disable casting
169 */
170
171 static void disable_casting() {
172 casting_disabled = 1;
173 }
174
175 /*
176 * Enable casting
177 */
178
179 static void enable_casting() {
180 casting_disabled = 0;
181 }
182
183 /*
184 * Casting status.
185 */
186
187 static int casting_status() {
188 return !casting_disabled;
189 }
190
191 /*
192 * Cast to ordinary numbers
193 */
194
195 operator double() const {
196 #if DEBUG_FIXED_POINT
197 /*
198 * Removed for performance reasons.
199 */
200
201 assert(!casting_disabled);
202 if (bits == ALE_FIXED_NAN) {
203 double zero = 0;
204 double nan = zero / zero;
205 assert (isnan(nan));
206 return nan;
207 } else if (bits == ALE_FIXED_NEGINF) {
208 double zero = 0;
209 double negone = -1;
210 double neginf = negone / zero;
211 assert (isinf(neginf));
212 assert (neginf < 0);
213 return neginf;
214 } else if (bits == ALE_FIXED_POSINF) {
215 double zero = 0;
216 double posone = +1;
217 double posinf = posone / zero;
218 assert (isinf(posinf));
219 assert (posinf > 0);
220 return posinf;
221 }
222 #endif
223
224 return (((double) bits) / (1 << N));
225 }
226
227 operator float() const {
228 #if DEBUG_FIXED_POINT
229 /*
230 * Removed for performance reasons.
231 */
232
233 assert(!casting_disabled);
234 if (bits == ALE_FIXED_NAN) {
235 float zero = 0;
236 float nan = zero / zero;
237 assert (isnan(nan));
238 return nan;
239 } else if (bits == ALE_FIXED_NEGINF) {
240 float zero = 0;
241 float negone = -1;
242 float neginf = negone / zero;
243 assert (isinf(neginf));
244 assert (neginf < 0);
245 return neginf;
246 } else if (bits == ALE_FIXED_POSINF) {
247 float zero = 0;
248 float posone = +1;
249 float posinf = posone / zero;
250 assert (isinf(posinf));
251 assert (posinf > 0);
252 return posinf;
253 }
254 #endif
255
256 return (((float) bits) / (1 << N));
257 }
258
259 operator int() const {
260 #if DEBUG_FIXED_POINT
261 /*
262 * Removed for performance reasons.
263 */
264
265 assert (bits != ALE_FIXED_NAN);
266 assert (bits != ALE_FIXED_POSINF);
267 assert (bits != ALE_FIXED_NEGINF);
268 #endif
269
270 return bits / (1 << N);
271 }
272
273 operator unsigned int() const {
274 #if DEBUG_FIXED_POINT
275 /*
276 * Removed for performance reasons.
277 */
278
279 assert (bits != ALE_FIXED_NAN);
280 assert (bits != ALE_FIXED_POSINF);
281 assert (bits != ALE_FIXED_NEGINF);
282 assert (bits >= 0);
283 #endif
284
285 return (unsigned int) operator int();
286 }
287
288 #if 0
289 template<class fixed_type_2, unsigned int M>
290 operator ale_fixed<fixed_type_2, M>() const {
291 ale_fixed<fixed_type_2, M> result;
292
293 if (bits == ALE_FIXED_NAN) {
294 result.bits = fixed_type_2::nan();
295 return result;
296 }
297
298 if (bits == ALE_FIXED_POSINF) {
299 result.bits = fixed_type_2::posinf();
300 return result;
301 }
302
303 if (bits == ALE_FIXED_NEGINF) {
304 result.bits = fixed_type_2::neginf();
305 return result;
306 }
307
308 if (sizeof(ale_fixed<fixed_type_2,M>) > sizeof(ale_fixed<fixed_type,N>)) {
309 typedef typename fixed_type_2::bits_t bits_t_calc;
310
311 bits_t_calc type_result;
312
313 if (M >= N)
314 type_result = bits << (bits_t_calc) ((int) M - (int) N);
315 else
316 type_result = bits / ((bits_t_calc) 1 << (bits_t_calc) ((int) N - (int) M));
317
318 result.bits = type_result;
319
320 } else {
321 typedef bits_t bits_t_calc;
322
323 bits_t_calc type_result;
324
325 if (M >= N)
326 type_result = bits << (bits_t_calc) ((int) M - (int) N);
327 else
328 type_result = bits / ((bits_t_calc) 1 << (bits_t_calc) ((int) N - (int) M));
329
330 if (type_result > fixed_type_2::posinf())
331 result.bits = fixed_type_2::posinf();
332 else if (type_result < fixed_type_2::neginf())
333 result.bits = fixed_type_2::neginf();
334 else
335 result.bits = type_result;
336 }
337
338 return result;
339 }
340 #endif
341
342 /*
343 * Cast from ordinary numbers
344 */
345
346 template<class fixed_type_2, unsigned int M>
347 ale_fixed(const ale_fixed<fixed_type_2,M> &d) {
348
349 /*
350 * XXX: this shouldn't be necessary.
351 */
352
353 bits = 0;
354
355 if (d.bits == fixed_type_2::nan()) {
356 bits = ALE_FIXED_NAN;
357 return;
358 }
359
360 if (bits == fixed_type_2::posinf()) {
361 bits = ALE_FIXED_POSINF;
362 return;
363 }
364
365 if (bits == fixed_type_2::neginf()) {
366 bits = ALE_FIXED_NEGINF;
367 return;
368 }
369
370 if (sizeof(ale_fixed<fixed_type,N>) > sizeof(ale_fixed<fixed_type_2,M>)) {
371 if (N >= M)
372 bits = d.bits << (bits_t) ((int) N - (int) M);
373 else
374 bits = d.bits / ((bits_t) 1 << (bits_t) ((int) M - (int) N));
375 } else {
376 typedef typename ale_fixed<fixed_type_2,M>::bits_t bits_t_calc;
377
378 bits_t_calc type_result;
379
380 if (N >= M)
381 type_result = d.bits << (bits_t_calc) ((int) N - (int) M);
382 else
383 type_result = d.bits / ((bits_t_calc) 1 << (bits_t_calc) ((int) M - (int) N));
384
385 if (type_result > ALE_FIXED_POSINF)
386 bits = ALE_FIXED_POSINF;
387 else if (type_result < ALE_FIXED_NEGINF)
388 bits = ALE_FIXED_NEGINF;
389 else
390 bits = type_result;
391 }
392 }
393
394 ale_fixed(double d) {
395 assert(!casting_disabled);
396
397 if (isnan(d)) {
398 bits = ALE_FIXED_NAN;
399 } else if (isinf(d) && d > 0) {
400 bits = ALE_FIXED_POSINF;
401 } else if (isinf(d) && d < 0) {
402 bits = ALE_FIXED_NEGINF;
403 } else {
404 bits = (bits_t) fixed_type::rint(d * (1 << N));
405
406 #if DEBUG_FIXED_POINT
407 /*
408 * Removed for performance reasons.
409 */
410
411 assert((double) *this > (d - (double) 1 / (1 << N)));
412 assert((double) *this < (d + (double) 1 / (1 << N)));
413
414 assert(bits < ALE_FIXED_POSINF);
415 assert(bits > ALE_FIXED_NEGINF);
416 #endif
417 }
418 }
419
420 ale_fixed(int d) {
421 bits = (bits_t) d << N;
422 #if DEBUG_FIXED_POINT
423 /*
424 * Removed for performance reasons.
425 */
426
427 assert((d >= 0 && bits >> N == d)
428 || (d < 0 && (-bits) >> N == -d));
429
430 assert (bits < ALE_FIXED_POSINF);
431 assert (bits > ALE_FIXED_NEGINF);
432 #endif
433 }
434
435 ale_fixed(unsigned int d) {
436 bits = (bits_t) d << N;
437
438 assert((unsigned int) (bits >> N) == d);
439
440 assert (bits < ALE_FIXED_POSINF);
441 assert (bits > ALE_FIXED_NEGINF);
442 }
443
444 /*
445 * Operators.
446 */
447
448 ale_fixed operator-() const {
449
450 ale_fixed result;
451
452 if (bits == ALE_FIXED_NAN || bits == 0)
453 return *this;
454 else if (bits == ALE_FIXED_POSINF)
455 result.bits = ALE_FIXED_NEGINF;
456 else if (bits == ALE_FIXED_NEGINF)
457 result.bits = ALE_FIXED_POSINF;
458 else
459 result.bits = -bits;
460
461 return result;
462 }
463
464 ale_fixed operator+(ale_fixed f) const {
465 ale_fixed result;
466
467 #if DEBUG_FIXED_POINT
468 /*
469 * Removed for performance reasons.
470 */
471
472 if (bits == ALE_FIXED_NAN || f.bits == ALE_FIXED_NAN
473 || (bits == ALE_FIXED_POSINF && f.bits == ALE_FIXED_NEGINF)
474 || (bits == ALE_FIXED_NEGINF && f.bits == ALE_FIXED_POSINF)) {
475 result.bits = ALE_FIXED_NAN;
476 return result;
477 }
478 #endif
479
480 bits_t bits_result = bits + f.bits;
481
482 #if DEBUG_FIXED_POINT
483 /*
484 * Removed for performance reasons.
485 */
486
487 if (bits_result >= ALE_FIXED_POSINF
488 || bits == ALE_FIXED_POSINF || f.bits == ALE_FIXED_POSINF
489 || bits > 0 && f.bits > 0 && bits_result < 0) {
490 result.bits = ALE_FIXED_POSINF;
491 return result;
492 } else if (bits_result <= ALE_FIXED_NEGINF
493 || bits == ALE_FIXED_NEGINF || f.bits == ALE_FIXED_NEGINF
494 || bits < 0 && f.bits < 0 && bits_result > 0) {
495 result.bits = ALE_FIXED_NEGINF;
496 return result;
497 }
498 #endif
499
500 result.bits = bits_result;
501
502 return result;
503 }
504
505 ale_fixed operator+(int i) const {
506 return operator+(ale_fixed(i));
507 }
508
509 ale_fixed operator+(unsigned int i) const {
510 return operator+(ale_fixed(i));
511 }
512
513 ale_fixed operator-(ale_fixed f) const {
514 ale_fixed result;
515
516 #if DEBUG_FIXED_POINT
517 /*
518 * Removed for performance reasons.
519 */
520
521 if (bits == ALE_FIXED_NAN || f.bits == ALE_FIXED_NAN
522 || (bits == ALE_FIXED_POSINF && f.bits == ALE_FIXED_POSINF)
523 || (bits == ALE_FIXED_NEGINF && f.bits == ALE_FIXED_NEGINF)) {
524 result.bits = ALE_FIXED_NAN;
525 return result;
526 }
527 #endif
528
529 bits_t bits_result = bits - f.bits;
530
531 #if DEBUG_FIXED_POINT
532 /*
533 * Removed for performance reasons.
534 */
535
536 if (bits_result >= ALE_FIXED_POSINF
537 || bits == ALE_FIXED_POSINF || f.bits == ALE_FIXED_NEGINF
538 || bits > 0 && f.bits < 0 && bits_result < 0) {
539 result.bits = ALE_FIXED_POSINF;
540 return result;
541 } else if (bits_result <= ALE_FIXED_NEGINF
542 || bits == ALE_FIXED_NEGINF || f.bits == ALE_FIXED_POSINF
543 || bits < 0 && f.bits > 0 && bits_result > 0) {
544 result.bits = ALE_FIXED_NEGINF;
545 return result;
546 }
547 #endif
548
549 result.bits = bits_result;
550
551 return result;
552 }
553
554 ale_fixed operator-(int i) const {
555 return operator-(ale_fixed(i));
556 }
557
558 ale_fixed operator-(unsigned int i) const {
559 return operator-(ale_fixed(i));
560 }
561
562 ale_fixed operator*(ale_fixed f) const {
563 ale_fixed result;
564
565 #if DEBUG_FIXED_POINT
566 /*
567 * Removed for performance reasons.
568 */
569
570 if (bits == ALE_FIXED_NAN || f.bits == ALE_FIXED_NAN) {
571 result.bits = ALE_FIXED_NAN;
572 return result;
573 }
574 #endif
575
576
577 mulbits_t mul_result = ((mulbits_t) bits * (mulbits_t) f.bits) / (1 << N);
578
579 #if DEBUG_FIXED_POINT
580 /*
581 * Removed for performance reasons.
582 */
583
584 if (mul_result > (mulbits_t) ALE_FIXED_POSINF
585 || mul_result < (mulbits_t) ALE_FIXED_NEGINF
586 || bits == ALE_FIXED_POSINF || f.bits == ALE_FIXED_POSINF
587 || bits == ALE_FIXED_NEGINF || f.bits == ALE_FIXED_NEGINF) {
588 if (mul_result > 0)
589 result.bits = ALE_FIXED_POSINF;
590 else if (mul_result < 0)
591 result.bits = ALE_FIXED_NEGINF;
592 else if (mul_result == 0)
593 result.bits = ALE_FIXED_NAN;
594 else
595 assert(0);
596 return result;
597 }
598 #endif
599
600 result.bits = mul_result;
601 return result;
602 }
603
604 ale_fixed operator*(int i) const {
605 return operator*(ale_fixed(i));
606 }
607
608 ale_fixed operator*(unsigned int i) const {
609 return operator*(ale_fixed(i));
610 }
611
612 ale_fixed operator/(ale_fixed f) const {
613 ale_fixed result;
614
615 /*
616 * While this approach may not be suitable for all
617 * applications, it can be a convenient way to detect and
618 * manufacture non-finite values.
619 */
620 if ((bits == 0 && f.bits == 0)
621 #if DEBUG_FIXED_POINT
622 /*
623 * Removed for performance reasons.
624 */
625
626 || bits == ALE_FIXED_NAN || f.bits == ALE_FIXED_NAN
627 || ((bits == ALE_FIXED_NEGINF || bits == ALE_FIXED_POSINF)
628 && (f.bits == ALE_FIXED_NEGINF || f.bits == ALE_FIXED_POSINF))
629 #endif
630 ) {
631 result.bits = ALE_FIXED_NAN;
632 return result;
633 } else if (f.bits == 0 && bits > 0) {
634 result.bits = ALE_FIXED_POSINF;
635 return result;
636 } else if (f.bits == 0 && bits < 0) {
637 result.bits = ALE_FIXED_NEGINF;
638 return result;
639 }
640
641 #if DEBUG_FIXED_POINT
642 /*
643 * Removed for performance reasons.
644 */
645
646 else if (f.bits == ALE_FIXED_POSINF || f.bits == ALE_FIXED_NEGINF) {
647 result.bits = 0;
648 return result;
649 }
650 #endif
651
652 mulbits_t div_result = ((mulbits_t) bits << N) / f.bits;
653
654 #if DEBUG_FIXED_POINT
655 /*
656 * Removed for performance reasons.
657 */
658
659 if (div_result > (mulbits_t) ALE_FIXED_POSINF) {
660 result.bits = ALE_FIXED_POSINF;
661 return result;
662 } else if (div_result < (mulbits_t) ALE_FIXED_NEGINF) {
663 result.bits = ALE_FIXED_NEGINF;
664 return result;
665 }
666 #endif
667
668 result.bits = (bits_t) div_result;
669 return result;
670 }
671
672 ale_fixed operator/(int i) const {
673 return operator/(ale_fixed(i));
674 }
675
676 ale_fixed operator/(unsigned int i) const {
677 return operator/(ale_fixed(i));
678 }
679
680 ale_fixed &operator+=(ale_fixed f) {
681 *this = *this + f;
682 return *this;
683 }
684
685 ale_fixed &operator-=(ale_fixed f) {
686 *this = *this - f;
687 return *this;
688 }
689
690 ale_fixed &operator*=(ale_fixed f) {
691 *this = *this * f;
692 return *this;
693 }
694
695 ale_fixed &operator/=(ale_fixed f) {
696 *this = *this / f;
697 return *this;
698 }
699
700 int operator!=(ale_fixed f) const {
701 if (bits == ALE_FIXED_NAN || f.bits == ALE_FIXED_NAN)
702 return 1;
703
704 if (bits == f.bits)
705 return 0;
706
707 return 1;
708 }
709
710 int operator==(ale_fixed f) const {
711 return !(operator!=(f));
712 }
713
714 int operator<=(ale_fixed f) const {
715 if (bits == ALE_FIXED_NAN || f.bits == ALE_FIXED_NAN)
716 return 0;
717
718 if (bits <= f.bits)
719 return 1;
720
721 return 0;
722 }
723
724 int operator>=(ale_fixed f) const {
725 if (bits == ALE_FIXED_NAN || f.bits == ALE_FIXED_NAN)
726 return 0;
727
728 if (bits >= f.bits)
729 return 1;
730
731 return 0;
732 }
733
734 int operator>(ale_fixed f) const {
735 if (bits == ALE_FIXED_NAN || f.bits == ALE_FIXED_NAN)
736 return 0;
737
738 if (bits > f.bits)
739 return 1;
740
741 return 0;
742 }
743
744 int operator<(ale_fixed f) const {
745 if (bits == ALE_FIXED_NAN || f.bits == ALE_FIXED_NAN)
746 return 0;
747
748 if (bits < f.bits)
749 return 1;
750
751 return 0;
752 }
753
754 int operator>=(int d) const {
755 return operator>=((ale_fixed) d);
756 }
757
758 int operator<=(int d) const {
759 return operator<=((ale_fixed) d);
760 }
761
762 int operator==(int d) const {
763 return operator==((ale_fixed) d);
764 }
765
766 int operator!=(int d) const {
767 return operator!=((ale_fixed) d);
768 }
769
770 int operator>(int d) const {
771 return operator>((ale_fixed) d);
772 }
773
774 int operator<(int d) const {
775 return operator<((ale_fixed) d);
776 }
777
778 int operator>=(double d) const {
779 return operator>=((ale_fixed) d);
780 }
781
782 int operator>=(float d) const {
783 return operator>=((ale_fixed) d);
784 }
785
786 int operator<=(double d) const {
787 return operator<=((ale_fixed) d);
788 }
789
790 int operator==(double d) const {
791 return operator==((ale_fixed) d);
792 }
793
794 int operator!=(double d) const {
795 return operator!=((ale_fixed) d);
796 }
797
798 int operator>(double d) const {
799 return operator>((ale_fixed) d);
800 }
801
802 int operator<(double d) const {
803 return operator<((ale_fixed) d);
804 }
805
806 int operator>=(unsigned int d) const {
807 return operator>=((ale_fixed) d);
808 }
809
810 int operator<=(unsigned int d) const {
811 return operator<=((ale_fixed) d);
812 }
813
814 int operator==(unsigned int d) const {
815 return operator==((ale_fixed) d);
816 }
817
818 int operator!=(unsigned int d) const {
819 return operator!=((ale_fixed) d);
820 }
821
822 int operator>(unsigned int d) const {
823 return operator>((ale_fixed) d);
824 }
825
826 int operator<(unsigned int d) const {
827 return operator<((ale_fixed) d);
828 }
829
830 };
831
832 #define ALE_FIXED_INCORPORATE_OPERATOR(return_value, op) \
833 template<class fixed_type, unsigned int N> \
834 return_value operator op(double a, const ale_fixed<fixed_type, N> &f) { \
835 ale_fixed<fixed_type, N> g(a); \
836 return g.operator op(f); \
837 } \
838 \
839 template<class fixed_type, unsigned int N> \
840 return_value operator op(int a, const ale_fixed<fixed_type, N> &f) { \
841 return (ale_fixed<fixed_type, N>) a op f; \
842 } \
843 \
844 template<class fixed_type, unsigned int N> \
845 return_value operator op(unsigned int a, const ale_fixed<fixed_type, N> &f) { \
846 return (ale_fixed<fixed_type, N>) a op f; \
847 } \
848
849 #define STDARGS ale_fixed<fixed_type,N>
850
851 ALE_FIXED_INCORPORATE_OPERATOR(STDARGS, +);
852 ALE_FIXED_INCORPORATE_OPERATOR(STDARGS, -);
853 ALE_FIXED_INCORPORATE_OPERATOR(STDARGS, *);
854 ALE_FIXED_INCORPORATE_OPERATOR(STDARGS, /);
855 ALE_FIXED_INCORPORATE_OPERATOR(int, <=);
856 ALE_FIXED_INCORPORATE_OPERATOR(int, >=);
857 ALE_FIXED_INCORPORATE_OPERATOR(int, <);
858 ALE_FIXED_INCORPORATE_OPERATOR(int, >);
859 ALE_FIXED_INCORPORATE_OPERATOR(int, !=);
860 ALE_FIXED_INCORPORATE_OPERATOR(int, ==);
861
862 template<class fixed_type, unsigned int N>
863 ale_fixed<fixed_type, N> fabs(ale_fixed<fixed_type, N> f) {
864 if (f < ale_fixed<fixed_type, N>())
865 return -f;
866 return f;
867 }
868
869 template<class fixed_type, unsigned int N>
870 ale_fixed<fixed_type, N> pow(ale_fixed<fixed_type, N> f, double d) {
871 return pow((double) f, (double) d);
872 }
873
874 /*
875 * sqrt() via the Babylonian method.
876 *
877 * http://en.wikipedia.org/wiki/Methods_of_computing_square_roots
878 */
879
880 template<class fixed_type, unsigned int N>
881 ale_fixed<fixed_type, N> sqrt(ale_fixed<fixed_type, N> f) {
882 ale_fixed<fixed_type, N> guess = f;
883
884 typedef typename ale_fixed<fixed_type, N>::mulbits_t mulbits_t;
885
886 for (int i = 0; i < 5; i++) {
887 guess.bits >>= 1;
888
889 if (guess.bits <= 0)
890 return 0;
891
892 mulbits_t sf = (mulbits_t) f.bits << (N - 2);
893 guess.bits = guess.bits + sf / guess.bits;
894 }
895
896 return guess;
897 }
898
899 template<class fixed_type, unsigned int N>
900 ale_fixed<fixed_type, N> pow(ale_fixed<fixed_type, N> f, ale_fixed<fixed_type, N> d) {
901 if (d == 2)
902 return f * f;
903
904 if (d == 1)
905 return f;
906
907 if (d == 0)
908 return ale_fixed<fixed_type,N>(1);
909
910 return pow((double) f, (double) d);
911 }
912
913 template<class fixed_type, unsigned int N>
914 ale_fixed<fixed_type, N> pow(ale_fixed<fixed_type, N> f, int d) {
915 if (d == 2)
916 return f * f;
917
918 if (d == 1)
919 return f;
920
921 if (d == 0)
922 return ale_fixed<fixed_type, N>(1);
923
924 if (d > 1)
925 return pow(f, d / 2) * pow(f, d - d / 2);
926
927 if (d < 0)
928 return 1 / pow(f, -d);
929
930 assert(0);
931 }
932
933 template<class fixed_type, unsigned int N>
934 ale_fixed<fixed_type, N> pow(ale_fixed<fixed_type, N> f, unsigned int d) {
935 if (d == 2)
936 return f * f;
937
938 if (d == 1)
939 return f;
940
941 if (d == 0)
942 return ale_fixed<fixed_type, N>(1);
943
944 return pow(f, d / 2) * pow(f, d - d / 2);
945 }
946
947 template<class fixed_type, unsigned int N>
948 ale_fixed<fixed_type, N> floor(ale_fixed<fixed_type, N> f) {
949
950 #if DEBUG_FIXED_POINT
951 /*
952 * Removed for performance reasons.
953 */
954
955 if (N == 0
956 || f.bits == ALE_FIXED_POSINF
957 || f.bits == ALE_FIXED_NEGINF
958 || f.bits == ALE_FIXED_NAN)
959 return f;
960 #endif
961
962 ale_fixed<fixed_type, N> result;
963
964 result.bits = (f.bits & ~((1 << N) - 1));
965
966 /*
967 * XXX: This isn't exactly right.
968 */
969 if (f.bits < 0)
970 result.bits -= 1;
971
972 return result;
973 }
974
975 template<class fixed_type, unsigned int N>
976 ale_fixed<fixed_type, N> lrintf(ale_fixed<fixed_type, N> f) {
977
978 #if DEBUG_FIXED_POINT
979 /*
980 * Removed for performance reasons.
981 */
982
983 if (N == 0
984 || f.bits == ALE_FIXED_POSINF
985 || f.bits == ALE_FIXED_NEGINF
986 || f.bits == ALE_FIXED_NAN)
987 return f;
988 #endif
989
990 ale_fixed<fixed_type, N> result = floor(f);
991
992 if (f.bits - result.bits >= (1 << N - 1))
993 result.bits += (1 << N);
994
995 return result;
996 }
997
998 template<class fixed_type, unsigned int N>
999 ale_fixed<fixed_type, N> ceil(ale_fixed<fixed_type, N> f) {
1000 return -floor(-f);
1001 }
1002
1003 template<class fixed_type, unsigned int N>
1004 int ale_isinf(ale_fixed<fixed_type, N> f) {
1005 return (f.bits == ALE_FIXED_NEGINF || f.bits == ALE_FIXED_POSINF);
1006 }
1007
1008 template<class fixed_type, unsigned int N>
1009 int ale_isnan(ale_fixed<fixed_type, N> f) {
1010 return (f.bits == ALE_FIXED_NAN);
1011 }
1012
1013 template<class fixed_type, unsigned int N>
1014 int finite(ale_fixed<fixed_type, N> f) {
1015 return (f.bits < ALE_FIXED_POSINF && f.bits > ALE_FIXED_NEGINF);
1016 }
1017
1018 template<class fixed_type, unsigned int N, unsigned int M>
1019 ale_fixed<fixed_type, N> convert_precision(ale_fixed<fixed_type, M> m) {
1020
1021 /*
1022 * XXX: Checks should be added that precision is not
1023 * lost from most-significant bits.
1024 */
1025
1026 if (N != M)
1027 assert (0);
1028
1029 ale_fixed<fixed_type, N> n;
1030
1031 n.bits = m.bits << (N - M);
1032
1033 return n;
1034 }
1035
1036 template<class fixed_type, unsigned int N>
1037 int ale_fixed<fixed_type, N>::casting_disabled = 0;
1038
1039 #undef FIXED16
1040 #undef FIXED32
1041
1042 #endif
synthetic capture engine and renderer