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