Wuzzy/BlockColor-Engine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Update mini-gmp (6.1.2)

Browse Source
This commit is contained in:
Maksim Gamarnik 2017-01-12 23:23:33 +02:00
parent d8901de27e
commit a27fed63d1
2 changed files with 146 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

248
src/gmp/mini-gmp.c
View File

@ -2,7 +2,7 @@
Contributed to the GNU project by Niels Möller Contributed to the GNU project by Niels Möller
Copyright 1991-1997, 1999-2015 Free Software Foundation, Inc. Copyright 1991-1997, 1999-2016 Free Software Foundation, Inc.
This file is part of the GNU MP Library. This file is part of the GNU MP Library.
@ -61,8 +61,10 @@ see https://www.gnu.org/licenses/. */
#define GMP_MIN(a, b) ((a) < (b) ? (a) : (b)) #define GMP_MIN(a, b) ((a) < (b) ? (a) : (b))
#define GMP_MAX(a, b) ((a) > (b) ? (a) : (b)) #define GMP_MAX(a, b) ((a) > (b) ? (a) : (b))
#define GMP_CMP(a,b) (((a) > (b)) - ((a) < (b)))
#define gmp_assert_nocarry(x) do { \ #define gmp_assert_nocarry(x) do { \
mp_limb_t __cy = x; \ mp_limb_t __cy = (x); \
assert (__cy == 0); \ assert (__cy == 0); \
} while (0) } while (0)
@ -446,7 +448,7 @@ mpn_sub_1 (mp_ptr rp, mp_srcptr ap, mp_size_t n, mp_limb_t b)
{ {
mp_limb_t a = ap[i]; mp_limb_t a = ap[i];
/* Carry out */ /* Carry out */
mp_limb_t cy = a < b;; mp_limb_t cy = a < b;
rp[i] = a - b; rp[i] = a - b;
b = cy; b = cy;
} }
@ -693,24 +695,68 @@ mpn_scan0 (mp_srcptr ptr, mp_bitcnt_t bit)
i, ptr, i, GMP_LIMB_MAX); i, ptr, i, GMP_LIMB_MAX);
} }
void
mpn_com (mp_ptr rp, mp_srcptr up, mp_size_t n)
{
while (--n >= 0)
*rp++ = ~ *up++;
}
mp_limb_t
mpn_neg (mp_ptr rp, mp_srcptr up, mp_size_t n)
{
while (*up == 0)
{
*rp = 0;
if (!--n)
return 0;
++up; ++rp;
}
*rp = - *up;
mpn_com (++rp, ++up, --n);
return 1;
}
/* MPN division interface. */ /* MPN division interface. */
/* The 3/2 inverse is defined as
m = floor( (B^3-1) / (B u1 + u0)) - B
*/
mp_limb_t mp_limb_t
mpn_invert_3by2 (mp_limb_t u1, mp_limb_t u0) mpn_invert_3by2 (mp_limb_t u1, mp_limb_t u0)
{ {
mp_limb_t r, p, m; mp_limb_t r, p, m, ql;
unsigned ul, uh; unsigned ul, uh, qh;
unsigned ql, qh;
/* First, do a 2/1 inverse. */
/* The inverse m is defined as floor( (B^2 - 1 - u1)/u1 ), so that 0 <
* B^2 - (B + m) u1 <= u1 */
assert (u1 >= GMP_LIMB_HIGHBIT); assert (u1 >= GMP_LIMB_HIGHBIT);
/* For notation, let b denote the half-limb base, so that B = b^2.
Split u1 = b uh + ul. */
ul = u1 & GMP_LLIMB_MASK; ul = u1 & GMP_LLIMB_MASK;
uh = u1 >> (GMP_LIMB_BITS / 2); uh = u1 >> (GMP_LIMB_BITS / 2);
/* Approximation of the high half of quotient. Differs from the 2/1
inverse of the half limb uh, since we have already subtracted
u0. */
qh = ~u1 / uh; qh = ~u1 / uh;
/* Adjust to get a half-limb 3/2 inverse, i.e., we want
qh' = floor( (b^3 - 1) / u) - b = floor ((b^3 - b u - 1) / u
= floor( (b (~u) + b-1) / u),
and the remainder
r = b (~u) + b-1 - qh (b uh + ul)
= b (~u - qh uh) + b-1 - qh ul
Subtraction of qh ul may underflow, which implies adjustments.
But by normalization, 2 u >= B > qh ul, so we need to adjust by
at most 2.
*/
r = ((~u1 - (mp_limb_t) qh * uh) << (GMP_LIMB_BITS / 2)) | GMP_LLIMB_MASK; r = ((~u1 - (mp_limb_t) qh * uh) << (GMP_LIMB_BITS / 2)) | GMP_LLIMB_MASK;
p = (mp_limb_t) qh * ul; p = (mp_limb_t) qh * ul;
@ -728,11 +774,19 @@ mpn_invert_3by2 (mp_limb_t u1, mp_limb_t u0)
} }
r -= p; r -= p;
/* Do a 3/2 division (with half limb size) */ /* Low half of the quotient is
ql = floor ( (b r + b-1) / u1).
This is a 3/2 division (on half-limbs), for which qh is a
suitable inverse. */
p = (r >> (GMP_LIMB_BITS / 2)) * qh + r; p = (r >> (GMP_LIMB_BITS / 2)) * qh + r;
/* Unlike full-limb 3/2, we can add 1 without overflow. For this to
work, it is essential that ql is a full mp_limb_t. */
ql = (p >> (GMP_LIMB_BITS / 2)) + 1; ql = (p >> (GMP_LIMB_BITS / 2)) + 1;
/* By the 3/2 method, we don't need the high half limb. */ /* By the 3/2 trick, we don't need the high half limb. */
r = (r << (GMP_LIMB_BITS / 2)) + GMP_LLIMB_MASK - ql * u1; r = (r << (GMP_LIMB_BITS / 2)) + GMP_LLIMB_MASK - ql * u1;
if (r >= (p << (GMP_LIMB_BITS / 2))) if (r >= (p << (GMP_LIMB_BITS / 2)))
@ -747,6 +801,8 @@ mpn_invert_3by2 (mp_limb_t u1, mp_limb_t u0)
r -= u1; r -= u1;
} }
/* Now m is the 2/1 invers of u1. If u0 > 0, adjust it to become a
3/2 inverse. */
if (u0 > 0) if (u0 > 0)
{ {
mp_limb_t th, tl; mp_limb_t th, tl;
@ -1151,7 +1207,7 @@ mpn_get_str_bits (unsigned char *sp, unsigned bits, mp_srcptr up, mp_size_t un)
unsigned char mask; unsigned char mask;
size_t sn, j; size_t sn, j;
mp_size_t i; mp_size_t i;
int shift; unsigned shift;
sn = ((un - 1) * GMP_LIMB_BITS + mpn_limb_size_in_base_2 (up[un-1]) sn = ((un - 1) * GMP_LIMB_BITS + mpn_limb_size_in_base_2 (up[un-1])
+ bits - 1) / bits; + bits - 1) / bits;
@ -1292,6 +1348,8 @@ mpn_set_str_bits (mp_ptr rp, const unsigned char *sp, size_t sn,
return rn; return rn;
} }
/* Result is usually normalized, except for all-zero input, in which
case a single zero limb is written at *RP, and 1 is returned. */
static mp_size_t static mp_size_t
mpn_set_str_other (mp_ptr rp, const unsigned char *sp, size_t sn, mpn_set_str_other (mp_ptr rp, const unsigned char *sp, size_t sn,
mp_limb_t b, const struct mpn_base_info *info) mp_limb_t b, const struct mpn_base_info *info)
@ -1301,6 +1359,8 @@ mpn_set_str_other (mp_ptr rp, const unsigned char *sp, size_t sn,
unsigned k; unsigned k;
size_t j; size_t j;
assert (sn > 0);
k = 1 + (sn - 1) % info->exp; k = 1 + (sn - 1) % info->exp;
j = 0; j = 0;
@ -1310,7 +1370,7 @@ mpn_set_str_other (mp_ptr rp, const unsigned char *sp, size_t sn,
rp[0] = w; rp[0] = w;
for (rn = (w > 0); j < sn;) for (rn = 1; j < sn;)
{ {
mp_limb_t cy; mp_limb_t cy;
@ -1353,9 +1413,11 @@ mpn_set_str (mp_ptr rp, const unsigned char *sp, size_t sn, int base)
void void
mpz_init (mpz_t r) mpz_init (mpz_t r)
{ {
r->_mp_alloc = 1; static const mp_limb_t dummy_limb = 0xc1a0;
r->_mp_alloc = 0;
r->_mp_size = 0; r->_mp_size = 0;
r->_mp_d = gmp_xalloc_limbs (1); r->_mp_d = (mp_ptr) &dummy_limb;
} }
/* The utility of this function is a bit limited, since many functions /* The utility of this function is a bit limited, since many functions
@ -1376,7 +1438,8 @@ mpz_init2 (mpz_t r, mp_bitcnt_t bits)
void void
mpz_clear (mpz_t r) mpz_clear (mpz_t r)
{ {
gmp_free (r->_mp_d); if (r->_mp_alloc)
gmp_free (r->_mp_d);
} }
static mp_ptr static mp_ptr
@ -1384,7 +1447,10 @@ mpz_realloc (mpz_t r, mp_size_t size)
{ {
size = GMP_MAX (size, 1); size = GMP_MAX (size, 1);
r->_mp_d = gmp_xrealloc_limbs (r->_mp_d, size); if (r->_mp_alloc)
r->_mp_d = gmp_xrealloc_limbs (r->_mp_d, size);
else
r->_mp_d = gmp_xalloc_limbs (size);
r->_mp_alloc = size; r->_mp_alloc = size;
if (GMP_ABS (r->_mp_size) > size) if (GMP_ABS (r->_mp_size) > size)
@ -1407,7 +1473,7 @@ mpz_set_si (mpz_t r, signed long int x)
else /* (x < 0) */ else /* (x < 0) */
{ {
r->_mp_size = -1; r->_mp_size = -1;
r->_mp_d[0] = GMP_NEG_CAST (unsigned long int, x); MPZ_REALLOC (r, 1)[0] = GMP_NEG_CAST (unsigned long int, x);
} }
} }
@ -1417,7 +1483,7 @@ mpz_set_ui (mpz_t r, unsigned long int x)
if (x > 0) if (x > 0)
{ {
r->_mp_size = 1; r->_mp_size = 1;
r->_mp_d[0] = x; MPZ_REALLOC (r, 1)[0] = x;
} }
else else
r->_mp_size = 0; r->_mp_size = 0;
@ -1485,14 +1551,11 @@ mpz_fits_ulong_p (const mpz_t u)
long int long int
mpz_get_si (const mpz_t u) mpz_get_si (const mpz_t u)
{ {
mp_size_t us = u->_mp_size; if (u->_mp_size < 0)
/* This expression is necessary to properly handle 0x80000000 */
if (us > 0) return -1 - (long) ((u->_mp_d[0] - 1) & ~GMP_LIMB_HIGHBIT);
return (long) (u->_mp_d[0] & ~GMP_LIMB_HIGHBIT);
else if (us < 0)
return (long) (- u->_mp_d[0] | GMP_LIMB_HIGHBIT);
else else
return 0; return (long) (mpz_get_ui (u) & ~GMP_LIMB_HIGHBIT);
} }
unsigned long int unsigned long int
@ -1525,7 +1588,7 @@ mpz_realloc2 (mpz_t x, mp_bitcnt_t n)
mp_srcptr mp_srcptr
mpz_limbs_read (mpz_srcptr x) mpz_limbs_read (mpz_srcptr x)
{ {
return x->_mp_d;; return x->_mp_d;
} }
mp_ptr mp_ptr
@ -1705,9 +1768,7 @@ mpz_cmp_d (const mpz_t x, double d)
int int
mpz_sgn (const mpz_t u) mpz_sgn (const mpz_t u)
{ {
mp_size_t usize = u->_mp_size; return GMP_CMP (u->_mp_size, 0);
return (usize > 0) - (usize < 0);
} }
int int
@ -1722,13 +1783,7 @@ mpz_cmp_si (const mpz_t u, long v)
else if (usize >= 0) else if (usize >= 0)
return 1; return 1;
else /* usize == -1 */ else /* usize == -1 */
{ return GMP_CMP (GMP_NEG_CAST (mp_limb_t, v), u->_mp_d[0]);
mp_limb_t ul = u->_mp_d[0];
if ((mp_limb_t)GMP_NEG_CAST (unsigned long int, v) < ul)
return -1;
else
return (mp_limb_t)GMP_NEG_CAST (unsigned long int, v) > ul;
}
} }
int int
@ -1741,10 +1796,7 @@ mpz_cmp_ui (const mpz_t u, unsigned long v)
else if (usize < 0) else if (usize < 0)
return -1; return -1;
else else
{ return GMP_CMP (mpz_get_ui (u), v);
mp_limb_t ul = (usize > 0) ? u->_mp_d[0] : 0;
return (ul > v) - (ul < v);
}
} }
int int
@ -1764,15 +1816,10 @@ mpz_cmp (const mpz_t a, const mpz_t b)
int int
mpz_cmpabs_ui (const mpz_t u, unsigned long v) mpz_cmpabs_ui (const mpz_t u, unsigned long v)
{ {
mp_size_t un = GMP_ABS (u->_mp_size); if (GMP_ABS (u->_mp_size) > 1)
mp_limb_t ul;
if (un > 1)
return 1; return 1;
else
ul = (un == 1) ? u->_mp_d[0] : 0; return GMP_CMP (mpz_get_ui (u), v);
return (ul > v) - (ul < v);
} }
int int
@ -1818,7 +1865,7 @@ mpz_abs_add_ui (mpz_t r, const mpz_t a, unsigned long b)
an = GMP_ABS (a->_mp_size); an = GMP_ABS (a->_mp_size);
if (an == 0) if (an == 0)
{ {
r->_mp_d[0] = b; MPZ_REALLOC (r, 1)[0] = b;
return b > 0; return b > 0;
} }
@ -1837,14 +1884,15 @@ static mp_size_t
mpz_abs_sub_ui (mpz_t r, const mpz_t a, unsigned long b) mpz_abs_sub_ui (mpz_t r, const mpz_t a, unsigned long b)
{ {
mp_size_t an = GMP_ABS (a->_mp_size); mp_size_t an = GMP_ABS (a->_mp_size);
mp_ptr rp = MPZ_REALLOC (r, an); mp_ptr rp;
if (an == 0) if (an == 0)
{ {
rp[0] = b; MPZ_REALLOC (r, 1)[0] = b;
return -(b > 0); return -(b > 0);
} }
else if (an == 1 && a->_mp_d[0] < b) rp = MPZ_REALLOC (r, an);
if (an == 1 && a->_mp_d[0] < b)
{ {
rp[0] = b - a->_mp_d[0]; rp[0] = b - a->_mp_d[0];
return -1; return -1;
@ -2315,7 +2363,6 @@ mpz_div_q_2exp (mpz_t q, const mpz_t u, mp_bitcnt_t bit_index,
if (qn <= 0) if (qn <= 0)
qn = 0; qn = 0;
else else
{ {
qp = MPZ_REALLOC (q, qn); qp = MPZ_REALLOC (q, qn);
@ -2369,16 +2416,9 @@ mpz_div_r_2exp (mpz_t r, const mpz_t u, mp_bitcnt_t bit_index,
{ {
/* Have to negate and sign extend. */ /* Have to negate and sign extend. */
mp_size_t i; mp_size_t i;
mp_limb_t cy;
for (cy = 1, i = 0; i < un; i++) gmp_assert_nocarry (! mpn_neg (rp, u->_mp_d, un));
{ for (i = un; i < rn - 1; i++)
mp_limb_t s = ~u->_mp_d[i] + cy;
cy = s < cy;
rp[i] = s;
}
assert (cy == 0);
for (; i < rn - 1; i++)
rp[i] = GMP_LIMB_MAX; rp[i] = GMP_LIMB_MAX;
rp[rn-1] = mask; rp[rn-1] = mask;
@ -2403,23 +2443,13 @@ mpz_div_r_2exp (mpz_t r, const mpz_t u, mp_bitcnt_t bit_index,
if (mode == ((us > 0) ? GMP_DIV_CEIL : GMP_DIV_FLOOR)) /* us != 0 here. */ if (mode == ((us > 0) ? GMP_DIV_CEIL : GMP_DIV_FLOOR)) /* us != 0 here. */
{ {
/* If r != 0, compute 2^{bit_count} - r. */ /* If r != 0, compute 2^{bit_count} - r. */
mp_size_t i; mpn_neg (rp, rp, rn);
for (i = 0; i < rn && rp[i] == 0; i++) rp[rn-1] &= mask;
;
if (i < rn)
{
/* r > 0, need to flip sign. */
rp[i] = ~rp[i] + 1;
while (++i < rn)
rp[i] = ~rp[i];
rp[rn-1] &= mask; /* us is not used for anything else, so we can modify it
here to indicate flipped sign. */
/* us is not used for anything else, so we can modify it us = -us;
here to indicate flipped sign. */
us = -us;
}
} }
} }
rn = mpn_normalized_size (rp, rn); rn = mpn_normalized_size (rp, rn);
@ -2534,7 +2564,7 @@ mpz_div_qr_ui (mpz_t q, mpz_t r,
if (r) if (r)
{ {
r->_mp_d[0] = rl; MPZ_REALLOC (r, 1)[0] = rl;
r->_mp_size = rs; r->_mp_size = rs;
} }
if (q) if (q)
@ -3195,12 +3225,8 @@ mpz_rootrem (mpz_t x, mpz_t r, const mpz_t y, unsigned long z)
} }
mpz_init (u); mpz_init (u);
{ mpz_init (t);
mp_bitcnt_t tb; mpz_setbit (t, mpz_sizeinbase (y, 2) / z + 1);
tb = mpz_sizeinbase (y, 2) / z + 1;
mpz_init2 (t, tb + 1);
mpz_setbit (t, tb);
}
if (z == 2) /* simplify sqrt loop: z-1 == 1 */ if (z == 2) /* simplify sqrt loop: z-1 == 1 */
do { do {
@ -3627,7 +3653,7 @@ mpz_and (mpz_t r, const mpz_t u, const mpz_t v)
/* If the smaller input is positive, higher limbs don't matter. */ /* If the smaller input is positive, higher limbs don't matter. */
rn = vx ? un : vn; rn = vx ? un : vn;
rp = MPZ_REALLOC (r, rn + rc); rp = MPZ_REALLOC (r, rn + (mp_size_t) rc);
up = u->_mp_d; up = u->_mp_d;
vp = v->_mp_d; vp = v->_mp_d;
@ -3700,7 +3726,7 @@ mpz_ior (mpz_t r, const mpz_t u, const mpz_t v)
don't matter. */ don't matter. */
rn = vx ? vn : un; rn = vx ? vn : un;
rp = MPZ_REALLOC (r, rn + rc); rp = MPZ_REALLOC (r, rn + (mp_size_t) rc);
up = u->_mp_d; up = u->_mp_d;
vp = v->_mp_d; vp = v->_mp_d;
@ -3769,7 +3795,7 @@ mpz_xor (mpz_t r, const mpz_t u, const mpz_t v)
vx = -vc; vx = -vc;
rx = -rc; rx = -rc;
rp = MPZ_REALLOC (r, un + rc); rp = MPZ_REALLOC (r, un + (mp_size_t) rc);
up = u->_mp_d; up = u->_mp_d;
vp = v->_mp_d; vp = v->_mp_d;
@ -4092,7 +4118,7 @@ mpz_set_str (mpz_t r, const char *sp, int base)
unsigned bits; unsigned bits;
mp_size_t rn, alloc; mp_size_t rn, alloc;
mp_ptr rp; mp_ptr rp;
size_t sn; size_t dn;
int sign; int sign;
unsigned char *dp; unsigned char *dp;
@ -4106,18 +4132,17 @@ mpz_set_str (mpz_t r, const char *sp, int base)
if (base == 0) if (base == 0)
{ {
if (*sp == '0') if (sp[0] == '0')
{ {
sp++; if (sp[1] == 'x' || sp[1] == 'X')
if (*sp == 'x' || *sp == 'X')
{ {
base = 16; base = 16;
sp++; sp += 2;
} }
else if (*sp == 'b' || *sp == 'B') else if (sp[1] == 'b' || sp[1] == 'B')
{ {
base = 2; base = 2;
sp++; sp += 2;
} }
else else
base = 8; base = 8;
@ -4126,16 +4151,20 @@ mpz_set_str (mpz_t r, const char *sp, int base)
base = 10; base = 10;
} }
sn = strlen (sp); if (!*sp)
dp = (unsigned char *) gmp_xalloc (sn + (sn == 0)); {
r->_mp_size = 0;
return -1;
}
dp = (unsigned char *) gmp_xalloc (strlen (sp));
for (sn = 0; *sp; sp++) for (dn = 0; *sp; sp++)
{ {
unsigned digit; unsigned digit;
if (isspace ((unsigned char) *sp)) if (isspace ((unsigned char) *sp))
continue; continue;
if (*sp >= '0' && *sp <= '9') else if (*sp >= '0' && *sp <= '9')
digit = *sp - '0'; digit = *sp - '0';
else if (*sp >= 'a' && *sp <= 'z') else if (*sp >= 'a' && *sp <= 'z')
digit = *sp - 'a' + 10; digit = *sp - 'a' + 10;
@ -4144,31 +4173,40 @@ mpz_set_str (mpz_t r, const char *sp, int base)
else else
digit = base; /* fail */ digit = base; /* fail */
if (digit >= base) if (digit >= (unsigned) base)
{ {
gmp_free (dp); gmp_free (dp);
r->_mp_size = 0; r->_mp_size = 0;
return -1; return -1;
} }
dp[sn++] = digit; dp[dn++] = digit;
} }
if (!dn)
{
gmp_free (dp);
r->_mp_size = 0;
return -1;
}
bits = mpn_base_power_of_two_p (base); bits = mpn_base_power_of_two_p (base);
if (bits > 0) if (bits > 0)
{ {
alloc = (sn * bits + GMP_LIMB_BITS - 1) / GMP_LIMB_BITS; alloc = (dn * bits + GMP_LIMB_BITS - 1) / GMP_LIMB_BITS;
rp = MPZ_REALLOC (r, alloc); rp = MPZ_REALLOC (r, alloc);
rn = mpn_set_str_bits (rp, dp, sn, bits); rn = mpn_set_str_bits (rp, dp, dn, bits);
} }
else else
{ {
struct mpn_base_info info; struct mpn_base_info info;
mpn_get_base_info (&info, base); mpn_get_base_info (&info, base);
alloc = (sn + info.exp - 1) / info.exp; alloc = (dn + info.exp - 1) / info.exp;
rp = MPZ_REALLOC (r, alloc); rp = MPZ_REALLOC (r, alloc);
rn = mpn_set_str_other (rp, dp, sn, base, &info); rn = mpn_set_str_other (rp, dp, dn, base, &info);
/* Normalization, needed for all-zero input. */
assert (rn > 0);
rn -= rp[rn-1] == 0;
} }
assert (rn <= alloc); assert (rn <= alloc);
gmp_free (dp); gmp_free (dp);

3
src/gmp/mini-gmp.h
View File

@ -100,6 +100,9 @@ mp_limb_t mpn_rshift (mp_ptr, mp_srcptr, mp_size_t, unsigned int);
mp_bitcnt_t mpn_scan0 (mp_srcptr, mp_bitcnt_t); mp_bitcnt_t mpn_scan0 (mp_srcptr, mp_bitcnt_t);
mp_bitcnt_t mpn_scan1 (mp_srcptr, mp_bitcnt_t); mp_bitcnt_t mpn_scan1 (mp_srcptr, mp_bitcnt_t);
void mpn_com (mp_ptr, mp_srcptr, mp_size_t);
mp_limb_t mpn_neg (mp_ptr, mp_srcptr, mp_size_t);
mp_bitcnt_t mpn_popcount (mp_srcptr, mp_size_t); mp_bitcnt_t mpn_popcount (mp_srcptr, mp_size_t);
mp_limb_t mpn_invert_3by2 (mp_limb_t, mp_limb_t); mp_limb_t mpn_invert_3by2 (mp_limb_t, mp_limb_t);