/****************************************************************
|
/****************************************************************
|
*
|
*
|
* The author of this software is David M. Gay.
|
* The author of this software is David M. Gay.
|
*
|
*
|
* Copyright (c) 1991 by AT&T.
|
* Copyright (c) 1991 by AT&T.
|
*
|
*
|
* Permission to use, copy, modify, and distribute this software for any
|
* Permission to use, copy, modify, and distribute this software for any
|
* purpose without fee is hereby granted, provided that this entire notice
|
* purpose without fee is hereby granted, provided that this entire notice
|
* is included in all copies of any software which is or includes a copy
|
* is included in all copies of any software which is or includes a copy
|
* or modification of this software and in all copies of the supporting
|
* or modification of this software and in all copies of the supporting
|
* documentation for such software.
|
* documentation for such software.
|
*
|
*
|
* THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
|
* THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
|
* WARRANTY. IN PARTICULAR, NEITHER THE AUTHOR NOR AT&T MAKES ANY
|
* WARRANTY. IN PARTICULAR, NEITHER THE AUTHOR NOR AT&T MAKES ANY
|
* REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
|
* REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
|
* OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
|
* OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
|
*
|
*
|
***************************************************************/
|
***************************************************************/
|
|
|
/* Please send bug reports to
|
/* Please send bug reports to
|
David M. Gay
|
David M. Gay
|
AT&T Bell Laboratories, Room 2C-463
|
AT&T Bell Laboratories, Room 2C-463
|
600 Mountain Avenue
|
600 Mountain Avenue
|
Murray Hill, NJ 07974-2070
|
Murray Hill, NJ 07974-2070
|
U.S.A.
|
U.S.A.
|
dmg@research.att.com or research!dmg
|
dmg@research.att.com or research!dmg
|
*/
|
*/
|
|
|
/* strtod for IEEE-, VAX-, and IBM-arithmetic machines.
|
/* strtod for IEEE-, VAX-, and IBM-arithmetic machines.
|
*
|
*
|
* This strtod returns a nearest machine number to the input decimal
|
* This strtod returns a nearest machine number to the input decimal
|
* string (or sets errno to ERANGE). With IEEE arithmetic, ties are
|
* string (or sets errno to ERANGE). With IEEE arithmetic, ties are
|
* broken by the IEEE round-even rule. Otherwise ties are broken by
|
* broken by the IEEE round-even rule. Otherwise ties are broken by
|
* biased rounding (add half and chop).
|
* biased rounding (add half and chop).
|
*
|
*
|
* Inspired loosely by William D. Clinger's paper "How to Read Floating
|
* Inspired loosely by William D. Clinger's paper "How to Read Floating
|
* Point Numbers Accurately" [Proc. ACM SIGPLAN '90, pp. 92-101].
|
* Point Numbers Accurately" [Proc. ACM SIGPLAN '90, pp. 92-101].
|
*
|
*
|
* Modifications:
|
* Modifications:
|
*
|
*
|
* 1. We only require IEEE, IBM, or VAX double-precision
|
* 1. We only require IEEE, IBM, or VAX double-precision
|
* arithmetic (not IEEE double-extended).
|
* arithmetic (not IEEE double-extended).
|
* 2. We get by with floating-point arithmetic in a case that
|
* 2. We get by with floating-point arithmetic in a case that
|
* Clinger missed -- when we're computing d * 10^n
|
* Clinger missed -- when we're computing d * 10^n
|
* for a small integer d and the integer n is not too
|
* for a small integer d and the integer n is not too
|
* much larger than 22 (the maximum integer k for which
|
* much larger than 22 (the maximum integer k for which
|
* we can represent 10^k exactly), we may be able to
|
* we can represent 10^k exactly), we may be able to
|
* compute (d*10^k) * 10^(e-k) with just one roundoff.
|
* compute (d*10^k) * 10^(e-k) with just one roundoff.
|
* 3. Rather than a bit-at-a-time adjustment of the binary
|
* 3. Rather than a bit-at-a-time adjustment of the binary
|
* result in the hard case, we use floating-point
|
* result in the hard case, we use floating-point
|
* arithmetic to determine the adjustment to within
|
* arithmetic to determine the adjustment to within
|
* one bit; only in really hard cases do we need to
|
* one bit; only in really hard cases do we need to
|
* compute a second residual.
|
* compute a second residual.
|
* 4. Because of 3., we don't need a large table of powers of 10
|
* 4. Because of 3., we don't need a large table of powers of 10
|
* for ten-to-e (just some small tables, e.g. of 10^k
|
* for ten-to-e (just some small tables, e.g. of 10^k
|
* for 0 <= k <= 22).
|
* for 0 <= k <= 22).
|
*/
|
*/
|
|
|
/*
|
/*
|
* #define IEEE_8087 for IEEE-arithmetic machines where the least
|
* #define IEEE_8087 for IEEE-arithmetic machines where the least
|
* significant byte has the lowest address.
|
* significant byte has the lowest address.
|
* #define IEEE_MC68k for IEEE-arithmetic machines where the most
|
* #define IEEE_MC68k for IEEE-arithmetic machines where the most
|
* significant byte has the lowest address.
|
* significant byte has the lowest address.
|
* #define Sudden_Underflow for IEEE-format machines without gradual
|
* #define Sudden_Underflow for IEEE-format machines without gradual
|
* underflow (i.e., that flush to zero on underflow).
|
* underflow (i.e., that flush to zero on underflow).
|
* #define IBM for IBM mainframe-style floating-point arithmetic.
|
* #define IBM for IBM mainframe-style floating-point arithmetic.
|
* #define VAX for VAX-style floating-point arithmetic.
|
* #define VAX for VAX-style floating-point arithmetic.
|
* #define Unsigned_Shifts if >> does treats its left operand as unsigned.
|
* #define Unsigned_Shifts if >> does treats its left operand as unsigned.
|
* #define No_leftright to omit left-right logic in fast floating-point
|
* #define No_leftright to omit left-right logic in fast floating-point
|
* computation of dtoa.
|
* computation of dtoa.
|
* #define Check_FLT_ROUNDS if FLT_ROUNDS can assume the values 2 or 3.
|
* #define Check_FLT_ROUNDS if FLT_ROUNDS can assume the values 2 or 3.
|
* #define RND_PRODQUOT to use rnd_prod and rnd_quot (assembly routines
|
* #define RND_PRODQUOT to use rnd_prod and rnd_quot (assembly routines
|
* that use extended-precision instructions to compute rounded
|
* that use extended-precision instructions to compute rounded
|
* products and quotients) with IBM.
|
* products and quotients) with IBM.
|
* #define ROUND_BIASED for IEEE-format with biased rounding.
|
* #define ROUND_BIASED for IEEE-format with biased rounding.
|
* #define Inaccurate_Divide for IEEE-format with correctly rounded
|
* #define Inaccurate_Divide for IEEE-format with correctly rounded
|
* products but inaccurate quotients, e.g., for Intel i860.
|
* products but inaccurate quotients, e.g., for Intel i860.
|
* #define Just_16 to store 16 bits per 32-bit long when doing high-precision
|
* #define Just_16 to store 16 bits per 32-bit long when doing high-precision
|
* integer arithmetic. Whether this speeds things up or slows things
|
* integer arithmetic. Whether this speeds things up or slows things
|
* down depends on the machine and the number being converted.
|
* down depends on the machine and the number being converted.
|
*/
|
*/
|
|
|
#include <_ansi.h>
|
#include <_ansi.h>
|
#include <stdlib.h>
|
#include <stdlib.h>
|
#include <string.h>
|
#include <string.h>
|
#include <reent.h>
|
#include <reent.h>
|
#include "mprec.h"
|
#include "mprec.h"
|
|
|
/* This is defined in sys/reent.h as (sizeof (size_t) << 3) now, as in NetBSD.
|
/* This is defined in sys/reent.h as (sizeof (size_t) << 3) now, as in NetBSD.
|
The old value of 15 was wrong and made newlib vulnerable against buffer
|
The old value of 15 was wrong and made newlib vulnerable against buffer
|
overrun attacks (CVE-2009-0689), same as other implementations of gdtoa
|
overrun attacks (CVE-2009-0689), same as other implementations of gdtoa
|
based on BSD code.
|
based on BSD code.
|
#define _Kmax 15
|
#define _Kmax 15
|
*/
|
*/
|
|
|
_Bigint *
|
_Bigint *
|
_DEFUN (Balloc, (ptr, k), struct _reent *ptr _AND int k)
|
_DEFUN (Balloc, (ptr, k), struct _reent *ptr _AND int k)
|
{
|
{
|
int x;
|
int x;
|
_Bigint *rv ;
|
_Bigint *rv ;
|
|
|
_REENT_CHECK_MP(ptr);
|
_REENT_CHECK_MP(ptr);
|
if (_REENT_MP_FREELIST(ptr) == NULL)
|
if (_REENT_MP_FREELIST(ptr) == NULL)
|
{
|
{
|
/* Allocate a list of pointers to the mprec objects */
|
/* Allocate a list of pointers to the mprec objects */
|
_REENT_MP_FREELIST(ptr) = (struct _Bigint **) _calloc_r (ptr,
|
_REENT_MP_FREELIST(ptr) = (struct _Bigint **) _calloc_r (ptr,
|
sizeof (struct _Bigint *),
|
sizeof (struct _Bigint *),
|
_Kmax + 1);
|
_Kmax + 1);
|
if (_REENT_MP_FREELIST(ptr) == NULL)
|
if (_REENT_MP_FREELIST(ptr) == NULL)
|
{
|
{
|
return NULL;
|
return NULL;
|
}
|
}
|
}
|
}
|
|
|
if ((rv = _REENT_MP_FREELIST(ptr)[k]) != 0)
|
if ((rv = _REENT_MP_FREELIST(ptr)[k]) != 0)
|
{
|
{
|
_REENT_MP_FREELIST(ptr)[k] = rv->_next;
|
_REENT_MP_FREELIST(ptr)[k] = rv->_next;
|
}
|
}
|
else
|
else
|
{
|
{
|
x = 1 << k;
|
x = 1 << k;
|
/* Allocate an mprec Bigint and stick in in the freelist */
|
/* Allocate an mprec Bigint and stick in in the freelist */
|
rv = (_Bigint *) _calloc_r (ptr,
|
rv = (_Bigint *) _calloc_r (ptr,
|
1,
|
1,
|
sizeof (_Bigint) +
|
sizeof (_Bigint) +
|
(x-1) * sizeof(rv->_x));
|
(x-1) * sizeof(rv->_x));
|
if (rv == NULL) return NULL;
|
if (rv == NULL) return NULL;
|
rv->_k = k;
|
rv->_k = k;
|
rv->_maxwds = x;
|
rv->_maxwds = x;
|
}
|
}
|
rv->_sign = rv->_wds = 0;
|
rv->_sign = rv->_wds = 0;
|
return rv;
|
return rv;
|
}
|
}
|
|
|
void
|
void
|
_DEFUN (Bfree, (ptr, v), struct _reent *ptr _AND _Bigint * v)
|
_DEFUN (Bfree, (ptr, v), struct _reent *ptr _AND _Bigint * v)
|
{
|
{
|
_REENT_CHECK_MP(ptr);
|
_REENT_CHECK_MP(ptr);
|
if (v)
|
if (v)
|
{
|
{
|
v->_next = _REENT_MP_FREELIST(ptr)[v->_k];
|
v->_next = _REENT_MP_FREELIST(ptr)[v->_k];
|
_REENT_MP_FREELIST(ptr)[v->_k] = v;
|
_REENT_MP_FREELIST(ptr)[v->_k] = v;
|
}
|
}
|
}
|
}
|
|
|
_Bigint *
|
_Bigint *
|
_DEFUN (multadd, (ptr, b, m, a),
|
_DEFUN (multadd, (ptr, b, m, a),
|
struct _reent *ptr _AND
|
struct _reent *ptr _AND
|
_Bigint * b _AND
|
_Bigint * b _AND
|
int m _AND
|
int m _AND
|
int a)
|
int a)
|
{
|
{
|
int i, wds;
|
int i, wds;
|
__ULong *x, y;
|
__ULong *x, y;
|
#ifdef Pack_32
|
#ifdef Pack_32
|
__ULong xi, z;
|
__ULong xi, z;
|
#endif
|
#endif
|
_Bigint *b1;
|
_Bigint *b1;
|
|
|
wds = b->_wds;
|
wds = b->_wds;
|
x = b->_x;
|
x = b->_x;
|
i = 0;
|
i = 0;
|
do
|
do
|
{
|
{
|
#ifdef Pack_32
|
#ifdef Pack_32
|
xi = *x;
|
xi = *x;
|
y = (xi & 0xffff) * m + a;
|
y = (xi & 0xffff) * m + a;
|
z = (xi >> 16) * m + (y >> 16);
|
z = (xi >> 16) * m + (y >> 16);
|
a = (int) (z >> 16);
|
a = (int) (z >> 16);
|
*x++ = (z << 16) + (y & 0xffff);
|
*x++ = (z << 16) + (y & 0xffff);
|
#else
|
#else
|
y = *x * m + a;
|
y = *x * m + a;
|
a = (int) (y >> 16);
|
a = (int) (y >> 16);
|
*x++ = y & 0xffff;
|
*x++ = y & 0xffff;
|
#endif
|
#endif
|
}
|
}
|
while (++i < wds);
|
while (++i < wds);
|
if (a)
|
if (a)
|
{
|
{
|
if (wds >= b->_maxwds)
|
if (wds >= b->_maxwds)
|
{
|
{
|
b1 = Balloc (ptr, b->_k + 1);
|
b1 = Balloc (ptr, b->_k + 1);
|
Bcopy (b1, b);
|
Bcopy (b1, b);
|
Bfree (ptr, b);
|
Bfree (ptr, b);
|
b = b1;
|
b = b1;
|
}
|
}
|
b->_x[wds++] = a;
|
b->_x[wds++] = a;
|
b->_wds = wds;
|
b->_wds = wds;
|
}
|
}
|
return b;
|
return b;
|
}
|
}
|
|
|
_Bigint *
|
_Bigint *
|
_DEFUN (s2b, (ptr, s, nd0, nd, y9),
|
_DEFUN (s2b, (ptr, s, nd0, nd, y9),
|
struct _reent * ptr _AND
|
struct _reent * ptr _AND
|
_CONST char *s _AND
|
_CONST char *s _AND
|
int nd0 _AND
|
int nd0 _AND
|
int nd _AND
|
int nd _AND
|
__ULong y9)
|
__ULong y9)
|
{
|
{
|
_Bigint *b;
|
_Bigint *b;
|
int i, k;
|
int i, k;
|
__Long x, y;
|
__Long x, y;
|
|
|
x = (nd + 8) / 9;
|
x = (nd + 8) / 9;
|
for (k = 0, y = 1; x > y; y <<= 1, k++);
|
for (k = 0, y = 1; x > y; y <<= 1, k++);
|
#ifdef Pack_32
|
#ifdef Pack_32
|
b = Balloc (ptr, k);
|
b = Balloc (ptr, k);
|
b->_x[0] = y9;
|
b->_x[0] = y9;
|
b->_wds = 1;
|
b->_wds = 1;
|
#else
|
#else
|
b = Balloc (ptr, k + 1);
|
b = Balloc (ptr, k + 1);
|
b->_x[0] = y9 & 0xffff;
|
b->_x[0] = y9 & 0xffff;
|
b->_wds = (b->_x[1] = y9 >> 16) ? 2 : 1;
|
b->_wds = (b->_x[1] = y9 >> 16) ? 2 : 1;
|
#endif
|
#endif
|
|
|
i = 9;
|
i = 9;
|
if (9 < nd0)
|
if (9 < nd0)
|
{
|
{
|
s += 9;
|
s += 9;
|
do
|
do
|
b = multadd (ptr, b, 10, *s++ - '0');
|
b = multadd (ptr, b, 10, *s++ - '0');
|
while (++i < nd0);
|
while (++i < nd0);
|
s++;
|
s++;
|
}
|
}
|
else
|
else
|
s += 10;
|
s += 10;
|
for (; i < nd; i++)
|
for (; i < nd; i++)
|
b = multadd (ptr, b, 10, *s++ - '0');
|
b = multadd (ptr, b, 10, *s++ - '0');
|
return b;
|
return b;
|
}
|
}
|
|
|
int
|
int
|
_DEFUN (hi0bits,
|
_DEFUN (hi0bits,
|
(x), register __ULong x)
|
(x), register __ULong x)
|
{
|
{
|
register int k = 0;
|
register int k = 0;
|
|
|
if (!(x & 0xffff0000))
|
if (!(x & 0xffff0000))
|
{
|
{
|
k = 16;
|
k = 16;
|
x <<= 16;
|
x <<= 16;
|
}
|
}
|
if (!(x & 0xff000000))
|
if (!(x & 0xff000000))
|
{
|
{
|
k += 8;
|
k += 8;
|
x <<= 8;
|
x <<= 8;
|
}
|
}
|
if (!(x & 0xf0000000))
|
if (!(x & 0xf0000000))
|
{
|
{
|
k += 4;
|
k += 4;
|
x <<= 4;
|
x <<= 4;
|
}
|
}
|
if (!(x & 0xc0000000))
|
if (!(x & 0xc0000000))
|
{
|
{
|
k += 2;
|
k += 2;
|
x <<= 2;
|
x <<= 2;
|
}
|
}
|
if (!(x & 0x80000000))
|
if (!(x & 0x80000000))
|
{
|
{
|
k++;
|
k++;
|
if (!(x & 0x40000000))
|
if (!(x & 0x40000000))
|
return 32;
|
return 32;
|
}
|
}
|
return k;
|
return k;
|
}
|
}
|
|
|
int
|
int
|
_DEFUN (lo0bits, (y), __ULong *y)
|
_DEFUN (lo0bits, (y), __ULong *y)
|
{
|
{
|
register int k;
|
register int k;
|
register __ULong x = *y;
|
register __ULong x = *y;
|
|
|
if (x & 7)
|
if (x & 7)
|
{
|
{
|
if (x & 1)
|
if (x & 1)
|
return 0;
|
return 0;
|
if (x & 2)
|
if (x & 2)
|
{
|
{
|
*y = x >> 1;
|
*y = x >> 1;
|
return 1;
|
return 1;
|
}
|
}
|
*y = x >> 2;
|
*y = x >> 2;
|
return 2;
|
return 2;
|
}
|
}
|
k = 0;
|
k = 0;
|
if (!(x & 0xffff))
|
if (!(x & 0xffff))
|
{
|
{
|
k = 16;
|
k = 16;
|
x >>= 16;
|
x >>= 16;
|
}
|
}
|
if (!(x & 0xff))
|
if (!(x & 0xff))
|
{
|
{
|
k += 8;
|
k += 8;
|
x >>= 8;
|
x >>= 8;
|
}
|
}
|
if (!(x & 0xf))
|
if (!(x & 0xf))
|
{
|
{
|
k += 4;
|
k += 4;
|
x >>= 4;
|
x >>= 4;
|
}
|
}
|
if (!(x & 0x3))
|
if (!(x & 0x3))
|
{
|
{
|
k += 2;
|
k += 2;
|
x >>= 2;
|
x >>= 2;
|
}
|
}
|
if (!(x & 1))
|
if (!(x & 1))
|
{
|
{
|
k++;
|
k++;
|
x >>= 1;
|
x >>= 1;
|
if (!x & 1)
|
if (!x & 1)
|
return 32;
|
return 32;
|
}
|
}
|
*y = x;
|
*y = x;
|
return k;
|
return k;
|
}
|
}
|
|
|
_Bigint *
|
_Bigint *
|
_DEFUN (i2b, (ptr, i), struct _reent * ptr _AND int i)
|
_DEFUN (i2b, (ptr, i), struct _reent * ptr _AND int i)
|
{
|
{
|
_Bigint *b;
|
_Bigint *b;
|
|
|
b = Balloc (ptr, 1);
|
b = Balloc (ptr, 1);
|
b->_x[0] = i;
|
b->_x[0] = i;
|
b->_wds = 1;
|
b->_wds = 1;
|
return b;
|
return b;
|
}
|
}
|
|
|
_Bigint *
|
_Bigint *
|
_DEFUN (mult, (ptr, a, b), struct _reent * ptr _AND _Bigint * a _AND _Bigint * b)
|
_DEFUN (mult, (ptr, a, b), struct _reent * ptr _AND _Bigint * a _AND _Bigint * b)
|
{
|
{
|
_Bigint *c;
|
_Bigint *c;
|
int k, wa, wb, wc;
|
int k, wa, wb, wc;
|
__ULong carry, y, z;
|
__ULong carry, y, z;
|
__ULong *x, *xa, *xae, *xb, *xbe, *xc, *xc0;
|
__ULong *x, *xa, *xae, *xb, *xbe, *xc, *xc0;
|
#ifdef Pack_32
|
#ifdef Pack_32
|
__ULong z2;
|
__ULong z2;
|
#endif
|
#endif
|
|
|
if (a->_wds < b->_wds)
|
if (a->_wds < b->_wds)
|
{
|
{
|
c = a;
|
c = a;
|
a = b;
|
a = b;
|
b = c;
|
b = c;
|
}
|
}
|
k = a->_k;
|
k = a->_k;
|
wa = a->_wds;
|
wa = a->_wds;
|
wb = b->_wds;
|
wb = b->_wds;
|
wc = wa + wb;
|
wc = wa + wb;
|
if (wc > a->_maxwds)
|
if (wc > a->_maxwds)
|
k++;
|
k++;
|
c = Balloc (ptr, k);
|
c = Balloc (ptr, k);
|
for (x = c->_x, xa = x + wc; x < xa; x++)
|
for (x = c->_x, xa = x + wc; x < xa; x++)
|
*x = 0;
|
*x = 0;
|
xa = a->_x;
|
xa = a->_x;
|
xae = xa + wa;
|
xae = xa + wa;
|
xb = b->_x;
|
xb = b->_x;
|
xbe = xb + wb;
|
xbe = xb + wb;
|
xc0 = c->_x;
|
xc0 = c->_x;
|
#ifdef Pack_32
|
#ifdef Pack_32
|
for (; xb < xbe; xb++, xc0++)
|
for (; xb < xbe; xb++, xc0++)
|
{
|
{
|
if ((y = *xb & 0xffff) != 0)
|
if ((y = *xb & 0xffff) != 0)
|
{
|
{
|
x = xa;
|
x = xa;
|
xc = xc0;
|
xc = xc0;
|
carry = 0;
|
carry = 0;
|
do
|
do
|
{
|
{
|
z = (*x & 0xffff) * y + (*xc & 0xffff) + carry;
|
z = (*x & 0xffff) * y + (*xc & 0xffff) + carry;
|
carry = z >> 16;
|
carry = z >> 16;
|
z2 = (*x++ >> 16) * y + (*xc >> 16) + carry;
|
z2 = (*x++ >> 16) * y + (*xc >> 16) + carry;
|
carry = z2 >> 16;
|
carry = z2 >> 16;
|
Storeinc (xc, z2, z);
|
Storeinc (xc, z2, z);
|
}
|
}
|
while (x < xae);
|
while (x < xae);
|
*xc = carry;
|
*xc = carry;
|
}
|
}
|
if ((y = *xb >> 16) != 0)
|
if ((y = *xb >> 16) != 0)
|
{
|
{
|
x = xa;
|
x = xa;
|
xc = xc0;
|
xc = xc0;
|
carry = 0;
|
carry = 0;
|
z2 = *xc;
|
z2 = *xc;
|
do
|
do
|
{
|
{
|
z = (*x & 0xffff) * y + (*xc >> 16) + carry;
|
z = (*x & 0xffff) * y + (*xc >> 16) + carry;
|
carry = z >> 16;
|
carry = z >> 16;
|
Storeinc (xc, z, z2);
|
Storeinc (xc, z, z2);
|
z2 = (*x++ >> 16) * y + (*xc & 0xffff) + carry;
|
z2 = (*x++ >> 16) * y + (*xc & 0xffff) + carry;
|
carry = z2 >> 16;
|
carry = z2 >> 16;
|
}
|
}
|
while (x < xae);
|
while (x < xae);
|
*xc = z2;
|
*xc = z2;
|
}
|
}
|
}
|
}
|
#else
|
#else
|
for (; xb < xbe; xc0++)
|
for (; xb < xbe; xc0++)
|
{
|
{
|
if (y = *xb++)
|
if (y = *xb++)
|
{
|
{
|
x = xa;
|
x = xa;
|
xc = xc0;
|
xc = xc0;
|
carry = 0;
|
carry = 0;
|
do
|
do
|
{
|
{
|
z = *x++ * y + *xc + carry;
|
z = *x++ * y + *xc + carry;
|
carry = z >> 16;
|
carry = z >> 16;
|
*xc++ = z & 0xffff;
|
*xc++ = z & 0xffff;
|
}
|
}
|
while (x < xae);
|
while (x < xae);
|
*xc = carry;
|
*xc = carry;
|
}
|
}
|
}
|
}
|
#endif
|
#endif
|
for (xc0 = c->_x, xc = xc0 + wc; wc > 0 && !*--xc; --wc);
|
for (xc0 = c->_x, xc = xc0 + wc; wc > 0 && !*--xc; --wc);
|
c->_wds = wc;
|
c->_wds = wc;
|
return c;
|
return c;
|
}
|
}
|
|
|
_Bigint *
|
_Bigint *
|
_DEFUN (pow5mult,
|
_DEFUN (pow5mult,
|
(ptr, b, k), struct _reent * ptr _AND _Bigint * b _AND int k)
|
(ptr, b, k), struct _reent * ptr _AND _Bigint * b _AND int k)
|
{
|
{
|
_Bigint *b1, *p5, *p51;
|
_Bigint *b1, *p5, *p51;
|
int i;
|
int i;
|
static _CONST int p05[3] = {5, 25, 125};
|
static _CONST int p05[3] = {5, 25, 125};
|
|
|
if ((i = k & 3) != 0)
|
if ((i = k & 3) != 0)
|
b = multadd (ptr, b, p05[i - 1], 0);
|
b = multadd (ptr, b, p05[i - 1], 0);
|
|
|
if (!(k >>= 2))
|
if (!(k >>= 2))
|
return b;
|
return b;
|
_REENT_CHECK_MP(ptr);
|
_REENT_CHECK_MP(ptr);
|
if (!(p5 = _REENT_MP_P5S(ptr)))
|
if (!(p5 = _REENT_MP_P5S(ptr)))
|
{
|
{
|
/* first time */
|
/* first time */
|
p5 = _REENT_MP_P5S(ptr) = i2b (ptr, 625);
|
p5 = _REENT_MP_P5S(ptr) = i2b (ptr, 625);
|
p5->_next = 0;
|
p5->_next = 0;
|
}
|
}
|
for (;;)
|
for (;;)
|
{
|
{
|
if (k & 1)
|
if (k & 1)
|
{
|
{
|
b1 = mult (ptr, b, p5);
|
b1 = mult (ptr, b, p5);
|
Bfree (ptr, b);
|
Bfree (ptr, b);
|
b = b1;
|
b = b1;
|
}
|
}
|
if (!(k >>= 1))
|
if (!(k >>= 1))
|
break;
|
break;
|
if (!(p51 = p5->_next))
|
if (!(p51 = p5->_next))
|
{
|
{
|
p51 = p5->_next = mult (ptr, p5, p5);
|
p51 = p5->_next = mult (ptr, p5, p5);
|
p51->_next = 0;
|
p51->_next = 0;
|
}
|
}
|
p5 = p51;
|
p5 = p51;
|
}
|
}
|
return b;
|
return b;
|
}
|
}
|
|
|
_Bigint *
|
_Bigint *
|
_DEFUN (lshift, (ptr, b, k), struct _reent * ptr _AND _Bigint * b _AND int k)
|
_DEFUN (lshift, (ptr, b, k), struct _reent * ptr _AND _Bigint * b _AND int k)
|
{
|
{
|
int i, k1, n, n1;
|
int i, k1, n, n1;
|
_Bigint *b1;
|
_Bigint *b1;
|
__ULong *x, *x1, *xe, z;
|
__ULong *x, *x1, *xe, z;
|
|
|
#ifdef Pack_32
|
#ifdef Pack_32
|
n = k >> 5;
|
n = k >> 5;
|
#else
|
#else
|
n = k >> 4;
|
n = k >> 4;
|
#endif
|
#endif
|
k1 = b->_k;
|
k1 = b->_k;
|
n1 = n + b->_wds + 1;
|
n1 = n + b->_wds + 1;
|
for (i = b->_maxwds; n1 > i; i <<= 1)
|
for (i = b->_maxwds; n1 > i; i <<= 1)
|
k1++;
|
k1++;
|
b1 = Balloc (ptr, k1);
|
b1 = Balloc (ptr, k1);
|
x1 = b1->_x;
|
x1 = b1->_x;
|
for (i = 0; i < n; i++)
|
for (i = 0; i < n; i++)
|
*x1++ = 0;
|
*x1++ = 0;
|
x = b->_x;
|
x = b->_x;
|
xe = x + b->_wds;
|
xe = x + b->_wds;
|
#ifdef Pack_32
|
#ifdef Pack_32
|
if (k &= 0x1f)
|
if (k &= 0x1f)
|
{
|
{
|
k1 = 32 - k;
|
k1 = 32 - k;
|
z = 0;
|
z = 0;
|
do
|
do
|
{
|
{
|
*x1++ = *x << k | z;
|
*x1++ = *x << k | z;
|
z = *x++ >> k1;
|
z = *x++ >> k1;
|
}
|
}
|
while (x < xe);
|
while (x < xe);
|
if ((*x1 = z) != 0)
|
if ((*x1 = z) != 0)
|
++n1;
|
++n1;
|
}
|
}
|
#else
|
#else
|
if (k &= 0xf)
|
if (k &= 0xf)
|
{
|
{
|
k1 = 16 - k;
|
k1 = 16 - k;
|
z = 0;
|
z = 0;
|
do
|
do
|
{
|
{
|
*x1++ = *x << k & 0xffff | z;
|
*x1++ = *x << k & 0xffff | z;
|
z = *x++ >> k1;
|
z = *x++ >> k1;
|
}
|
}
|
while (x < xe);
|
while (x < xe);
|
if (*x1 = z)
|
if (*x1 = z)
|
++n1;
|
++n1;
|
}
|
}
|
#endif
|
#endif
|
else
|
else
|
do
|
do
|
*x1++ = *x++;
|
*x1++ = *x++;
|
while (x < xe);
|
while (x < xe);
|
b1->_wds = n1 - 1;
|
b1->_wds = n1 - 1;
|
Bfree (ptr, b);
|
Bfree (ptr, b);
|
return b1;
|
return b1;
|
}
|
}
|
|
|
int
|
int
|
_DEFUN (cmp, (a, b), _Bigint * a _AND _Bigint * b)
|
_DEFUN (cmp, (a, b), _Bigint * a _AND _Bigint * b)
|
{
|
{
|
__ULong *xa, *xa0, *xb, *xb0;
|
__ULong *xa, *xa0, *xb, *xb0;
|
int i, j;
|
int i, j;
|
|
|
i = a->_wds;
|
i = a->_wds;
|
j = b->_wds;
|
j = b->_wds;
|
#ifdef DEBUG
|
#ifdef DEBUG
|
if (i > 1 && !a->_x[i - 1])
|
if (i > 1 && !a->_x[i - 1])
|
Bug ("cmp called with a->_x[a->_wds-1] == 0");
|
Bug ("cmp called with a->_x[a->_wds-1] == 0");
|
if (j > 1 && !b->_x[j - 1])
|
if (j > 1 && !b->_x[j - 1])
|
Bug ("cmp called with b->_x[b->_wds-1] == 0");
|
Bug ("cmp called with b->_x[b->_wds-1] == 0");
|
#endif
|
#endif
|
if (i -= j)
|
if (i -= j)
|
return i;
|
return i;
|
xa0 = a->_x;
|
xa0 = a->_x;
|
xa = xa0 + j;
|
xa = xa0 + j;
|
xb0 = b->_x;
|
xb0 = b->_x;
|
xb = xb0 + j;
|
xb = xb0 + j;
|
for (;;)
|
for (;;)
|
{
|
{
|
if (*--xa != *--xb)
|
if (*--xa != *--xb)
|
return *xa < *xb ? -1 : 1;
|
return *xa < *xb ? -1 : 1;
|
if (xa <= xa0)
|
if (xa <= xa0)
|
break;
|
break;
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
_Bigint *
|
_Bigint *
|
_DEFUN (diff, (ptr, a, b), struct _reent * ptr _AND
|
_DEFUN (diff, (ptr, a, b), struct _reent * ptr _AND
|
_Bigint * a _AND _Bigint * b)
|
_Bigint * a _AND _Bigint * b)
|
{
|
{
|
_Bigint *c;
|
_Bigint *c;
|
int i, wa, wb;
|
int i, wa, wb;
|
__Long borrow, y; /* We need signed shifts here. */
|
__Long borrow, y; /* We need signed shifts here. */
|
__ULong *xa, *xae, *xb, *xbe, *xc;
|
__ULong *xa, *xae, *xb, *xbe, *xc;
|
#ifdef Pack_32
|
#ifdef Pack_32
|
__Long z;
|
__Long z;
|
#endif
|
#endif
|
|
|
i = cmp (a, b);
|
i = cmp (a, b);
|
if (!i)
|
if (!i)
|
{
|
{
|
c = Balloc (ptr, 0);
|
c = Balloc (ptr, 0);
|
c->_wds = 1;
|
c->_wds = 1;
|
c->_x[0] = 0;
|
c->_x[0] = 0;
|
return c;
|
return c;
|
}
|
}
|
if (i < 0)
|
if (i < 0)
|
{
|
{
|
c = a;
|
c = a;
|
a = b;
|
a = b;
|
b = c;
|
b = c;
|
i = 1;
|
i = 1;
|
}
|
}
|
else
|
else
|
i = 0;
|
i = 0;
|
c = Balloc (ptr, a->_k);
|
c = Balloc (ptr, a->_k);
|
c->_sign = i;
|
c->_sign = i;
|
wa = a->_wds;
|
wa = a->_wds;
|
xa = a->_x;
|
xa = a->_x;
|
xae = xa + wa;
|
xae = xa + wa;
|
wb = b->_wds;
|
wb = b->_wds;
|
xb = b->_x;
|
xb = b->_x;
|
xbe = xb + wb;
|
xbe = xb + wb;
|
xc = c->_x;
|
xc = c->_x;
|
borrow = 0;
|
borrow = 0;
|
#ifdef Pack_32
|
#ifdef Pack_32
|
do
|
do
|
{
|
{
|
y = (*xa & 0xffff) - (*xb & 0xffff) + borrow;
|
y = (*xa & 0xffff) - (*xb & 0xffff) + borrow;
|
borrow = y >> 16;
|
borrow = y >> 16;
|
Sign_Extend (borrow, y);
|
Sign_Extend (borrow, y);
|
z = (*xa++ >> 16) - (*xb++ >> 16) + borrow;
|
z = (*xa++ >> 16) - (*xb++ >> 16) + borrow;
|
borrow = z >> 16;
|
borrow = z >> 16;
|
Sign_Extend (borrow, z);
|
Sign_Extend (borrow, z);
|
Storeinc (xc, z, y);
|
Storeinc (xc, z, y);
|
}
|
}
|
while (xb < xbe);
|
while (xb < xbe);
|
while (xa < xae)
|
while (xa < xae)
|
{
|
{
|
y = (*xa & 0xffff) + borrow;
|
y = (*xa & 0xffff) + borrow;
|
borrow = y >> 16;
|
borrow = y >> 16;
|
Sign_Extend (borrow, y);
|
Sign_Extend (borrow, y);
|
z = (*xa++ >> 16) + borrow;
|
z = (*xa++ >> 16) + borrow;
|
borrow = z >> 16;
|
borrow = z >> 16;
|
Sign_Extend (borrow, z);
|
Sign_Extend (borrow, z);
|
Storeinc (xc, z, y);
|
Storeinc (xc, z, y);
|
}
|
}
|
#else
|
#else
|
do
|
do
|
{
|
{
|
y = *xa++ - *xb++ + borrow;
|
y = *xa++ - *xb++ + borrow;
|
borrow = y >> 16;
|
borrow = y >> 16;
|
Sign_Extend (borrow, y);
|
Sign_Extend (borrow, y);
|
*xc++ = y & 0xffff;
|
*xc++ = y & 0xffff;
|
}
|
}
|
while (xb < xbe);
|
while (xb < xbe);
|
while (xa < xae)
|
while (xa < xae)
|
{
|
{
|
y = *xa++ + borrow;
|
y = *xa++ + borrow;
|
borrow = y >> 16;
|
borrow = y >> 16;
|
Sign_Extend (borrow, y);
|
Sign_Extend (borrow, y);
|
*xc++ = y & 0xffff;
|
*xc++ = y & 0xffff;
|
}
|
}
|
#endif
|
#endif
|
while (!*--xc)
|
while (!*--xc)
|
wa--;
|
wa--;
|
c->_wds = wa;
|
c->_wds = wa;
|
return c;
|
return c;
|
}
|
}
|
|
|
double
|
double
|
_DEFUN (ulp, (_x), double _x)
|
_DEFUN (ulp, (_x), double _x)
|
{
|
{
|
union double_union x, a;
|
union double_union x, a;
|
register __Long L;
|
register __Long L;
|
|
|
x.d = _x;
|
x.d = _x;
|
|
|
L = (word0 (x) & Exp_mask) - (P - 1) * Exp_msk1;
|
L = (word0 (x) & Exp_mask) - (P - 1) * Exp_msk1;
|
#ifndef Sudden_Underflow
|
#ifndef Sudden_Underflow
|
if (L > 0)
|
if (L > 0)
|
{
|
{
|
#endif
|
#endif
|
#ifdef IBM
|
#ifdef IBM
|
L |= Exp_msk1 >> 4;
|
L |= Exp_msk1 >> 4;
|
#endif
|
#endif
|
word0 (a) = L;
|
word0 (a) = L;
|
#ifndef _DOUBLE_IS_32BITS
|
#ifndef _DOUBLE_IS_32BITS
|
word1 (a) = 0;
|
word1 (a) = 0;
|
#endif
|
#endif
|
|
|
#ifndef Sudden_Underflow
|
#ifndef Sudden_Underflow
|
}
|
}
|
else
|
else
|
{
|
{
|
L = -L >> Exp_shift;
|
L = -L >> Exp_shift;
|
if (L < Exp_shift)
|
if (L < Exp_shift)
|
{
|
{
|
word0 (a) = 0x80000 >> L;
|
word0 (a) = 0x80000 >> L;
|
#ifndef _DOUBLE_IS_32BITS
|
#ifndef _DOUBLE_IS_32BITS
|
word1 (a) = 0;
|
word1 (a) = 0;
|
#endif
|
#endif
|
}
|
}
|
else
|
else
|
{
|
{
|
word0 (a) = 0;
|
word0 (a) = 0;
|
L -= Exp_shift;
|
L -= Exp_shift;
|
#ifndef _DOUBLE_IS_32BITS
|
#ifndef _DOUBLE_IS_32BITS
|
word1 (a) = L >= 31 ? 1 : 1 << (31 - L);
|
word1 (a) = L >= 31 ? 1 : 1 << (31 - L);
|
#endif
|
#endif
|
}
|
}
|
}
|
}
|
#endif
|
#endif
|
return a.d;
|
return a.d;
|
}
|
}
|
|
|
double
|
double
|
_DEFUN (b2d, (a, e),
|
_DEFUN (b2d, (a, e),
|
_Bigint * a _AND int *e)
|
_Bigint * a _AND int *e)
|
{
|
{
|
__ULong *xa, *xa0, w, y, z;
|
__ULong *xa, *xa0, w, y, z;
|
int k;
|
int k;
|
union double_union d;
|
union double_union d;
|
#ifdef VAX
|
#ifdef VAX
|
__ULong d0, d1;
|
__ULong d0, d1;
|
#else
|
#else
|
#define d0 word0(d)
|
#define d0 word0(d)
|
#define d1 word1(d)
|
#define d1 word1(d)
|
#endif
|
#endif
|
|
|
xa0 = a->_x;
|
xa0 = a->_x;
|
xa = xa0 + a->_wds;
|
xa = xa0 + a->_wds;
|
y = *--xa;
|
y = *--xa;
|
#ifdef DEBUG
|
#ifdef DEBUG
|
if (!y)
|
if (!y)
|
Bug ("zero y in b2d");
|
Bug ("zero y in b2d");
|
#endif
|
#endif
|
k = hi0bits (y);
|
k = hi0bits (y);
|
*e = 32 - k;
|
*e = 32 - k;
|
#ifdef Pack_32
|
#ifdef Pack_32
|
if (k < Ebits)
|
if (k < Ebits)
|
{
|
{
|
d0 = Exp_1 | y >> (Ebits - k);
|
d0 = Exp_1 | y >> (Ebits - k);
|
w = xa > xa0 ? *--xa : 0;
|
w = xa > xa0 ? *--xa : 0;
|
#ifndef _DOUBLE_IS_32BITS
|
#ifndef _DOUBLE_IS_32BITS
|
d1 = y << ((32 - Ebits) + k) | w >> (Ebits - k);
|
d1 = y << ((32 - Ebits) + k) | w >> (Ebits - k);
|
#endif
|
#endif
|
goto ret_d;
|
goto ret_d;
|
}
|
}
|
z = xa > xa0 ? *--xa : 0;
|
z = xa > xa0 ? *--xa : 0;
|
if (k -= Ebits)
|
if (k -= Ebits)
|
{
|
{
|
d0 = Exp_1 | y << k | z >> (32 - k);
|
d0 = Exp_1 | y << k | z >> (32 - k);
|
y = xa > xa0 ? *--xa : 0;
|
y = xa > xa0 ? *--xa : 0;
|
#ifndef _DOUBLE_IS_32BITS
|
#ifndef _DOUBLE_IS_32BITS
|
d1 = z << k | y >> (32 - k);
|
d1 = z << k | y >> (32 - k);
|
#endif
|
#endif
|
}
|
}
|
else
|
else
|
{
|
{
|
d0 = Exp_1 | y;
|
d0 = Exp_1 | y;
|
#ifndef _DOUBLE_IS_32BITS
|
#ifndef _DOUBLE_IS_32BITS
|
d1 = z;
|
d1 = z;
|
#endif
|
#endif
|
}
|
}
|
#else
|
#else
|
if (k < Ebits + 16)
|
if (k < Ebits + 16)
|
{
|
{
|
z = xa > xa0 ? *--xa : 0;
|
z = xa > xa0 ? *--xa : 0;
|
d0 = Exp_1 | y << k - Ebits | z >> Ebits + 16 - k;
|
d0 = Exp_1 | y << k - Ebits | z >> Ebits + 16 - k;
|
w = xa > xa0 ? *--xa : 0;
|
w = xa > xa0 ? *--xa : 0;
|
y = xa > xa0 ? *--xa : 0;
|
y = xa > xa0 ? *--xa : 0;
|
d1 = z << k + 16 - Ebits | w << k - Ebits | y >> 16 + Ebits - k;
|
d1 = z << k + 16 - Ebits | w << k - Ebits | y >> 16 + Ebits - k;
|
goto ret_d;
|
goto ret_d;
|
}
|
}
|
z = xa > xa0 ? *--xa : 0;
|
z = xa > xa0 ? *--xa : 0;
|
w = xa > xa0 ? *--xa : 0;
|
w = xa > xa0 ? *--xa : 0;
|
k -= Ebits + 16;
|
k -= Ebits + 16;
|
d0 = Exp_1 | y << k + 16 | z << k | w >> 16 - k;
|
d0 = Exp_1 | y << k + 16 | z << k | w >> 16 - k;
|
y = xa > xa0 ? *--xa : 0;
|
y = xa > xa0 ? *--xa : 0;
|
d1 = w << k + 16 | y << k;
|
d1 = w << k + 16 | y << k;
|
#endif
|
#endif
|
ret_d:
|
ret_d:
|
#ifdef VAX
|
#ifdef VAX
|
word0 (d) = d0 >> 16 | d0 << 16;
|
word0 (d) = d0 >> 16 | d0 << 16;
|
word1 (d) = d1 >> 16 | d1 << 16;
|
word1 (d) = d1 >> 16 | d1 << 16;
|
#else
|
#else
|
#undef d0
|
#undef d0
|
#undef d1
|
#undef d1
|
#endif
|
#endif
|
return d.d;
|
return d.d;
|
}
|
}
|
|
|
_Bigint *
|
_Bigint *
|
_DEFUN (d2b,
|
_DEFUN (d2b,
|
(ptr, _d, e, bits),
|
(ptr, _d, e, bits),
|
struct _reent * ptr _AND
|
struct _reent * ptr _AND
|
double _d _AND
|
double _d _AND
|
int *e _AND
|
int *e _AND
|
int *bits)
|
int *bits)
|
|
|
{
|
{
|
union double_union d;
|
union double_union d;
|
_Bigint *b;
|
_Bigint *b;
|
int de, i, k;
|
int de, i, k;
|
__ULong *x, y, z;
|
__ULong *x, y, z;
|
#ifdef VAX
|
#ifdef VAX
|
__ULong d0, d1;
|
__ULong d0, d1;
|
#endif
|
#endif
|
d.d = _d;
|
d.d = _d;
|
#ifdef VAX
|
#ifdef VAX
|
d0 = word0 (d) >> 16 | word0 (d) << 16;
|
d0 = word0 (d) >> 16 | word0 (d) << 16;
|
d1 = word1 (d) >> 16 | word1 (d) << 16;
|
d1 = word1 (d) >> 16 | word1 (d) << 16;
|
#else
|
#else
|
#define d0 word0(d)
|
#define d0 word0(d)
|
#define d1 word1(d)
|
#define d1 word1(d)
|
d.d = _d;
|
d.d = _d;
|
#endif
|
#endif
|
|
|
#ifdef Pack_32
|
#ifdef Pack_32
|
b = Balloc (ptr, 1);
|
b = Balloc (ptr, 1);
|
#else
|
#else
|
b = Balloc (ptr, 2);
|
b = Balloc (ptr, 2);
|
#endif
|
#endif
|
x = b->_x;
|
x = b->_x;
|
|
|
z = d0 & Frac_mask;
|
z = d0 & Frac_mask;
|
d0 &= 0x7fffffff; /* clear sign bit, which we ignore */
|
d0 &= 0x7fffffff; /* clear sign bit, which we ignore */
|
#ifdef Sudden_Underflow
|
#ifdef Sudden_Underflow
|
de = (int) (d0 >> Exp_shift);
|
de = (int) (d0 >> Exp_shift);
|
#ifndef IBM
|
#ifndef IBM
|
z |= Exp_msk11;
|
z |= Exp_msk11;
|
#endif
|
#endif
|
#else
|
#else
|
if ((de = (int) (d0 >> Exp_shift)) != 0)
|
if ((de = (int) (d0 >> Exp_shift)) != 0)
|
z |= Exp_msk1;
|
z |= Exp_msk1;
|
#endif
|
#endif
|
#ifdef Pack_32
|
#ifdef Pack_32
|
#ifndef _DOUBLE_IS_32BITS
|
#ifndef _DOUBLE_IS_32BITS
|
if (d1)
|
if (d1)
|
{
|
{
|
y = d1;
|
y = d1;
|
k = lo0bits (&y);
|
k = lo0bits (&y);
|
if (k)
|
if (k)
|
{
|
{
|
x[0] = y | z << (32 - k);
|
x[0] = y | z << (32 - k);
|
z >>= k;
|
z >>= k;
|
}
|
}
|
else
|
else
|
x[0] = y;
|
x[0] = y;
|
i = b->_wds = (x[1] = z) ? 2 : 1;
|
i = b->_wds = (x[1] = z) ? 2 : 1;
|
}
|
}
|
else
|
else
|
#endif
|
#endif
|
{
|
{
|
#ifdef DEBUG
|
#ifdef DEBUG
|
if (!z)
|
if (!z)
|
Bug ("Zero passed to d2b");
|
Bug ("Zero passed to d2b");
|
#endif
|
#endif
|
k = lo0bits (&z);
|
k = lo0bits (&z);
|
x[0] = z;
|
x[0] = z;
|
i = b->_wds = 1;
|
i = b->_wds = 1;
|
#ifndef _DOUBLE_IS_32BITS
|
#ifndef _DOUBLE_IS_32BITS
|
k += 32;
|
k += 32;
|
#endif
|
#endif
|
}
|
}
|
#else
|
#else
|
if (d1)
|
if (d1)
|
{
|
{
|
y = d1;
|
y = d1;
|
k = lo0bits (&y);
|
k = lo0bits (&y);
|
if (k)
|
if (k)
|
if (k >= 16)
|
if (k >= 16)
|
{
|
{
|
x[0] = y | z << 32 - k & 0xffff;
|
x[0] = y | z << 32 - k & 0xffff;
|
x[1] = z >> k - 16 & 0xffff;
|
x[1] = z >> k - 16 & 0xffff;
|
x[2] = z >> k;
|
x[2] = z >> k;
|
i = 2;
|
i = 2;
|
}
|
}
|
else
|
else
|
{
|
{
|
x[0] = y & 0xffff;
|
x[0] = y & 0xffff;
|
x[1] = y >> 16 | z << 16 - k & 0xffff;
|
x[1] = y >> 16 | z << 16 - k & 0xffff;
|
x[2] = z >> k & 0xffff;
|
x[2] = z >> k & 0xffff;
|
x[3] = z >> k + 16;
|
x[3] = z >> k + 16;
|
i = 3;
|
i = 3;
|
}
|
}
|
else
|
else
|
{
|
{
|
x[0] = y & 0xffff;
|
x[0] = y & 0xffff;
|
x[1] = y >> 16;
|
x[1] = y >> 16;
|
x[2] = z & 0xffff;
|
x[2] = z & 0xffff;
|
x[3] = z >> 16;
|
x[3] = z >> 16;
|
i = 3;
|
i = 3;
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
#ifdef DEBUG
|
#ifdef DEBUG
|
if (!z)
|
if (!z)
|
Bug ("Zero passed to d2b");
|
Bug ("Zero passed to d2b");
|
#endif
|
#endif
|
k = lo0bits (&z);
|
k = lo0bits (&z);
|
if (k >= 16)
|
if (k >= 16)
|
{
|
{
|
x[0] = z;
|
x[0] = z;
|
i = 0;
|
i = 0;
|
}
|
}
|
else
|
else
|
{
|
{
|
x[0] = z & 0xffff;
|
x[0] = z & 0xffff;
|
x[1] = z >> 16;
|
x[1] = z >> 16;
|
i = 1;
|
i = 1;
|
}
|
}
|
k += 32;
|
k += 32;
|
}
|
}
|
while (!x[i])
|
while (!x[i])
|
--i;
|
--i;
|
b->_wds = i + 1;
|
b->_wds = i + 1;
|
#endif
|
#endif
|
#ifndef Sudden_Underflow
|
#ifndef Sudden_Underflow
|
if (de)
|
if (de)
|
{
|
{
|
#endif
|
#endif
|
#ifdef IBM
|
#ifdef IBM
|
*e = (de - Bias - (P - 1) << 2) + k;
|
*e = (de - Bias - (P - 1) << 2) + k;
|
*bits = 4 * P + 8 - k - hi0bits (word0 (d) & Frac_mask);
|
*bits = 4 * P + 8 - k - hi0bits (word0 (d) & Frac_mask);
|
#else
|
#else
|
*e = de - Bias - (P - 1) + k;
|
*e = de - Bias - (P - 1) + k;
|
*bits = P - k;
|
*bits = P - k;
|
#endif
|
#endif
|
#ifndef Sudden_Underflow
|
#ifndef Sudden_Underflow
|
}
|
}
|
else
|
else
|
{
|
{
|
*e = de - Bias - (P - 1) + 1 + k;
|
*e = de - Bias - (P - 1) + 1 + k;
|
#ifdef Pack_32
|
#ifdef Pack_32
|
*bits = 32 * i - hi0bits (x[i - 1]);
|
*bits = 32 * i - hi0bits (x[i - 1]);
|
#else
|
#else
|
*bits = (i + 2) * 16 - hi0bits (x[i]);
|
*bits = (i + 2) * 16 - hi0bits (x[i]);
|
#endif
|
#endif
|
}
|
}
|
#endif
|
#endif
|
return b;
|
return b;
|
}
|
}
|
#undef d0
|
#undef d0
|
#undef d1
|
#undef d1
|
|
|
double
|
double
|
_DEFUN (ratio, (a, b), _Bigint * a _AND _Bigint * b)
|
_DEFUN (ratio, (a, b), _Bigint * a _AND _Bigint * b)
|
|
|
{
|
{
|
union double_union da, db;
|
union double_union da, db;
|
int k, ka, kb;
|
int k, ka, kb;
|
|
|
da.d = b2d (a, &ka);
|
da.d = b2d (a, &ka);
|
db.d = b2d (b, &kb);
|
db.d = b2d (b, &kb);
|
#ifdef Pack_32
|
#ifdef Pack_32
|
k = ka - kb + 32 * (a->_wds - b->_wds);
|
k = ka - kb + 32 * (a->_wds - b->_wds);
|
#else
|
#else
|
k = ka - kb + 16 * (a->_wds - b->_wds);
|
k = ka - kb + 16 * (a->_wds - b->_wds);
|
#endif
|
#endif
|
#ifdef IBM
|
#ifdef IBM
|
if (k > 0)
|
if (k > 0)
|
{
|
{
|
word0 (da) += (k >> 2) * Exp_msk1;
|
word0 (da) += (k >> 2) * Exp_msk1;
|
if (k &= 3)
|
if (k &= 3)
|
da.d *= 1 << k;
|
da.d *= 1 << k;
|
}
|
}
|
else
|
else
|
{
|
{
|
k = -k;
|
k = -k;
|
word0 (db) += (k >> 2) * Exp_msk1;
|
word0 (db) += (k >> 2) * Exp_msk1;
|
if (k &= 3)
|
if (k &= 3)
|
db.d *= 1 << k;
|
db.d *= 1 << k;
|
}
|
}
|
#else
|
#else
|
if (k > 0)
|
if (k > 0)
|
word0 (da) += k * Exp_msk1;
|
word0 (da) += k * Exp_msk1;
|
else
|
else
|
{
|
{
|
k = -k;
|
k = -k;
|
word0 (db) += k * Exp_msk1;
|
word0 (db) += k * Exp_msk1;
|
}
|
}
|
#endif
|
#endif
|
return da.d / db.d;
|
return da.d / db.d;
|
}
|
}
|
|
|
|
|
_CONST double
|
_CONST double
|
tens[] =
|
tens[] =
|
{
|
{
|
1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
|
1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
|
1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
|
1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
|
1e20, 1e21, 1e22, 1e23, 1e24
|
1e20, 1e21, 1e22, 1e23, 1e24
|
|
|
};
|
};
|
|
|
#if !defined(_DOUBLE_IS_32BITS) && !defined(__v800)
|
#if !defined(_DOUBLE_IS_32BITS) && !defined(__v800)
|
_CONST double bigtens[] =
|
_CONST double bigtens[] =
|
{1e16, 1e32, 1e64, 1e128, 1e256};
|
{1e16, 1e32, 1e64, 1e128, 1e256};
|
|
|
_CONST double tinytens[] =
|
_CONST double tinytens[] =
|
{1e-16, 1e-32, 1e-64, 1e-128, 1e-256};
|
{1e-16, 1e-32, 1e-64, 1e-128, 1e-256};
|
#else
|
#else
|
_CONST double bigtens[] =
|
_CONST double bigtens[] =
|
{1e16, 1e32};
|
{1e16, 1e32};
|
|
|
_CONST double tinytens[] =
|
_CONST double tinytens[] =
|
{1e-16, 1e-32};
|
{1e-16, 1e-32};
|
#endif
|
#endif
|
|
|
|
|
double
|
double
|
_DEFUN (_mprec_log10, (dig),
|
_DEFUN (_mprec_log10, (dig),
|
int dig)
|
int dig)
|
{
|
{
|
double v = 1.0;
|
double v = 1.0;
|
if (dig < 24)
|
if (dig < 24)
|
return tens[dig];
|
return tens[dig];
|
while (dig > 0)
|
while (dig > 0)
|
{
|
{
|
v *= 10;
|
v *= 10;
|
dig--;
|
dig--;
|
}
|
}
|
return v;
|
return v;
|
}
|
}
|
|
|
void
|
void
|
_DEFUN (copybits, (c, n, b),
|
_DEFUN (copybits, (c, n, b),
|
__ULong *c _AND
|
__ULong *c _AND
|
int n _AND
|
int n _AND
|
_Bigint *b)
|
_Bigint *b)
|
{
|
{
|
__ULong *ce, *x, *xe;
|
__ULong *ce, *x, *xe;
|
#ifdef Pack_16
|
#ifdef Pack_16
|
int nw, nw1;
|
int nw, nw1;
|
#endif
|
#endif
|
|
|
ce = c + ((n-1) >> kshift) + 1;
|
ce = c + ((n-1) >> kshift) + 1;
|
x = b->_x;
|
x = b->_x;
|
#ifdef Pack_32
|
#ifdef Pack_32
|
xe = x + b->_wds;
|
xe = x + b->_wds;
|
while(x < xe)
|
while(x < xe)
|
*c++ = *x++;
|
*c++ = *x++;
|
#else
|
#else
|
nw = b->_wds;
|
nw = b->_wds;
|
nw1 = nw & 1;
|
nw1 = nw & 1;
|
for(xe = x + (nw - nw1); x < xe; x += 2)
|
for(xe = x + (nw - nw1); x < xe; x += 2)
|
Storeinc(c, x[1], x[0]);
|
Storeinc(c, x[1], x[0]);
|
if (nw1)
|
if (nw1)
|
*c++ = *x;
|
*c++ = *x;
|
#endif
|
#endif
|
while(c < ce)
|
while(c < ce)
|
*c++ = 0;
|
*c++ = 0;
|
}
|
}
|
|
|
__ULong
|
__ULong
|
_DEFUN (any_on, (b, k),
|
_DEFUN (any_on, (b, k),
|
_Bigint *b _AND
|
_Bigint *b _AND
|
int k)
|
int k)
|
{
|
{
|
int n, nwds;
|
int n, nwds;
|
__ULong *x, *x0, x1, x2;
|
__ULong *x, *x0, x1, x2;
|
|
|
x = b->_x;
|
x = b->_x;
|
nwds = b->_wds;
|
nwds = b->_wds;
|
n = k >> kshift;
|
n = k >> kshift;
|
if (n > nwds)
|
if (n > nwds)
|
n = nwds;
|
n = nwds;
|
else if (n < nwds && (k &= kmask)) {
|
else if (n < nwds && (k &= kmask)) {
|
x1 = x2 = x[n];
|
x1 = x2 = x[n];
|
x1 >>= k;
|
x1 >>= k;
|
x1 <<= k;
|
x1 <<= k;
|
if (x1 != x2)
|
if (x1 != x2)
|
return 1;
|
return 1;
|
}
|
}
|
x0 = x;
|
x0 = x;
|
x += n;
|
x += n;
|
while(x > x0)
|
while(x > x0)
|
if (*--x)
|
if (*--x)
|
return 1;
|
return 1;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
|
|
