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