home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / files / gnu / g__inc / xfix24.h < prev    next >
Encoding:
C/C++ Source or Header  |  1993-07-23  |  12.1 KB  |  591 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 once
  23. #pragma interface
  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();
  82.                         Fix24(long i);
  83.                         Fix24(int i);
  84.  
  85.  
  86. public:
  87.                         Fix24();
  88.                         Fix24(Fix24&  f);
  89.                         Fix24(double d);
  90.                         Fix24(Fix48& f);
  91.  
  92.                         ~Fix24();
  93.  
  94.   Fix24&                operator=(Fix24&  f);
  95.   Fix24&                operator=(double d);
  96.   Fix24&                operator=(Fix48& f);
  97.  
  98.   friend long&          mantissa(Fix24&  f);
  99.   friend double         value(Fix24&  f);
  100.  
  101.   Fix24                 operator +  ();
  102.   Fix24                 operator -  ();
  103.  
  104.   friend Fix24          operator +  (Fix24&  f, Fix24&  g);
  105.   friend Fix24          operator -  (Fix24&  f, Fix24&  g);
  106.   friend Fix48          operator *  (Fix24&  f, Fix24&  g);
  107.   friend Fix24          operator *  (Fix24&  f, long     g);
  108.   friend Fix24          operator *  (long     g, Fix24&  f);
  109.   friend Fix24          operator /  (Fix24&  f, Fix24&  g);
  110.   friend Fix24          operator << (Fix24&  f, int b);
  111.   friend Fix24          operator >> (Fix24&  f, int b);
  112.  
  113.   Fix24&                operator += (Fix24&  f);
  114.   Fix24&                operator -= (Fix24&  f);
  115.   Fix24&                operator *= (Fix24&  f);
  116.   Fix24&                operator *= (long    b);
  117.   Fix24&                operator /= (Fix24&  f);
  118.  
  119.   Fix24&                operator <<=(int b);
  120.   Fix24&                operator >>=(int b);
  121.  
  122.   friend int            operator == (Fix24&  f, Fix24&  g);
  123.   friend int            operator != (Fix24&  f, Fix24&  g);
  124.   friend int            operator >= (Fix24&  f, Fix24&  g);
  125.   friend int            operator <= (Fix24&  f, Fix24&  g);
  126.   friend int            operator >  (Fix24&  f, Fix24&  g);
  127.   friend int            operator <  (Fix24&  f, Fix24&  g);
  128.  
  129.   friend istream&       operator >> (istream& s, Fix24&  f);
  130.   friend ostream&       operator << (ostream& s, Fix24&  f);
  131.  
  132.   void                  overflow(long&);
  133.   void                  range_error(long&);
  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();
  151.                        Fix48(twolongs i);
  152.  
  153. public:
  154.                        Fix48();
  155.                        Fix48(Fix48& f);
  156.                        Fix48(Fix24&  f);
  157.                        Fix48(double d);
  158.                        ~Fix48();
  159.  
  160.   Fix48&               operator =  (Fix48& f);
  161.   Fix48&               operator =  (Fix24&  f);
  162.   Fix48&               operator =  (double d);
  163.  
  164.   friend twolongs&     mantissa(Fix48& f);
  165.   friend double        value(Fix48& f);
  166.  
  167.   Fix48                operator +  ();
  168.   Fix48                operator -  ();
  169.  
  170.   friend Fix48         operator +  (Fix48& f, Fix48& g);
  171.   friend Fix48         operator -  (Fix48& f, Fix48& g);
  172.   friend Fix48         operator *  (Fix48& f, long   g);
  173.   friend Fix48         operator *  (long   g, Fix48& f);
  174.   friend Fix48         operator << (Fix48& f, int b);
  175.   friend Fix48         operator >> (Fix48& f, int b);
  176.  
  177.   friend Fix48         operator *  (Fix24&  f, Fix24&  g);
  178.  
  179.   Fix48&               operator += (Fix48& f);
  180.   Fix48&               operator -= (Fix48& f);
  181.   Fix48&               operator *= (long   b);
  182.   Fix48&               operator <<=(int b);
  183.   Fix48&               operator >>=(int b);
  184.  
  185.   friend int           operator == (Fix48& f, Fix48& g);
  186.   friend int           operator != (Fix48& f, Fix48& g);
  187.   friend int           operator >= (Fix48& f, Fix48& g);
  188.   friend int           operator <= (Fix48& f, Fix48& g);
  189.   friend int           operator >  (Fix48& f, Fix48& g);
  190.   friend int           operator <  (Fix48& f, Fix48& g);
  191.  
  192.   friend istream&      operator >> (istream& s, Fix48& f);
  193.   friend ostream&      operator << (ostream& s, Fix48& f);
  194.  
  195.   void                 overflow(twolongs& i);
  196.   void                 range_error(twolongs& i);
  197. };
  198.  
  199.  
  200. // active error handler declarations
  201.  
  202. typedef void (*Fix24_peh)(long&);
  203. typedef void (*Fix48_peh)(twolongs&);
  204.  
  205. extern Fix24_peh Fix24_overflow_handler;
  206. extern Fix48_peh Fix48_overflow_handler;
  207.  
  208. extern Fix24_peh Fix24_range_error_handler;
  209. extern Fix48_peh Fix48_range_error_handler;
  210.  
  211.  
  212. // error handler declarations
  213.  
  214. #if defined(SHORT_NAMES) || defined(VMS)
  215. #define    set_overflow_handler    sohndl
  216. #define set_range_error_handler    srnghdl
  217. #endif
  218.  
  219. extern Fix24_peh set_Fix24_overflow_handler(Fix24_peh);
  220. extern Fix48_peh set_Fix48_overflow_handler(Fix48_peh);
  221. extern void set_overflow_handler(Fix24_peh, Fix48_peh);
  222.  
  223. extern Fix24_peh set_Fix24_range_error_handler(Fix24_peh);
  224. extern Fix48_peh set_Fix48_range_error_handler(Fix48_peh);
  225. extern void set_range_error_handler(Fix24_peh, Fix48_peh);
  226.  
  227. extern void
  228.   Fix24_ignore(long&),
  229.   Fix24_overflow_saturate(long&),
  230.   Fix24_overflow_warning_saturate(long&),
  231.   Fix24_warning(long&),
  232.   Fix24_abort(long&);
  233.  
  234. extern void
  235.   Fix48_ignore(twolongs&),
  236.   Fix48_overflow_saturate(twolongs&),
  237.   Fix48_overflow_warning_saturate(twolongs&),
  238.   Fix48_warning(twolongs&),
  239.   Fix48_abort(twolongs&);
  240.  
  241. #if defined(__OPTIMIZE__) || defined(USE_LIBGXX_INLINES)
  242.  
  243. inline Fix24::~Fix24() {}
  244.  
  245. inline Fix24::Fix24(long i)        
  246. { 
  247.   m = i; 
  248. }
  249.  
  250. inline Fix24::Fix24(int i)        
  251. { 
  252.   m = i; 
  253. }
  254.  
  255. inline Fix24::operator double() 
  256. { 
  257.   return  Fix24_div * m; 
  258. }
  259.  
  260. inline Fix24::Fix24()                 
  261. { 
  262.   m = 0; 
  263. }
  264.  
  265. inline Fix24::Fix24(Fix24&  f)        
  266. { 
  267.   m = f.m; 
  268. }
  269.  
  270. inline Fix24::Fix24(double d)        
  271. {
  272.   m = assign(d);
  273. }
  274.  
  275. inline Fix24::Fix24(Fix48& f)        
  276. { 
  277.   m = f.m.u;
  278. }
  279.  
  280. inline Fix24&  Fix24::operator=(Fix24&  f)    
  281. { 
  282.   m = f.m; 
  283.   return *this; 
  284. }
  285.  
  286. inline Fix24&  Fix24::operator=(double d) 
  287. { 
  288.   m = assign(d); 
  289.   return *this; 
  290. }
  291.  
  292. inline Fix24&  Fix24::operator=(Fix48& f)
  293. { 
  294.   m = f.m.u;
  295.   return *this; 
  296. }
  297.  
  298. inline long& mantissa(Fix24&  f)    
  299. { 
  300.   return f.m; 
  301. }
  302.  
  303. inline double value(Fix24&  f)        
  304. { 
  305.   return double(f); 
  306. }
  307.  
  308. inline Fix24 Fix24::operator+()         
  309. { 
  310.   return m; 
  311. }
  312.  
  313. inline Fix24 Fix24::operator-()         
  314. { 
  315.   return -m; 
  316. }
  317.  
  318. inline Fix24 operator+(Fix24&  f, Fix24&  g) 
  319. {
  320.   long sum = f.m + g.m;
  321.   if ( (f.m ^ sum) & (g.m ^ sum) & Fix24_msb )
  322.     f.overflow(sum);
  323.   return sum;
  324. }
  325.  
  326. inline Fix24 operator-(Fix24&  f, Fix24&  g) 
  327. {
  328.   long sum = f.m - g.m;
  329.   if ( (f.m ^ sum) & (-g.m ^ sum) & Fix24_msb )
  330.     f.overflow(sum);
  331.   return sum;
  332. }
  333.  
  334. inline Fix24 operator*(Fix24& a, long b)     
  335. { 
  336.   return a.m * b; 
  337. }
  338.  
  339. inline Fix24 operator*(long b, Fix24& a)     
  340. { 
  341.   return a * b; 
  342. }
  343.  
  344. inline Fix24 operator<<(Fix24& a, int b)     
  345. { 
  346.   return a.m << b; 
  347. }
  348.  
  349. inline Fix24 operator>>(Fix24& a, int b)     
  350. { 
  351.   return (a.m >> b) & 0xffffff00L; 
  352. }
  353.  
  354. inline  Fix24&  Fix24:: operator+=(Fix24&  f)
  355. { 
  356.   return *this = *this + f; 
  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<<=(int b)    
  375. { 
  376.   return *this = *this << b;
  377. }
  378.  
  379. inline Fix24&  Fix24:: operator>>=(int b)    
  380. { 
  381.   return *this = *this >> b;
  382. }
  383.  
  384. inline Fix24& Fix24::operator*=(long b)
  385. { 
  386.   return *this = *this * b; 
  387. }
  388.  
  389. inline int operator==(Fix24&  f, Fix24&  g)    
  390. { 
  391.   return f.m == g.m;
  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 istream&  operator>>(istream& s, Fix24&  f)
  420. { 
  421.   double d;
  422.   s >> d; 
  423.   f = d; 
  424.   return s; 
  425. }
  426.  
  427. inline ostream&  operator<<(ostream& s, Fix24&  f)
  428. { 
  429.   return s << double(f);
  430. }
  431.  
  432. inline Fix48::~Fix48() {}
  433.  
  434. inline Fix48::Fix48(twolongs i)        
  435. { 
  436.   m = i;
  437. }
  438.  
  439. inline Fix48:: operator double()        
  440. { 
  441. /*
  442.  * Note: can't simply do Fix48_div_u * m.u + Fix48_div_l * m.l, because
  443.  * m.u is signed and m.l is unsigned.
  444.  */
  445.   return (m.u >= 0)? Fix48_div_u * m.u + Fix48_div_l * m.l :
  446.       (Fix48_div_u * ((unsigned long)(m.u & 0xffffff00)) 
  447.       + Fix48_div_l * m.l) - 2;
  448. }
  449.  
  450. inline Fix48::Fix48()                
  451. { 
  452.   m.u = 0;
  453.   m.l = 0;
  454. }
  455.  
  456. inline Fix48::Fix48(Fix48& f)        
  457. { 
  458.   m = f.m;
  459. }
  460.  
  461. inline Fix48::Fix48(Fix24&  f)    
  462. { 
  463.   m.u = f.m;
  464.   m.l = 0;
  465. }
  466.  
  467. inline Fix48::Fix48(double d)        
  468. { 
  469.   m = assign(d);
  470. }
  471.  
  472. inline Fix48& Fix48::operator=(Fix48& f)    
  473. { 
  474.   m = f.m;
  475.   return *this; 
  476. }
  477.  
  478. inline Fix48& Fix48::operator=(Fix24&  f)    
  479. { 
  480.   m.u = f.m;
  481.   m.l = 0;
  482.   return *this;
  483. }
  484.  
  485. inline Fix48& Fix48::operator=(double d)    
  486. { 
  487.   m = assign(d);
  488.   return *this; 
  489. }
  490.  
  491. inline twolongs& mantissa(Fix48& f)    
  492. { 
  493.   return f.m;
  494. }
  495.  
  496. inline double value(Fix48& f)        
  497. { 
  498.   return double(f);
  499. }
  500.  
  501. inline Fix48 Fix48::operator+()         
  502. { 
  503.   return m;
  504. }
  505.  
  506. inline Fix48 Fix48::operator-()         
  507. { 
  508.   twolongs n;
  509.   n.l = -m.l;
  510.   n.u = ~m.u + ((n.l ^ m.l) & Fix24_msb ? 0 : Fix24_lsb);
  511.   return Fix48(n);
  512. }
  513.  
  514. inline Fix48 operator*(long b, Fix48& a)     
  515. { 
  516.   return a * b; 
  517. }
  518.  
  519. inline Fix48& Fix48::operator+=(Fix48& f)     
  520. { 
  521.   return *this = *this + f;
  522. }
  523.  
  524. inline Fix48& Fix48::operator-=(Fix48& f)     
  525. { 
  526.   return *this = *this - f;
  527. }
  528.  
  529. inline Fix48& Fix48::operator*=(long b)    
  530. { 
  531.   return *this = *this * b;
  532. }
  533.  
  534. inline Fix48& Fix48::operator<<=(int 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 int operator==(Fix48& f, Fix48& g)    
  545. { 
  546.   return f.m.u == g.m.u && f.m.l == g.m.l;
  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.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 istream& operator>>(istream& s, Fix48& f)
  575. { 
  576.   double d;
  577.   s >> d; 
  578.   f = d; 
  579.   return s; 
  580. }
  581.  
  582. inline ostream& operator<<(ostream& s, Fix48& f)
  583. { 
  584.   return s << double(f);
  585. }
  586.  
  587.  
  588. #endif
  589. #endif
  590.  
  591.