home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / libg++-2.7.1-bin.lha / lib / g++-include / Fix24.h < prev    next >
C/C++ Source or Header  |  1996-10-12  |  13KB  |  598 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 the GNU C++ Library.  This library is free
  8. software; you can redistribute it and/or modify it under the terms of
  9. the GNU Library General Public License as published by the Free
  10. Software Foundation; either version 2 of the License, or (at your
  11. option) any later version.  This library is distributed in the hope
  12. that it will be useful, but WITHOUT ANY WARRANTY; without even the
  13. implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14. PURPOSE.  See the GNU Library General Public License for more details.
  15. You should have received a copy of the GNU Library General Public
  16. License along with this library; if not, write to the Free Software
  17. Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18. */
  19.  
  20. #ifndef _Fix24_h
  21. #ifdef __GNUG__
  22. #pragma interface
  23. #endif
  24. #define _Fix24_h 1
  25.  
  26. #include <stream.h>
  27. #include <std.h>
  28.  
  29. // extra type definitions 
  30.  
  31. typedef struct {
  32.   _G_int32_t        u;
  33.   _G_uint32_t        l;
  34. } twolongs;
  35.  
  36. // constant definitions
  37.  
  38. static const int
  39.   Fix24_shift = 31;
  40.           
  41. static const double
  42.   Fix24_fs = 2147483648.,        // 2^Fix24_shift
  43.   Fix24_mult = Fix24_fs,
  44.   Fix24_div = 1./Fix24_fs,
  45.   Fix24_max = 1. - .5/Fix24_fs,
  46.   Fix24_min = -1.;
  47.       
  48. static const _G_uint32_t
  49.   Fix24_msb = 0x80000000L,
  50.   Fix24_lsb = 0x00000100L,
  51.   Fix24_m_max = 0x7fffff00L,
  52.   Fix24_m_min = 0x80000000L;
  53.  
  54. static const double
  55.   Fix48_fs = 36028797018963968.,    // 2^(24+Fix24_shift)
  56.   Fix48_max = 1. - .5/Fix48_fs,
  57.   Fix48_min = -1.,
  58.   Fix48_div_u = 1./Fix24_fs,
  59.   Fix48_div_l = 1./Fix48_fs;
  60.    
  61. static const twolongs
  62.   Fix48_msb = { 0x80000000L, 0L },
  63.   Fix48_lsb = { 0L, 0x00000100L },
  64.   Fix48_m_max = { 0x7fffff00L, 0xffffff00L },
  65.   Fix48_m_min = { 0x80000000L, 0L };
  66.           
  67. //
  68. // Fix24    class: 24-bit Fixed point data type
  69. //
  70. //    consists of a 24-bit mantissa (sign bit & 23 data bits).
  71. //
  72.  
  73. class Fix24 
  74. { 
  75.   friend class          Fix48;
  76.  
  77.   _G_int32_t            m;
  78.  
  79.   _G_int32_t            assign(double d);
  80.          operator       double() const;
  81.                         Fix24(long i);
  82.                         Fix24(int i);
  83.  
  84.  
  85. public:
  86.                         Fix24();
  87.                         Fix24(const Fix24&  f);
  88.                         Fix24(double d);
  89.                         Fix24(const Fix48& f);
  90.  
  91.                         ~Fix24();
  92.  
  93.   Fix24&                operator=(const Fix24&  f);
  94.   Fix24&                operator=(double d);
  95.   Fix24&                operator=(const Fix48& f);
  96.  
  97.   friend _G_int32_t&    mantissa(Fix24&  f);
  98.   friend const _G_int32_t&    mantissa(const Fix24&  f);
  99.   friend double         value(const Fix24&  f);
  100.  
  101.   Fix24                 operator +  () const;
  102.   Fix24                 operator -  () const;
  103.  
  104.   friend Fix24          operator +  (const Fix24&  f, const Fix24&  g);
  105.   friend Fix24          operator -  (const Fix24&  f, const Fix24&  g);
  106.   friend Fix48          operator *  (const Fix24&  f, const Fix24&  g);
  107.   friend Fix24          operator *  (const Fix24&  f, int     g);
  108.   friend Fix24          operator *  (int     g, const Fix24&  f);
  109.   friend Fix24          operator /  (const Fix24&  f, const Fix24&  g);
  110.   friend Fix24          operator << (const Fix24&  f, int b);
  111.   friend Fix24          operator >> (const Fix24&  f, int b);
  112.  
  113.   Fix24&                operator += (const Fix24&  f);
  114.   Fix24&                operator -= (const Fix24&  f);
  115.   Fix24&                operator *= (const Fix24&  f);
  116.   Fix24&                operator *= (int     b);
  117.   Fix24&                operator /= (const Fix24&  f);
  118.  
  119.   Fix24&                operator <<=(int b);
  120.   Fix24&                operator >>=(int b);
  121.  
  122.   friend int            operator == (const Fix24&  f, const Fix24&  g);
  123.   friend int            operator != (const Fix24&  f, const Fix24&  g);
  124.   friend int            operator >= (const Fix24&  f, const Fix24&  g);
  125.   friend int            operator <= (const Fix24&  f, const Fix24&  g);
  126.   friend int            operator >  (const Fix24&  f, const Fix24&  g);
  127.   friend int            operator <  (const Fix24&  f, const Fix24&  g);
  128.  
  129.   friend istream&       operator >> (istream& s, Fix24&  f);
  130.   friend ostream&       operator << (ostream& s, const Fix24&  f);
  131.  
  132.   void                  overflow(_G_int32_t&) const;
  133.   void                  range_error(_G_int32_t&) const;
  134. };
  135.  
  136.  
  137. //
  138. // Fix48 class: 48-bit Fixed point data type
  139. //
  140. //    consists of a 48-bit mantissa (sign bit & 47 data bits).
  141. //
  142.  
  143. class Fix48 
  144. { 
  145.   friend class         Fix24;
  146.  
  147.   twolongs             m;
  148.  
  149.   twolongs             assign(double d);
  150.          operator      double() const;
  151.                        Fix48(twolongs i);
  152.  
  153. public:
  154.                        Fix48();
  155.                        Fix48(const Fix48& f);
  156.                        Fix48(const Fix24&  f);
  157.                        Fix48(double d);
  158.                        ~Fix48();
  159.  
  160.   Fix48&               operator =  (const Fix48& f);
  161.   Fix48&               operator =  (const Fix24&  f);
  162.   Fix48&               operator =  (double d);
  163.  
  164.   friend twolongs&     mantissa(Fix48& f);
  165.   friend const twolongs&  mantissa(const Fix48& f);
  166.   friend double        value(const Fix48& f);
  167.  
  168.   Fix48                operator +  () const;
  169.   Fix48                operator -  () const;
  170.  
  171.   friend Fix48         operator +  (const Fix48& f, const Fix48& g);
  172.   friend Fix48         operator -  (const Fix48& f, const Fix48& g);
  173.   friend Fix48         operator *  (const Fix48& f, int    g);
  174.   friend Fix48         operator *  (int    g, const Fix48& f);
  175.   friend Fix48         operator << (const Fix48& f, int b);
  176.   friend Fix48         operator >> (const Fix48& f, int b);
  177.  
  178.   friend Fix48         operator *  (const Fix24&  f, const Fix24&  g);
  179.  
  180.   Fix48&               operator += (const Fix48& f);
  181.   Fix48&               operator -= (const Fix48& f);
  182.   Fix48&               operator *= (int    b);
  183.   Fix48&               operator <<=(int b);
  184.   Fix48&               operator >>=(int b);
  185.  
  186.   friend int           operator == (const Fix48& f, const Fix48& g);
  187.   friend int           operator != (const Fix48& f, const Fix48& g);
  188.   friend int           operator >= (const Fix48& f, const Fix48& g);
  189.   friend int           operator <= (const Fix48& f, const Fix48& g);
  190.   friend int           operator >  (const Fix48& f, const Fix48& g);
  191.   friend int           operator <  (const Fix48& f, const Fix48& g);
  192.  
  193.   friend istream&      operator >> (istream& s, Fix48& f);
  194.   friend ostream&      operator << (ostream& s, const Fix48& f);
  195.  
  196.   void                 overflow(twolongs& i) const;
  197.   void                 range_error(twolongs& i) const;
  198. };
  199.  
  200.  
  201. // active error handler declarations
  202.  
  203. typedef void (*Fix24_peh)(_G_int32_t&);
  204. typedef void (*Fix48_peh)(twolongs&);
  205.  
  206. extern Fix24_peh Fix24_overflow_handler;
  207. extern Fix48_peh Fix48_overflow_handler;
  208.  
  209. extern Fix24_peh Fix24_range_error_handler;
  210. extern Fix48_peh Fix48_range_error_handler;
  211.  
  212.  
  213. // error handler declarations
  214.  
  215. #if defined(SHORT_NAMES) || defined(VMS)
  216. #define    set_overflow_handler    sohndl
  217. #define set_range_error_handler    srnghdl
  218. #endif
  219.  
  220. extern Fix24_peh set_Fix24_overflow_handler(Fix24_peh);
  221. extern Fix48_peh set_Fix48_overflow_handler(Fix48_peh);
  222. extern void set_overflow_handler(Fix24_peh, Fix48_peh);
  223.  
  224. extern Fix24_peh set_Fix24_range_error_handler(Fix24_peh);
  225. extern Fix48_peh set_Fix48_range_error_handler(Fix48_peh);
  226. extern void set_range_error_handler(Fix24_peh, Fix48_peh);
  227.  
  228. extern void
  229.   Fix24_ignore(_G_int32_t&),
  230.   Fix24_overflow_saturate(_G_int32_t&),
  231.   Fix24_overflow_warning_saturate(_G_int32_t&),
  232.   Fix24_warning(_G_int32_t&),
  233.   Fix24_abort(_G_int32_t&);
  234.  
  235. extern void
  236.   Fix48_ignore(twolongs&),
  237.   Fix48_overflow_saturate(twolongs&),
  238.   Fix48_overflow_warning_saturate(twolongs&),
  239.   Fix48_warning(twolongs&),
  240.   Fix48_abort(twolongs&);
  241.  
  242.  
  243. inline Fix24::~Fix24() {}
  244.  
  245. inline Fix48::~Fix48() {}
  246.  
  247. inline Fix24::Fix24(long i)        
  248. { 
  249.   m = i; 
  250. }
  251.  
  252. inline Fix24::Fix24(int i)        
  253. { 
  254.   m = i; 
  255. }
  256.  
  257. inline Fix24::operator double() const
  258. { 
  259.   return  Fix24_div * m; 
  260. }
  261.  
  262. inline Fix24::Fix24()                 
  263. { 
  264.   m = 0; 
  265. }
  266.  
  267. inline Fix24::Fix24(const Fix24&  f)        
  268. { 
  269.   m = f.m; 
  270. }
  271.  
  272. inline Fix24::Fix24(double d)        
  273. {
  274.   m = assign(d);
  275. }
  276.  
  277. inline Fix24::Fix24(const Fix48& f)        
  278. { 
  279.   m = f.m.u;
  280. }
  281.  
  282. inline Fix24&  Fix24::operator=(const Fix24&  f)    
  283. { 
  284.   m = f.m; 
  285.   return *this; 
  286. }
  287.  
  288. inline Fix24&  Fix24::operator=(double d) 
  289. { 
  290.   m = assign(d); 
  291.   return *this; 
  292. }
  293.  
  294. inline Fix24&  Fix24::operator=(const Fix48& f)
  295. { 
  296.   m = f.m.u;
  297.   return *this; 
  298. }
  299.  
  300. inline _G_int32_t& mantissa(Fix24&  f)
  301. { 
  302.   return f.m; 
  303. }
  304.  
  305. inline const _G_int32_t& mantissa(const Fix24&  f)
  306. { 
  307.   return f.m; 
  308. }
  309.  
  310. inline double value(const Fix24&  f)
  311. { 
  312.   return double(f); 
  313. }
  314.  
  315. inline Fix24 Fix24::operator+() const        
  316. { 
  317.   return m; 
  318. }
  319.  
  320. inline Fix24 Fix24::operator-() const
  321. { 
  322.   return -m; 
  323. }
  324.  
  325. inline Fix24 operator+(const Fix24&  f, const Fix24&  g) 
  326. {
  327.   _G_int32_t sum = f.m + g.m;
  328.   if ( (f.m ^ sum) & (g.m ^ sum) & Fix24_msb )
  329.     f.overflow(sum);
  330.   return sum;
  331. }
  332.  
  333. inline Fix24 operator-(const Fix24&  f, const Fix24&  g) 
  334. {
  335.   _G_int32_t sum = f.m - g.m;
  336.   if ( (f.m ^ sum) & (-g.m ^ sum) & Fix24_msb )
  337.     f.overflow(sum);
  338.   return sum;
  339. }
  340.  
  341. inline Fix24 operator*(const Fix24& a, int b)     
  342. { 
  343.   return a.m * b; 
  344. }
  345.  
  346. inline Fix24 operator*(int b, const Fix24& a)     
  347. { 
  348.   return a * b; 
  349. }
  350.  
  351. inline Fix24 operator<<(const Fix24& a, int b)     
  352. { 
  353.   return a.m << b; 
  354. }
  355.  
  356. inline Fix24 operator>>(const Fix24& a, int b)     
  357. { 
  358.   return (a.m >> b) & ~0xff;
  359. }
  360.  
  361. inline  Fix24&  Fix24:: operator+=(const Fix24&  f)
  362. {
  363.   return *this = *this + f;
  364. }
  365.  
  366. inline Fix24&  Fix24:: operator-=(const Fix24&  f)     
  367. { 
  368.   return *this = *this - f; 
  369. }
  370.  
  371. inline Fix24& Fix24::operator*=(const Fix24& f)     
  372. { 
  373.   return *this = *this * f; 
  374. }
  375.  
  376. inline Fix24&  Fix24:: operator/=(const Fix24&  f)     
  377. { 
  378.   return *this = *this / f; 
  379. }
  380.  
  381. inline Fix24&  Fix24:: operator<<=(int b)    
  382. { 
  383.   return *this = *this << b;
  384. }
  385.  
  386. inline Fix24&  Fix24:: operator>>=(int b)    
  387. { 
  388.   return *this = *this >> b;
  389. }
  390.  
  391. inline Fix24& Fix24::operator*=(int b)
  392. { 
  393.   return *this = *this * b; 
  394. }
  395.  
  396. inline int operator==(const Fix24&  f, const Fix24&  g)    
  397. { 
  398.   return f.m == g.m;
  399. }
  400.  
  401. inline int operator!=(const Fix24&  f, const Fix24&  g)    
  402. { 
  403.   return f.m != g.m;
  404. }
  405.  
  406. inline int operator>=(const Fix24&  f, const Fix24&  g)    
  407. { 
  408.   return f.m >= g.m;
  409. }
  410.  
  411. inline int operator<=(const Fix24&  f, const Fix24&  g)    
  412. { 
  413.   return f.m <= g.m;
  414. }
  415.  
  416. inline int operator>(const Fix24&  f, const Fix24&  g)    
  417. { 
  418.   return f.m > g.m;
  419. }
  420.  
  421. inline int operator<(const Fix24&  f, const Fix24&  g)    
  422. { 
  423.   return f.m < g.m;
  424. }
  425.  
  426. inline istream&  operator>>(istream& s, Fix24&  f)
  427. { 
  428.   double d;
  429.   s >> d; 
  430.   f = d; 
  431.   return s; 
  432. }
  433.  
  434. inline ostream&  operator<<(ostream& s, const Fix24&  f)
  435. { 
  436.   return s << double(f);
  437. }
  438.  
  439. inline Fix48::Fix48(twolongs i)        
  440. { 
  441.   m = i;
  442. }
  443.  
  444. inline Fix48:: operator double() const
  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 * ((_G_uint32_t)(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(const Fix48& f)        
  462. { 
  463.   m = f.m;
  464. }
  465.  
  466. inline Fix48::Fix48(const 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=(const Fix48& f)    
  478. { 
  479.   m = f.m;
  480.   return *this; 
  481. }
  482.  
  483. inline Fix48& Fix48::operator=(const 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 const twolongs& mantissa(const Fix48& f)    
  502. { 
  503.   return f.m;
  504. }
  505.  
  506. inline double value(const Fix48& f)
  507. { 
  508.   return double(f);
  509. }
  510.  
  511. inline Fix48 Fix48::operator+() const        
  512. { 
  513.   return m;
  514. }
  515.  
  516. inline Fix48 Fix48::operator-() const
  517. { 
  518.   twolongs n;
  519.   n.l = -m.l;
  520.   n.u = ~m.u + ((n.l ^ m.l) & Fix24_msb ? 0 : Fix24_lsb);
  521.   return Fix48(n);
  522. }
  523.  
  524. inline Fix48 operator*(int b, const Fix48& a)     
  525. { 
  526.   return a * b; 
  527. }
  528.  
  529. inline Fix48& Fix48::operator+=(const Fix48& f)     
  530. { 
  531.   return *this = *this + f;
  532. }
  533.  
  534. inline Fix48& Fix48::operator-=(const Fix48& f)     
  535. { 
  536.   return *this = *this - f;
  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 Fix48& Fix48::operator>>=(int b)    
  550. { 
  551.   return *this = *this >> b;
  552. }
  553.  
  554. inline int operator==(const Fix48& f, const Fix48& g)    
  555. { 
  556.   return f.m.u == g.m.u && f.m.l == g.m.l;
  557. }
  558.  
  559. inline int operator!=(const Fix48& f, const Fix48& g)    
  560. { 
  561.   return f.m.u != g.m.u || f.m.l != g.m.l;
  562. }
  563.  
  564. inline int operator>=(const Fix48& f, const 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<=(const Fix48& f, const 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>(const Fix48& f, const 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 int operator<(const Fix48& f, const Fix48& g)    
  580. { 
  581.   return f.m.u < g.m.u || (f.m.u == g.m.u && f.m.l < g.m.l);
  582. }
  583.  
  584. inline istream& operator>>(istream& s, Fix48& f)
  585. { 
  586.   double d;
  587.   s >> d; 
  588.   f = d; 
  589.   return s; 
  590. }
  591.  
  592. inline ostream& operator<<(ostream& s, const Fix48& f)
  593. { 
  594.   return s << double(f);
  595. }
  596.  
  597. #endif
  598.