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