home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / zip / gnu / gxxinc.lzh / GXXINC / XFIX24.H < prev    next >
C/C++ Source or Header  |  1991-07-07  |  12KB  |  596 lines
  1. // This may look like C code, but it is really -*- C++ -*-
  2. /* 
  3. Copyright (C) 1988 Free Software Foundation
  4.     written by Kurt Baudendistel (gt-eedsp!baud@gatech.edu)
  5.     adapted for libg++ by Doug Lea (dl@rocky.oswego.edu)
  6.  
  7. This file is part of GNU CC.
  8.  
  9. GNU CC is distributed in the hope that it will be useful,
  10. but WITHOUT ANY WARRANTY.  No author or distributor
  11. accepts responsibility to anyone for the consequences of using it
  12. or for whether it serves any particular purpose or works at all,
  13. unless he says so in writing.  Refer to the GNU CC General Public
  14. License for full details.
  15.  
  16. Everyone is granted permission to copy, modify and redistribute
  17. GNU CC, but only under the conditions described in the
  18. GNU CC General Public License.   A copy of this license is
  19. supposed to have been given to you along with GNU CC so you
  20. can know your rights and responsibilities.  It should be in a
  21. file named COPYING.  Among other things, the copyright notice
  22. and this notice must be preserved on all copies.  
  23. */
  24.  
  25. #ifndef _Fix24_h
  26. #ifdef __GNUG__
  27. #pragma once
  28. #pragma interface
  29. #endif
  30. #define _Fix24_h 1
  31.  
  32. #include <stream.h>
  33. #include <std.h>
  34.  
  35. // extra type definitions 
  36.  
  37. typedef struct {
  38.   long                 u;
  39.   unsigned long           l;
  40. } twolongs;
  41.  
  42. // constant definitions
  43.  
  44. static const int
  45.   Fix24_shift = 31;
  46.           
  47. static const double
  48.   Fix24_fs = 2147483648.,        // 2^Fix24_shift
  49.   Fix24_mult = Fix24_fs,
  50.   Fix24_div = 1./Fix24_fs,
  51.   Fix24_max = 1. - .5/Fix24_fs,
  52.   Fix24_min = -1.;
  53.       
  54. static const unsigned long
  55.   Fix24_msb = 0x80000000L,
  56.   Fix24_lsb = 0x00000100L,
  57.   Fix24_m_max = 0x7fffff00L,
  58.   Fix24_m_min = 0x80000000L;
  59.  
  60. static const double
  61.   Fix48_fs = 36028797018963968.,    // 2^(24+Fix24_shift)
  62.   Fix48_max = 1. - .5/Fix48_fs,
  63.   Fix48_min = -1.,
  64.   Fix48_div_u = 1./Fix24_fs,
  65.   Fix48_div_l = 1./Fix48_fs;
  66.    
  67. static const twolongs
  68.   Fix48_msb = { 0x80000000L, 0L },
  69.   Fix48_lsb = { 0L, 0x00000100L },
  70.   Fix48_m_max = { 0x7fffff00L, 0xffffff00L },
  71.   Fix48_m_min = { 0x80000000L, 0L };
  72.           
  73. //
  74. // Fix24    class: 24-bit Fixed point data type
  75. //
  76. //    consists of a 24-bit mantissa (sign bit & 23 data bits).
  77. //
  78.  
  79. class Fix24 
  80. { 
  81.   friend class          Fix48;
  82.  
  83.   long                  m;
  84.  
  85.   long                  assign(double d);
  86.          operator       double();
  87.                         Fix24(long i);
  88.                         Fix24(int i);
  89.  
  90.  
  91. public:
  92.                         Fix24();
  93.                         Fix24(Fix24&  f);
  94.                         Fix24(double d);
  95.                         Fix24(Fix48& f);
  96.  
  97.                         ~Fix24();
  98.  
  99.   Fix24&                operator=(Fix24&  f);
  100.   Fix24&                operator=(double d);
  101.   Fix24&                operator=(Fix48& f);
  102.  
  103.   friend long&          mantissa(Fix24&  f);
  104.   friend double         value(Fix24&  f);
  105.  
  106.   Fix24                 operator +  ();
  107.   Fix24                 operator -  ();
  108.  
  109.   friend Fix24          operator +  (Fix24&  f, Fix24&  g);
  110.   friend Fix24          operator -  (Fix24&  f, Fix24&  g);
  111.   friend Fix48          operator *  (Fix24&  f, Fix24&  g);
  112.   friend Fix24          operator *  (Fix24&  f, long     g);
  113.   friend Fix24          operator *  (long     g, Fix24&  f);
  114.   friend Fix24          operator /  (Fix24&  f, Fix24&  g);
  115.   friend Fix24          operator << (Fix24&  f, int b);
  116.   friend Fix24          operator >> (Fix24&  f, int b);
  117.  
  118.   Fix24&                operator += (Fix24&  f);
  119.   Fix24&                operator -= (Fix24&  f);
  120.   Fix24&                operator *= (Fix24&  f);
  121.   Fix24&                operator *= (long    b);
  122.   Fix24&                operator /= (Fix24&  f);
  123.  
  124.   Fix24&                operator <<=(int b);
  125.   Fix24&                operator >>=(int b);
  126.  
  127.   friend int            operator == (Fix24&  f, Fix24&  g);
  128.   friend int            operator != (Fix24&  f, Fix24&  g);
  129.   friend int            operator >= (Fix24&  f, Fix24&  g);
  130.   friend int            operator <= (Fix24&  f, Fix24&  g);
  131.   friend int            operator >  (Fix24&  f, Fix24&  g);
  132.   friend int            operator <  (Fix24&  f, Fix24&  g);
  133.  
  134.   friend istream&       operator >> (istream& s, Fix24&  f);
  135.   friend ostream&       operator << (ostream& s, Fix24&  f);
  136.  
  137.   void                  overflow(long&);
  138.   void                  range_error(long&);
  139. };
  140.  
  141.  
  142. //
  143. // Fix48 class: 48-bit Fixed point data type
  144. //
  145. //    consists of a 48-bit mantissa (sign bit & 47 data bits).
  146. //
  147.  
  148. class Fix48 
  149. { 
  150.   friend class         Fix24;
  151.  
  152.   twolongs             m;
  153.  
  154.   twolongs             assign(double d);
  155.          operator      double();
  156.                        Fix48(twolongs i);
  157.  
  158. public:
  159.                        Fix48();
  160.                        Fix48(Fix48& f);
  161.                        Fix48(Fix24&  f);
  162.                        Fix48(double d);
  163.                        ~Fix48();
  164.  
  165.   Fix48&               operator =  (Fix48& f);
  166.   Fix48&               operator =  (Fix24&  f);
  167.   Fix48&               operator =  (double d);
  168.  
  169.   friend twolongs&     mantissa(Fix48& f);
  170.   friend double        value(Fix48& f);
  171.  
  172.   Fix48                operator +  ();
  173.   Fix48                operator -  ();
  174.  
  175.   friend Fix48         operator +  (Fix48& f, Fix48& g);
  176.   friend Fix48         operator -  (Fix48& f, Fix48& g);
  177.   friend Fix48         operator *  (Fix48& f, long   g);
  178.   friend Fix48         operator *  (long   g, Fix48& f);
  179.   friend Fix48         operator << (Fix48& f, int b);
  180.   friend Fix48         operator >> (Fix48& f, int b);
  181.  
  182.   friend Fix48         operator *  (Fix24&  f, Fix24&  g);
  183.  
  184.   Fix48&               operator += (Fix48& f);
  185.   Fix48&               operator -= (Fix48& f);
  186.   Fix48&               operator *= (long   b);
  187.   Fix48&               operator <<=(int b);
  188.   Fix48&               operator >>=(int b);
  189.  
  190.   friend int           operator == (Fix48& f, Fix48& g);
  191.   friend int           operator != (Fix48& f, Fix48& g);
  192.   friend int           operator >= (Fix48& f, Fix48& g);
  193.   friend int           operator <= (Fix48& f, Fix48& g);
  194.   friend int           operator >  (Fix48& f, Fix48& g);
  195.   friend int           operator <  (Fix48& f, Fix48& g);
  196.  
  197.   friend istream&      operator >> (istream& s, Fix48& f);
  198.   friend ostream&      operator << (ostream& s, Fix48& f);
  199.  
  200.   void                 overflow(twolongs& i);
  201.   void                 range_error(twolongs& i);
  202. };
  203.  
  204.  
  205. // active error handler declarations
  206.  
  207. typedef void (*Fix24_peh)(long&);
  208. typedef void (*Fix48_peh)(twolongs&);
  209.  
  210. extern Fix24_peh Fix24_overflow_handler;
  211. extern Fix48_peh Fix48_overflow_handler;
  212.  
  213. extern Fix24_peh Fix24_range_error_handler;
  214. extern Fix48_peh Fix48_range_error_handler;
  215.  
  216.  
  217. // error handler declarations
  218.  
  219. #if defined(SHORT_NAMES) || defined(VMS)
  220. #define    set_overflow_handler    sohndl
  221. #define set_range_error_handler    srnghdl
  222. #endif
  223.  
  224. extern Fix24_peh set_Fix24_overflow_handler(Fix24_peh);
  225. extern Fix48_peh set_Fix48_overflow_handler(Fix48_peh);
  226. extern void set_overflow_handler(Fix24_peh, Fix48_peh);
  227.  
  228. extern Fix24_peh set_Fix24_range_error_handler(Fix24_peh);
  229. extern Fix48_peh set_Fix48_range_error_handler(Fix48_peh);
  230. extern void set_range_error_handler(Fix24_peh, Fix48_peh);
  231.  
  232. extern void
  233.   Fix24_ignore(long&),
  234.   Fix24_overflow_saturate(long&),
  235.   Fix24_overflow_warning_saturate(long&),
  236.   Fix24_warning(long&),
  237.   Fix24_abort(long&);
  238.  
  239. extern void
  240.   Fix48_ignore(twolongs&),
  241.   Fix48_overflow_saturate(twolongs&),
  242.   Fix48_overflow_warning_saturate(twolongs&),
  243.   Fix48_warning(twolongs&),
  244.   Fix48_abort(twolongs&);
  245.  
  246. #if defined(__OPTIMIZE__) || defined(USE_LIBGXX_INLINES)
  247.  
  248. inline Fix24::~Fix24() {}
  249.  
  250. inline Fix24::Fix24(long i)        
  251. { 
  252.   m = i; 
  253. }
  254.  
  255. inline Fix24::Fix24(int i)        
  256. { 
  257.   m = i; 
  258. }
  259.  
  260. inline Fix24::operator double() 
  261. { 
  262.   return  Fix24_div * m; 
  263. }
  264.  
  265. inline Fix24::Fix24()                 
  266. { 
  267.   m = 0; 
  268. }
  269.  
  270. inline Fix24::Fix24(Fix24&  f)        
  271. { 
  272.   m = f.m; 
  273. }
  274.  
  275. inline Fix24::Fix24(double d)        
  276. {
  277.   m = assign(d);
  278. }
  279.  
  280. inline Fix24::Fix24(Fix48& f)        
  281. { 
  282.   m = f.m.u;
  283. }
  284.  
  285. inline Fix24&  Fix24::operator=(Fix24&  f)    
  286. { 
  287.   m = f.m; 
  288.   return *this; 
  289. }
  290.  
  291. inline Fix24&  Fix24::operator=(double d) 
  292. { 
  293.   m = assign(d); 
  294.   return *this; 
  295. }
  296.  
  297. inline Fix24&  Fix24::operator=(Fix48& f)
  298. { 
  299.   m = f.m.u;
  300.   return *this; 
  301. }
  302.  
  303. inline long& mantissa(Fix24&  f)    
  304. { 
  305.   return f.m; 
  306. }
  307.  
  308. inline double value(Fix24&  f)        
  309. { 
  310.   return double(f); 
  311. }
  312.  
  313. inline Fix24 Fix24::operator+()         
  314. { 
  315.   return m; 
  316. }
  317.  
  318. inline Fix24 Fix24::operator-()         
  319. { 
  320.   return -m; 
  321. }
  322.  
  323. inline Fix24 operator+(Fix24&  f, Fix24&  g) 
  324. {
  325.   long sum = f.m + g.m;
  326.   if ( (f.m ^ sum) & (g.m ^ sum) & Fix24_msb )
  327.     f.overflow(sum);
  328.   return sum;
  329. }
  330.  
  331. inline Fix24 operator-(Fix24&  f, Fix24&  g) 
  332. {
  333.   long sum = f.m - g.m;
  334.   if ( (f.m ^ sum) & (-g.m ^ sum) & Fix24_msb )
  335.     f.overflow(sum);
  336.   return sum;
  337. }
  338.  
  339. inline Fix24 operator*(Fix24& a, long b)     
  340. { 
  341.   return a.m * b; 
  342. }
  343.  
  344. inline Fix24 operator*(long b, Fix24& a)     
  345. { 
  346.   return a * b; 
  347. }
  348.  
  349. inline Fix24 operator<<(Fix24& a, int b)     
  350. { 
  351.   return a.m << b; 
  352. }
  353.  
  354. inline Fix24 operator>>(Fix24& a, int b)     
  355. { 
  356.   return (a.m >> b) & 0xffffff00L; 
  357. }
  358.  
  359. inline  Fix24&  Fix24:: operator+=(Fix24&  f)
  360. { 
  361.   return *this = *this + f; 
  362. }
  363.  
  364. inline Fix24&  Fix24:: operator-=(Fix24&  f)     
  365. { 
  366.   return *this = *this - f; 
  367. }
  368.  
  369. inline Fix24& Fix24::operator*=(Fix24& f)     
  370. { 
  371.   return *this = *this * f; 
  372. }
  373.  
  374. inline Fix24&  Fix24:: operator/=(Fix24&  f)     
  375. { 
  376.   return *this = *this / f; 
  377. }
  378.  
  379. inline Fix24&  Fix24:: operator<<=(int b)    
  380. { 
  381.   return *this = *this << b;
  382. }
  383.  
  384. inline Fix24&  Fix24:: operator>>=(int b)    
  385. { 
  386.   return *this = *this >> b;
  387. }
  388.  
  389. inline Fix24& Fix24::operator*=(long b)
  390. { 
  391.   return *this = *this * b; 
  392. }
  393.  
  394. inline int operator==(Fix24&  f, Fix24&  g)    
  395. { 
  396.   return f.m == g.m;
  397. }
  398.  
  399. inline int operator!=(Fix24&  f, Fix24&  g)    
  400. { 
  401.   return f.m != g.m;
  402. }
  403.  
  404. inline int operator>=(Fix24&  f, Fix24&  g)    
  405. { 
  406.   return f.m >= g.m;
  407. }
  408.  
  409. inline int operator<=(Fix24&  f, Fix24&  g)    
  410. { 
  411.   return f.m <= g.m;
  412. }
  413.  
  414. inline int operator>(Fix24&  f, Fix24&  g)    
  415. { 
  416.   return f.m > g.m;
  417. }
  418.  
  419. inline int operator<(Fix24&  f, Fix24&  g)    
  420. { 
  421.   return f.m < g.m;
  422. }
  423.  
  424. inline istream&  operator>>(istream& s, Fix24&  f)
  425. { 
  426.   double d;
  427.   s >> d; 
  428.   f = d; 
  429.   return s; 
  430. }
  431.  
  432. inline ostream&  operator<<(ostream& s, Fix24&  f)
  433. { 
  434.   return s << double(f);
  435. }
  436.  
  437. inline Fix48::~Fix48() {}
  438.  
  439. inline Fix48::Fix48(twolongs i)        
  440. { 
  441.   m = i;
  442. }
  443.  
  444. inline Fix48:: operator double()        
  445. { 
  446. /*
  447.  * Note: can't simply do Fix48_div_u * m.u + Fix48_div_l * m.l, because
  448.  * m.u is signed and m.l is unsigned.
  449.  */
  450.   return (m.u >= 0)? Fix48_div_u * m.u + Fix48_div_l * m.l :
  451.       (Fix48_div_u * ((unsigned long)(m.u & 0xffffff00)) 
  452.       + Fix48_div_l * m.l) - 2;
  453. }
  454.  
  455. inline Fix48::Fix48()                
  456. { 
  457.   m.u = 0;
  458.   m.l = 0;
  459. }
  460.  
  461. inline Fix48::Fix48(Fix48& f)        
  462. { 
  463.   m = f.m;
  464. }
  465.  
  466. inline Fix48::Fix48(Fix24&  f)    
  467. { 
  468.   m.u = f.m;
  469.   m.l = 0;
  470. }
  471.  
  472. inline Fix48::Fix48(double d)        
  473. { 
  474.   m = assign(d);
  475. }
  476.  
  477. inline Fix48& Fix48::operator=(Fix48& f)    
  478. { 
  479.   m = f.m;
  480.   return *this; 
  481. }
  482.  
  483. inline Fix48& Fix48::operator=(Fix24&  f)    
  484. { 
  485.   m.u = f.m;
  486.   m.l = 0;
  487.   return *this;
  488. }
  489.  
  490. inline Fix48& Fix48::operator=(double d)    
  491. { 
  492.   m = assign(d);
  493.   return *this; 
  494. }
  495.  
  496. inline twolongs& mantissa(Fix48& f)    
  497. { 
  498.   return f.m;
  499. }
  500.  
  501. inline double value(Fix48& f)        
  502. { 
  503.   return double(f);
  504. }
  505.  
  506. inline Fix48 Fix48::operator+()         
  507. { 
  508.   return m;
  509. }
  510.  
  511. inline Fix48 Fix48::operator-()         
  512. { 
  513.   twolongs n;
  514.   n.l = -m.l;
  515.   n.u = ~m.u + ((n.l ^ m.l) & Fix24_msb ? 0 : Fix24_lsb);
  516.   return Fix48(n);
  517. }
  518.  
  519. inline Fix48 operator*(long b, Fix48& a)     
  520. { 
  521.   return a * b; 
  522. }
  523.  
  524. inline Fix48& Fix48::operator+=(Fix48& f)     
  525. { 
  526.   return *this = *this + f;
  527. }
  528.  
  529. inline Fix48& Fix48::operator-=(Fix48& f)     
  530. { 
  531.   return *this = *this - f;
  532. }
  533.  
  534. inline Fix48& Fix48::operator*=(long b)    
  535. { 
  536.   return *this = *this * b;
  537. }
  538.  
  539. inline Fix48& Fix48::operator<<=(int b)    
  540. { 
  541.   return *this = *this << b;
  542. }
  543.  
  544. inline Fix48& Fix48::operator>>=(int b)    
  545. { 
  546.   return *this = *this >> b;
  547. }
  548.  
  549. inline int operator==(Fix48& f, Fix48& g)    
  550. { 
  551.   return f.m.u == g.m.u && f.m.l == g.m.l;
  552. }
  553.  
  554. inline int operator!=(Fix48& f, Fix48& g)    
  555. { 
  556.   return f.m.u != g.m.u || f.m.l != g.m.l;
  557. }
  558.  
  559. inline int operator>=(Fix48& f, Fix48& g)    
  560. { 
  561.   return f.m.u >= g.m.u || (f.m.u == g.m.u && f.m.l >= g.m.l);
  562. }
  563.  
  564. inline int operator<=(Fix48& f, Fix48& g)    
  565. { 
  566.   return f.m.u <= g.m.u || (f.m.u == g.m.u && f.m.l <= g.m.l);
  567. }
  568.  
  569. inline int operator>(Fix48& f, Fix48& g)    
  570. { 
  571.   return f.m.u > g.m.u || (f.m.u == g.m.u && f.m.l > g.m.l);
  572. }
  573.  
  574. inline int operator<(Fix48& f, Fix48& g)    
  575. { 
  576.   return f.m.u < g.m.u || (f.m.u == g.m.u && f.m.l < g.m.l);
  577. }
  578.  
  579. inline istream& operator>>(istream& s, Fix48& f)
  580. { 
  581.   double d;
  582.   s >> d; 
  583.   f = d; 
  584.   return s; 
  585. }
  586.  
  587. inline ostream& operator<<(ostream& s, Fix48& f)
  588. { 
  589.   return s << double(f);
  590. }
  591.  
  592.  
  593. #endif
  594. #endif
  595.  
  596.