home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 7 / FreshFishVol7.bin / bbs / gnu / libg++-2.6-fsf.lha / libg++-2.6 / libg++ / src / Fix.cc < prev    next >
C/C++ Source or Header  |  1994-06-28  |  13KB  |  664 lines
  1. // This may look like C code, but it is really -*- C++ -*-
  2. /*
  3. Copyright (C) 1989 Free Software Foundation
  4.     written by Doug Lea (dl@rocky.oswego.edu)
  5.  
  6. This file is part of the GNU C++ Library.  This library is free
  7. software; you can redistribute it and/or modify it under the terms of
  8. the GNU Library General Public License as published by the Free
  9. Software Foundation; either version 2 of the License, or (at your
  10. option) any later version.  This library is distributed in the hope
  11. that it will be useful, but WITHOUT ANY WARRANTY; without even the
  12. implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  13. PURPOSE.  See the GNU Library General Public License for more details.
  14. You should have received a copy of the GNU Library General Public
  15. License along with this library; if not, write to the Free Software
  16. Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  17. */
  18. //
  19. // Fix.cc : variable length fixed point data type class functions
  20. //
  21.  
  22. #ifdef __GNUG__
  23. #pragma implementation
  24. #endif
  25. #include <Fix.h>
  26. #include <std.h>
  27. #include <Obstack.h>
  28. #include <AllocRing.h>
  29. #include <strstream.h>
  30.  
  31. // member constants
  32.  
  33. const _G_uint16_t Fix::min_length;
  34. const _G_uint16_t Fix::max_length;
  35. const double Fix::min_value;
  36. const double Fix::max_value;
  37.  
  38. // default parameters
  39.  
  40. _G_uint16_t Fix::default_length = 16;
  41. int    Fix::default_print_width = 8;
  42.  
  43. Fix::PEH Fix::overflow_handler = Fix::overflow_saturate;
  44.  
  45. Fix::Rep Fix::Rep_0    = { 16, 1, 1, { 0 } };
  46. Fix::Rep Fix::Rep_m1    = { 16, 1, 1, { 0x8000 } };
  47. Fix::Rep Fix::Rep_quotient_bump = { 16, 1, 1, { 0x4000 } };
  48.  
  49. // error handling
  50.  
  51. void
  52. Fix::default_error_handler(const char* msg)
  53. {
  54.   cerr << "Fix: " << msg << "\n";
  55.   abort();
  56. }
  57.  
  58. void
  59. Fix::default_range_error_handler(const char* msg)
  60. {
  61.   cerr << "Fix: range error in " << msg << "\n";
  62.   //abort();
  63. }
  64.  
  65. one_arg_error_handler_t 
  66.   Fix::error_handler = Fix::default_error_handler,
  67.   Fix::range_error_handler = Fix::default_range_error_handler;
  68.  
  69. one_arg_error_handler_t
  70. Fix::set_error_handler(one_arg_error_handler_t f)
  71. {
  72.   one_arg_error_handler_t old = error_handler;
  73.   error_handler = f;
  74.   return old;
  75. }
  76.  
  77. one_arg_error_handler_t
  78. Fix::set_range_error_handler(one_arg_error_handler_t f)
  79. {
  80.   one_arg_error_handler_t old = range_error_handler;
  81.   range_error_handler = f;
  82.   return old;
  83. }
  84.  
  85. void
  86. Fix::error(const char* msg)
  87. {
  88.   error_handler(msg);
  89. }
  90.  
  91. void
  92. Fix::range_error(const char* msg)
  93. {
  94.   range_error_handler(msg);
  95. }
  96.  
  97. // Fix::Rep allocation and initialization functions
  98.  
  99. static inline Fix::Rep*
  100. _new_Fix(_G_uint16_t len)
  101. {
  102.   int siz = (((_G_uint32_t) len + 15) >> 4);
  103.   if (siz <= 0) siz = 1;
  104.   unsigned int allocsiz = (sizeof(Fix::Rep) + (siz - 1) * sizeof(_G_uint16_t));
  105.   Fix::Rep* z = (Fix::Rep*)(new char[allocsiz]);
  106.   memset(z, 0, allocsiz);
  107.   z->len = len;
  108.   z->siz = siz;
  109.   z->ref = 1;
  110.   return z;
  111. }
  112.  
  113. Fix::Rep*
  114. Fix::new_Fix(_G_uint16_t len)
  115. {
  116.   return _new_Fix(len);
  117. }
  118.  
  119. Fix::Rep*
  120. Fix::new_Fix(_G_uint16_t len, const Rep* x)
  121. {
  122.   Rep* z = _new_Fix(len);
  123.   return copy(x,z);
  124. }
  125.  
  126. Fix::Rep*
  127. Fix::new_Fix(_G_uint16_t len, double d)
  128. {
  129.   Rep* z = _new_Fix(len);
  130.  
  131.   if ( d == max_value )
  132.   {
  133.     z->s[0] = 0x7fff;
  134.     for ( int i=1; i < z->siz; i++ )
  135.       z->s[i] = 0xffff;
  136.   }
  137.   else if ( d < min_value || d > max_value )
  138.     range_error("declaration");
  139.   else
  140.   {
  141.     if (d < 0)
  142.       d += 2.0;
  143.     d *= 32768;
  144.     for ( int i=0; i < z->siz; i++ )
  145.     {
  146.       z->s[i] = (_G_uint16_t )d;
  147.       d -= z->s[i];
  148.       d *= 65536;
  149.     }
  150.     if ( d >= 32768 )
  151.       z->s[z->siz-1]++;
  152.   }
  153.   mask(z);
  154.   return z;
  155. }
  156.  
  157. // convert to a double 
  158.  
  159. double
  160. value(const Fix& x)
  161. { 
  162.   double d = 0.0;
  163.   for ( int i=x.rep->siz-1; i >= 0; i-- )
  164.   {
  165.     d += x.rep->s[i];
  166.     d *= 1./65536.;
  167.   }
  168.   d *= 2.;
  169.   return d < 1. ? d : d - 2.;
  170. }
  171.  
  172. // extract mantissa to Integer
  173.  
  174. Integer
  175. mantissa(const Fix& x)
  176. {
  177.   Integer a = 1, b=1;
  178.   for ( int i=0; i < x.rep->siz; i++ )
  179.   {
  180.     a <<= 16;
  181.     a += x.rep->s[i];
  182.     b <<= 16;
  183.   }
  184.   return a-b;
  185. }
  186.  
  187. // comparison functions
  188.   
  189. inline static int
  190. docmp(const _G_uint16_t* x, const _G_uint16_t* y, int siz)
  191. {
  192.   int diff = (_G_int16_t )*x - (_G_int16_t )*y;
  193.   while ( --siz && !diff )
  194.     diff = (_G_int32_t )(_G_uint32_t )*++x - (_G_int32_t )(_G_uint32_t )*++y;
  195.   return diff;
  196. }
  197.  
  198. inline static int
  199. docmpz(const _G_uint16_t* x, int siz)
  200. {
  201.   while ( siz-- )
  202.     if ( *x++ ) return 1;
  203.   return 0;
  204. }
  205.  
  206. int
  207. Fix::compare(const Rep* x, const Rep* y)
  208. {
  209.   if ( x->siz == y->siz )
  210.     return docmp(x->s, y->s, x->siz);
  211.   else
  212.   {
  213.     int r;
  214.     const Rep* longer, *shorter;
  215.     if ( x->siz > y->siz )
  216.     {
  217.       longer = x;
  218.       shorter = y;
  219.       r = 1;
  220.     }
  221.     else
  222.     {
  223.       longer = y;
  224.       shorter = x;
  225.       r = -1;
  226.     }
  227.     int diff = docmp(x->s, y->s, shorter->siz);
  228.     if ( diff )
  229.       return diff;
  230.     else if ( docmpz(&longer->s[shorter->siz], longer->siz-shorter->siz) )
  231.       return r;
  232.     else
  233.       return 0;
  234.   }
  235. }
  236.  
  237. // arithmetic functions
  238.  
  239. Fix::Rep*
  240. Fix::add(const Rep* x, const Rep* y, Rep* r)
  241. {
  242.   _G_uint16_t xsign = x->s[0], ysign = y->s[0];
  243.   const Rep* longer, *shorter;
  244.   if ( x->len >= y->len )
  245.     longer = x, shorter = y;
  246.   else
  247.     longer = y, shorter = x;
  248.   if ( r == NULL )
  249.     r = new_Fix(longer->len);
  250.   for ( int i=r->siz-1; i >= longer->siz; i-- )
  251.     r->s[i] = 0;
  252.   for ( ; i >= shorter->siz; i-- )
  253.     r->s[i] = longer->s[i];
  254.   _G_uint32_t sum = 0, carry = 0;
  255.   for ( ; i >= 0; i-- )
  256.   {
  257.     sum = carry + (_G_uint32_t )x->s[i] + (_G_uint32_t )y->s[i];
  258.     carry = sum >> 16;
  259.     r->s[i] = sum;
  260.   }
  261.   if ( (xsign ^ sum) & (ysign ^ sum) & 0x8000 )
  262.     overflow_handler(r);
  263.   return r;
  264. }
  265.  
  266. Fix::Rep*
  267. Fix::subtract(const Rep* x, const Rep* y, Rep* r)
  268. {
  269.   _G_uint16_t xsign = x->s[0], ysign = y->s[0];
  270.   const Rep* longer, *shorter;
  271.   if ( x->len >= y->len )
  272.     longer = x, shorter = y;
  273.   else
  274.     longer = y, shorter = x;
  275.   if ( r == NULL )
  276.     r = new_Fix(longer->len);
  277.   for ( int i=r->siz-1; i >= longer->siz; i-- )
  278.     r->s[i] = 0;
  279.   for ( ; i >= shorter->siz; i-- )
  280.     r->s[i] = (longer == x ? x->s[i] : -y->s[i]);
  281.   _G_int16_t carry = 0;
  282.   _G_uint32_t sum = 0;
  283.   for ( ; i >= 0; i-- )
  284.   {
  285.     sum = (_G_int32_t )carry + (_G_uint32_t )x->s[i] - (_G_uint32_t )y->s[i];
  286.     carry = sum >> 16;
  287.     r->s[i] = sum;
  288.   }
  289.   if ( (xsign ^ sum) & (~ysign ^ sum) & 0x8000 )
  290.     overflow_handler(r);
  291.   return r;
  292. }
  293.  
  294. Fix::Rep*
  295. Fix::multiply(const Rep* x, const Rep* y, Rep* r)
  296. {
  297.   if ( r == NULL )
  298.     r = new_Fix(x->len + y->len);
  299.   int xsign = x->s[0] & 0x8000,
  300.     ysign = y->s[0] & 0x8000;
  301.   Fix X(x->len), Y(y->len);
  302.   if ( xsign )
  303.     x = negate(x,X.rep);
  304.   if ( ysign )
  305.     y = negate(y,Y.rep);
  306.   for ( int i=0; i < r->siz; i++ )
  307.     r->s[i] = 0;
  308.   for ( i=x->siz-1; i >= 0; i-- )
  309.   {
  310.     _G_uint32_t carry = 0;
  311.     for ( int j=y->siz-1; j >= 0; j-- ) 
  312.     {
  313.       int k = i + j + 1;
  314.       _G_uint32_t a = (_G_uint32_t )x->s[i] * (_G_uint32_t )y->s[j];
  315.       _G_uint32_t b = ((a << 1) & 0xffff) + carry;
  316.       if ( k < r->siz )
  317.       {
  318.     b += r->s[k];
  319.         r->s[k] = b;
  320.       }
  321.       if ( k < (int)r->siz + 1 )
  322.         carry = (a >> 15) + (b >> 16);
  323.     }
  324.     r->s[i] = carry;
  325.   }
  326.   if ( xsign != ysign )
  327.     negate(r,r);
  328.   return r;
  329. }
  330.  
  331. Fix::Rep*
  332. Fix::multiply(const Rep* x, int y, Rep* r)
  333. {
  334.   if ( y != (_G_int16_t )y )
  335.     range_error("multiply by int -- int too large");
  336.   if ( r == NULL )
  337.     r = new_Fix(x->len);
  338.   for ( int i=r->siz-1; i >= x->siz; i-- )
  339.     r->s[i] = 0;
  340.   _G_int32_t a, carry = 0;
  341.   for ( ; i > 0; i-- )
  342.   {
  343.     a = (_G_int32_t) (_G_uint32_t )x->s[i] * y + carry;
  344.     r->s[i] = a;
  345.     carry = a >> 16;        // assumes arithmetic right shift
  346.   }
  347.   a = (_G_int32_t) (_G_int16_t )x->s[0] * y + carry;
  348.   r->s[0] = a;
  349.   a &= 0xffff8000L;
  350.   if ( a != 0xffff8000L && a != 0L ) {
  351.     r->s[0] = 0x8000 ^ x->s[0] ^ y;
  352.     overflow_handler(r);
  353.   }
  354.   return r;
  355. }
  356.  
  357. Fix::Rep*
  358. Fix::divide(const Rep* x, const Rep* y, Rep* q, Rep* r)
  359. {
  360.   int xsign = x->s[0] & 0x8000, 
  361.     ysign = y->s[0] & 0x8000;
  362.   if ( q == NULL )
  363.     q = new_Fix(x->len);
  364.   copy(&Rep_0,q);
  365.   if ( r == NULL )
  366.     r = new_Fix(x->len + y->len - 1);
  367.   if ( xsign )
  368.     negate(x,r);
  369.   else
  370.     copy(x,r);
  371.   Fix Y(y->len);
  372.   Rep* y2 = ( ysign ? negate(y,Y.rep) : copy(y,Y.rep) );
  373.   if ( !compare(y2) )
  374.     range_error("division -- division by zero");
  375.   else if ( compare(x,y2) >= 0 )
  376.