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