home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / files / gnu / g__inc / xfix16.h < prev    next >
Encoding:
C/C++ Source or Header  |  1993-07-23  |  12.5 KB  |  643 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 _Fix16_h
  21. #ifdef __GNUG__
  22. #pragma once
  23. #pragma interface
  24. #endif
  25. #define _Fix16_h 1
  26.  
  27. #include <stream.h>
  28. #include <std.h>
  29.  
  30. // constant definitions
  31.  
  32. #define Fix16_fs     ((double)((unsigned)(1 << 15)))
  33.  
  34. #define Fix16_msb    (1 << 15)
  35. #define Fix16_m_max    ((1 << 15) - 1)
  36. #define Fix16_m_min    ((short)(1 << 15))
  37.  
  38. #define Fix16_mult    Fix16_fs
  39. #define Fix16_div    (1./Fix16_fs)
  40. #define Fix16_max    (1. - .5/Fix16_fs)
  41. #define Fix16_min    (-1.)
  42.  
  43.  
  44. #define Fix32_fs     ((double)((unsigned long)(1 << 31)))
  45.  
  46. #define Fix32_msb    ((unsigned long)(1 << 31))
  47. #define Fix32_m_max    ((long)((1L << 31) - 1L))
  48. #define Fix32_m_min    ((long)(1 << 31))
  49.  
  50. #define Fix32_mult    Fix32_fs
  51. #define Fix32_div    (1./Fix32_fs)
  52. #define Fix32_max    (1. - .5/Fix32_fs)
  53. #define Fix32_min    (-1.)
  54.  
  55.  
  56. //
  57. // Fix16    class: 16-bit Fixed point data type
  58. //
  59. //    consists of a 16-bit mantissa (sign bit & 15 data bits).
  60. //
  61.  
  62. class Fix16 
  63. { 
  64.   friend class          Fix32;
  65.  
  66.   short                 m;
  67.  
  68.   short                 round(double d);
  69.   short                 assign(double d);
  70.                         Fix16(short i);
  71.                         Fix16(int i);
  72.  
  73.          operator       double();
  74.  
  75.  
  76. public:
  77.                         Fix16();
  78.                         Fix16(Fix16&  f);
  79.                         Fix16(double d);
  80.                         Fix16(Fix32& f);
  81.  
  82.                         ~Fix16();
  83.  
  84.   Fix16&                operator=(Fix16&  f);
  85.   Fix16&                operator=(double d);
  86.   Fix16&                operator=(Fix32& f);
  87.  
  88.   friend short&         mantissa(Fix16&  f);
  89.   friend double         value(Fix16&  f);
  90.  
  91.   Fix16                 operator +  ();
  92.   Fix16                 operator -  ();
  93.  
  94.   friend Fix16          operator +  (Fix16&  f, Fix16&  g);
  95.   friend Fix16          operator -  (Fix16&  f, Fix16&  g);
  96.   friend Fix32          operator *  (Fix16&  f, Fix16&  g);
  97.   friend Fix16          operator /  (Fix16&  f, Fix16&  g);
  98.   friend Fix16          operator << (Fix16&  f, int b);
  99.   friend Fix16          operator >> (Fix16&  f, int b);
  100.  
  101.   Fix16&                operator += (Fix16&  f);
  102.   Fix16&                operator -= (Fix16&  f);
  103.   Fix16&                operator *= (Fix16& );
  104.   Fix16&                operator /= (Fix16&  f);
  105.   
  106.   Fix16&                operator <<=(int b);
  107.   Fix16&                operator >>=(int b);
  108.  
  109.   friend int            operator == (Fix16&  f, Fix16&  g);
  110.   friend int            operator != (Fix16&  f, Fix16&  g);
  111.   friend int            operator >= (Fix16&  f, Fix16&  g);
  112.   friend int            operator <= (Fix16&  f, Fix16&  g);
  113.   friend int            operator >  (Fix16&  f, Fix16&  g);
  114.   friend int            operator <  (Fix16&  f, Fix16&  g);
  115.  
  116.   friend istream&       operator >> (istream& s, Fix16&  f);
  117.   friend ostream&       operator << (ostream& s, Fix16&  f);
  118.  
  119.   void                  overflow(short&);
  120.   void                  range_error(short&);
  121.  
  122.   friend Fix16          operator *  (Fix16&  f, int g);
  123.   friend Fix16          operator *  (int g, Fix16&  f);
  124.   Fix16&                operator *= (int g);
  125. };
  126.  
  127.  
  128. //
  129. // Fix32 class: 32-bit Fixed point data type
  130. //
  131. //    consists of a 32-bit mantissa (sign bit & 31 data bits).
  132. //
  133.  
  134. class Fix32 
  135. { 
  136.   friend class         Fix16;
  137.  
  138.   long                 m;
  139.  
  140.   long                 round(double d);
  141.   long                 assign(double d);
  142.  
  143.                        Fix32(long i);
  144.                        operator double();
  145.  
  146.  
  147. public:
  148.                        Fix32();
  149.                        Fix32(Fix32& f);
  150.                        Fix32(Fix16&  f);
  151.                        Fix32(double d);
  152.                        ~Fix32();
  153.  
  154.   Fix32&               operator =  (Fix32& f);
  155.   Fix32&               operator =  (Fix16&  f);
  156.   Fix32&               operator =  (double d);
  157.  
  158.   friend long&         mantissa(Fix32& f);
  159.   friend double        value(Fix32& f);
  160.  
  161.   Fix32                operator +  ();
  162.   Fix32                operator -  ();
  163.  
  164.   friend Fix32         operator +  (Fix32& f, Fix32& g);
  165.   friend Fix32         operator -  (Fix32& f, Fix32& g);
  166.   friend Fix32         operator *  (Fix32& f, Fix32& g);
  167.   friend Fix32         operator /  (Fix32& f, Fix32& g);
  168.   friend Fix32         operator << (Fix32& f, int b);
  169.   friend Fix32         operator >> (Fix32& f, int b);
  170.  
  171.   friend Fix32         operator *  (Fix16&  f, Fix16&  g);
  172.  
  173.   Fix32&               operator += (Fix32& f);
  174.   Fix32&               operator -= (Fix32& f);
  175.   Fix32&               operator *= (Fix32& f);
  176.   Fix32&               operator /= (Fix32& f);
  177.   Fix32&               operator <<=(int b);
  178.   Fix32&               operator >>=(int b);
  179.  
  180.   friend int           operator == (Fix32& f, Fix32& g);
  181.   friend int           operator != (Fix32& f, Fix32& g);
  182.   friend int           operator >= (Fix32& f, Fix32& g);
  183.   friend int           operator <= (Fix32& f, Fix32& g);
  184.   friend int           operator >  (Fix32& f, Fix32& g);
  185.   friend int           operator <  (Fix32& f, Fix32& g);
  186.  
  187.   friend istream&      operator >> (istream& s, Fix32& f);
  188.   friend ostream&      operator << (ostream& s, Fix32& f);
  189.  
  190.   void                 overflow(long& i);
  191.   void                 range_error(long& i);
  192.  
  193.   friend Fix32          operator *  (Fix32&  f, long g);
  194.   friend Fix32          operator *  (long g, Fix32&  f);
  195.   Fix32&                operator *= (long g);
  196. };
  197.  
  198. // active error handler declarations
  199.  
  200. typedef void (*Fix16_peh)(short&);
  201. typedef void (*Fix32_peh)(long&);
  202.  
  203. extern Fix16_peh Fix16_overflow_handler;
  204. extern Fix32_peh Fix32_overflow_handler;
  205.  
  206. extern Fix16_peh Fix16_range_error_handler;
  207. extern Fix32_peh Fix32_range_error_handler;
  208.  
  209. #if defined(SHORT_NAMES) || defined(VMS)
  210. #define    set_overflow_handler    sohndl
  211. #define set_range_error_handler    srnghdl
  212. #endif
  213.  
  214.  
  215. // error handler declarations
  216.  
  217. extern Fix16_peh set_Fix16_overflow_handler(Fix16_peh);
  218. extern Fix32_peh set_Fix32_overflow_handler(Fix32_peh);
  219. extern void set_overflow_handler(Fix16_peh, Fix32_peh);
  220.  
  221. extern Fix16_peh set_Fix16_range_error_handler(Fix16_peh);
  222. extern Fix32_peh set_Fix32_range_error_handler(Fix32_peh);
  223. extern void set_range_error_handler(Fix16_peh, Fix32_peh);
  224.  
  225. extern void
  226.   Fix16_ignore(short&),
  227.   Fix16_overflow_saturate(short&),
  228.   Fix16_overflow_warning_saturate(short&),
  229.   Fix16_warning(short&),
  230.   Fix16_abort(short&);
  231.  
  232. extern void
  233.   Fix32_ignore(long&),
  234.   Fix32_overflow_saturate(long&),
  235.   Fix32_overflow_warning_saturate(long&),
  236.   Fix32_warning(long&),
  237.   Fix32_abort(long&);
  238.  
  239. #if defined(__OPTIMIZE__) || defined(USE_LIBGXX_INLINES)
  240.  
  241. inline Fix16::~Fix16() {}
  242.  
  243. inline short Fix16::round(double d)
  244. { 
  245.   return short( (d >= 0)? d + 0.5 : d - 0.5); 
  246. }
  247.  
  248. inline Fix16::Fix16(short i)        
  249. { 
  250.   m = i; 
  251. }
  252.  
  253. inline Fix16::Fix16(int i)        
  254. { 
  255.   m = i; 
  256. }
  257.  
  258. inline Fix16::operator double() 
  259. { 
  260.   return  Fix16_div * m; 
  261. }
  262.  
  263. inline Fix16::Fix16()                 
  264. { 
  265.   m = 0; 
  266. }
  267.  
  268. inline Fix16::Fix16(Fix16&  f)        
  269. { 
  270.   m = f.m; 
  271. }
  272.  
  273. inline Fix16::Fix16(double d)        
  274. {
  275.   m = assign(d);
  276. }
  277.  
  278.  
  279. inline Fix16&  Fix16::operator=(Fix16&  f)    
  280. { 
  281.   m = f.m; 
  282.   return *this; 
  283. }
  284.  
  285. inline Fix16&  Fix16::operator=(double d) 
  286. { 
  287.   m = assign(d); 
  288.   return *this; 
  289. }
  290.  
  291.  
  292. inline Fix32::Fix32()                
  293. { 
  294.   m = 0;
  295. }
  296.  
  297. inline Fix32::Fix32(long i)        
  298. { 
  299.   m = i;
  300. }
  301.  
  302. inline Fix32:: operator double()        
  303. { 
  304.   return Fix32_div * m;
  305. }
  306.  
  307.  
  308. inline Fix32::Fix32(Fix32& f)        
  309. { 
  310.   m = f.m;
  311. }
  312.  
  313. inline Fix32::Fix32(Fix16&  f)    
  314. { 
  315.   m = long(f.m) << 16;
  316. }
  317.  
  318. inline Fix32::Fix32(double d)        
  319. { 
  320.   m = assign(d);
  321. }
  322.  
  323. inline Fix16::Fix16(Fix32& f)        
  324. { 
  325.   m = f.m >> 16; 
  326. }
  327.  
  328.  
  329. inline Fix16&  Fix16::operator=(Fix32& f)
  330. { 
  331.   m = f.m >> 16; 
  332.   return *this; 
  333. }
  334.  
  335. inline Fix32& Fix32::operator=(Fix32& f)    
  336. { 
  337.   m = f.m;
  338.   return *this; 
  339. }
  340.  
  341. inline Fix32& Fix32::operator=(Fix16&  f)    
  342. { 
  343.   m = long(f.m) << 16;
  344.   return *this;
  345. }
  346.  
  347. inline Fix32& Fix32::operator=(double d)    
  348. { 
  349.   m = assign(d);
  350.   return *this; 
  351. }
  352.  
  353. inline short& mantissa(Fix16&  f)    
  354. { 
  355.   return f.m; 
  356. }
  357.  
  358. inline double value(Fix16&  f)        
  359. { 
  360.   return double(f); 
  361. }
  362.  
  363. inline Fix16 Fix16::operator+()         
  364. { 
  365.   return m; 
  366. }
  367.  
  368. inline Fix16 Fix16::operator-()         
  369. { 
  370.   return -m; 
  371. }
  372.  
  373. inline Fix16 operator+(Fix16&  f, Fix16&  g) 
  374. {
  375.   short sum = f.m + g.m;
  376.   if ( (f.m ^ sum) & (g.m ^ sum) & Fix16_msb )
  377.     f.overflow(sum);
  378.   return sum;
  379. }
  380.  
  381. inline Fix16 operator-(Fix16&  f, Fix16&  g) 
  382. {
  383.   short sum = f.m - g.m;
  384.   if ( (f.m ^ sum) & (-g.m ^ sum) & Fix16_msb )
  385.     f.overflow(sum);
  386.   return sum;
  387. }
  388.  
  389. inline Fix32 operator*(Fix16&  f, Fix16&  g)
  390. { 
  391.   return Fix32( long( long(f.m) * long(g.m) << 1)); 
  392. }
  393.  
  394. inline Fix16 operator<<(Fix16& a, int b)     
  395. { 
  396.   return a.m << b; 
  397. }
  398.  
  399. inline Fix16 operator>>(Fix16& a, int b)     
  400. { 
  401.   return a.m >> b; 
  402. }
  403.  
  404. inline  Fix16&  Fix16:: operator+=(Fix16&  f)
  405. { 
  406.   return *this = *this + f; 
  407. }
  408.  
  409. inline Fix16&  Fix16:: operator-=(Fix16&  f)     
  410. { 
  411.   return *this = *this - f; 
  412. }
  413.  
  414. inline Fix16& Fix16::operator*=(Fix16& f)     
  415. { 
  416.   return *this = *this * f; 
  417. }
  418.  
  419. inline Fix16&  Fix16:: operator/=(Fix16&  f)     
  420. { 
  421.   return *this = *this / f; 
  422. }
  423.  
  424. inline Fix16&  Fix16:: operator<<=(int b)    
  425. { 
  426.   return *this = *this << b;
  427. }
  428.  
  429. inline Fix16&  Fix16:: operator>>=(int b)    
  430. { 
  431.   return *this = *this >> b;
  432. }
  433.  
  434. inline int operator==(Fix16&  f, Fix16&  g)    
  435. { 
  436.   return f.m == g.m;
  437. }
  438.  
  439. inline int operator!=(Fix16&  f, Fix16&  g)    
  440. { 
  441.   return f.m != g.m;
  442. }
  443.  
  444. inline int operator>=(Fix16&  f, Fix16&  g)    
  445. { 
  446.   return f.m >= g.m;
  447. }
  448.  
  449. inline int operator<=(Fix16&  f, Fix16&  g)    
  450. { 
  451.   return f.m <= g.m;
  452. }
  453.  
  454. inline int operator>(Fix16&  f, Fix16&  g)    
  455. { 
  456.   return f.m > g.m;
  457. }
  458.  
  459. inline int operator<(Fix16&  f, Fix16&  g)    
  460. { 
  461.   return f.m < g.m;
  462. }
  463.  
  464. inline istream&  operator>>(istream& s, Fix16&  f)
  465. { 
  466.   double d;
  467.   s >> d; 
  468.   f = d; 
  469.   return s; 
  470. }
  471.  
  472. inline ostream&  operator<<(ostream& s, Fix16&  f)
  473. { 
  474.   return s << double(f);
  475. }
  476.  
  477.  
  478. inline Fix16 operator*(Fix16&  f, int g)
  479. {
  480.   return Fix16(short(f.m * g));
  481. }
  482.  
  483. inline Fix16 operator*(int g, Fix16&  f)
  484. {
  485.   return f * g;
  486. }
  487.  
  488.  
  489. inline Fix16& Fix16::operator*=(int g)
  490. {
  491.   return *this = *this * g;
  492. }
  493.  
  494. inline Fix32::~Fix32() {}
  495.  
  496. inline long Fix32::round(double d)
  497. { 
  498.   return long( (d >= 0)? d + 0.5 : d - 0.5);
  499. }
  500.  
  501.  
  502. inline long& mantissa(Fix32& f)    
  503. { 
  504.   return f.m;
  505. }
  506.  
  507. inline double value(Fix32& f)        
  508. { 
  509.   return double(f);
  510. }
  511.  
  512. inline Fix32 Fix32::operator+()         
  513. { 
  514.   return m;
  515. }
  516.  
  517. inline Fix32 Fix32::operator-()         
  518. { 
  519.   return -m;
  520. }
  521.  
  522. inline Fix32 operator+(Fix32& f, Fix32& g) 
  523. {
  524.   long sum = f.m + g.m;
  525.   if ( (f.m ^ sum) & (g.m ^ sum) & Fix32_msb )
  526.     f.overflow(sum);
  527.   return sum;
  528. }
  529.  
  530. inline Fix32 operator-(Fix32& f, Fix32& g) 
  531. {
  532.   long sum = f.m - g.m;
  533.   if ( (f.m ^ sum) & (-g.m ^ sum) & Fix32_msb )
  534.     f.overflow(sum);
  535.   return sum;
  536. }
  537.  
  538. inline Fix32 operator<<(Fix32& a, int b)     
  539. { 
  540.   return a.m << b;
  541. }
  542.  
  543. inline Fix32 operator>>(Fix32& a, int b)     
  544. { 
  545.   return a.m >> b;
  546. }
  547.  
  548. inline Fix32& Fix32::operator+=(Fix32& f)     
  549. { 
  550.   return *this = *this + f;
  551. }
  552.  
  553. inline Fix32& Fix32::operator-=(Fix32& f)     
  554. { 
  555.   return *this = *this - f;
  556. }
  557.  
  558. inline Fix32& Fix32::operator*=(Fix32& f)     
  559. { 
  560.   return *this = *this * f;
  561. }
  562.  
  563. inline Fix32& Fix32::operator/=(Fix32& f)     
  564. { 
  565.   return *this = *this / f;
  566. }
  567.  
  568.  
  569. inline Fix32& Fix32::operator<<=(int b)    
  570. { 
  571.   return *this = *this << b;
  572. }
  573.  
  574. inline Fix32& Fix32::operator>>=(int b)    
  575. { 
  576.   return *this = *this >> b;
  577. }
  578.  
  579. inline int operator==(Fix32& f, Fix32& g)    
  580. { 
  581.   return f.m == g.m;
  582. }
  583.  
  584. inline int operator!=(Fix32& f, Fix32& g)    
  585. { 
  586.   return f.m != g.m;
  587. }
  588.  
  589. inline int operator>=(Fix32& f, Fix32& g)    
  590. { 
  591.   return f.m >= g.m;
  592. }
  593.  
  594. inline int operator<=(Fix32& f, Fix32& g)    
  595. { 
  596.   return f.m <= g.m;
  597. }
  598.  
  599. inline int operator>(Fix32& f, Fix32& g)    
  600. { 
  601.   return f.m > g.m;
  602. }
  603.  
  604. inline int operator<(Fix32& f, Fix32& g)    
  605. { 
  606.   return f.m < g.m;
  607. }
  608.  
  609. inline istream& operator>>(istream& s, Fix32& f)
  610. { 
  611.   double d;
  612.   s >> d; 
  613.   f = d; 
  614.   return s; 
  615. }
  616.  
  617. inline ostream& operator<<(ostream& s, Fix32& f)
  618. { 
  619.   return s << double(f);
  620. }
  621.  
  622. inline Fix32 operator*(Fix32&  f, long g)
  623. {
  624.   return Fix32(long(f.m * g));
  625. }
  626.  
  627. inline Fix32 operator*(long g, Fix32&  f)
  628. {
  629.   return f * g;
  630. }
  631.  
  632.  
  633.  
  634. inline Fix32& Fix32::operator*=(long g)
  635. {
  636.   return *this = *this * g;
  637. }
  638.  
  639.  
  640. #endif
  641. #endif
  642.  
  643.