int
mpz_eq_mpn (mp_ptr ap, mp_size_t an, const mpz_t b)
{
mp_size_t bn = mpz_size (b);
return (bn >= 0 && bn <= an
&& mpn_cmp (ap, mpz_limbs_read (b), bn) == 0
&& (an == bn || mpn_zero_p (ap + bn, an - bn)));
}
static void
check_one (mp_ptr qp, mp_srcptr rp,
mp_srcptr np, mp_size_t nn, mp_srcptr dp, mp_size_t dn,
const char *fname, mp_limb_t q_allowed_err)
{
mp_size_t qn = nn - dn + 1;
mp_ptr tp;
const char *msg;
const char *tvalue;
mp_limb_t i;
TMP_DECL;
TMP_MARK;
tp = TMP_ALLOC_LIMBS (nn + 1);
if (dn >= qn)
refmpn_mul (tp, dp, dn, qp, qn);
else
refmpn_mul (tp, qp, qn, dp, dn);
for (i = 0; i < q_allowed_err && (tp[nn] > 0 || mpn_cmp (tp, np, nn) > 0); i++)
ASSERT_NOCARRY (refmpn_sub (tp, tp, nn+1, dp, dn));
if (tp[nn] > 0 || mpn_cmp (tp, np, nn) > 0)
{
msg = "q too large";
tvalue = "Q*D";
error:
printf ("\r*******************************************************************************\n");
printf ("%s failed test %ld: %s\n", fname, test, msg);
printf ("N= "); dumpy (np, nn);
printf ("D= "); dumpy (dp, dn);
printf ("Q= "); dumpy (qp, qn);
if (rp)
{ printf ("R= "); dumpy (rp, dn); }
printf ("%5s=", tvalue); dumpy (tp, nn+1);
printf ("nn = %ld, dn = %ld, qn = %ld\n", nn, dn, qn);
abort ();
}
ASSERT_NOCARRY (refmpn_sub_n (tp, np, tp, nn));
tvalue = "N-Q*D";
if (!mpn_zero_p (tp + dn, nn - dn) || mpn_cmp (tp, dp, dn) >= 0)
{
msg = "q too small";
goto error;
}
if (rp && mpn_cmp (rp, tp, dn) != 0)
{
msg = "r incorrect";
goto error;
}
TMP_FREE;
}
/* FIXME:
x Take scratch parameter, and figure out scratch need.
x Use some fallback for small M->n?
*/
static mp_size_t
hgcd_matrix_apply (const struct hgcd_matrix *M,
mp_ptr ap, mp_ptr bp,
mp_size_t n)
{
mp_size_t an, bn, un, vn, nn;
mp_size_t mn[2][2];
mp_size_t modn;
mp_ptr tp, sp, scratch;
mp_limb_t cy;
unsigned i, j;
TMP_DECL;
ASSERT ( (ap[n-1] | bp[n-1]) > 0);
an = n;
MPN_NORMALIZE (ap, an);
bn = n;
MPN_NORMALIZE (bp, bn);
for (i = 0; i < 2; i++)
for (j = 0; j < 2; j++)
{
mp_size_t k;
k = M->n;
MPN_NORMALIZE (M->p[i][j], k);
mn[i][j] = k;
}
ASSERT (mn[0][0] > 0);
ASSERT (mn[1][1] > 0);
ASSERT ( (mn[0][1] | mn[1][0]) > 0);
TMP_MARK;
if (mn[0][1] == 0)
{
/* A unchanged, M = (1, 0; q, 1) */
ASSERT (mn[0][0] == 1);
ASSERT (M->p[0][0][0] == 1);
ASSERT (mn[1][1] == 1);
ASSERT (M->p[1][1][0] == 1);
/* Put B <-- B - q A */
nn = submul (bp, bn, ap, an, M->p[1][0], mn[1][0]);
}
else if (mn[1][0] == 0)
{
/* B unchanged, M = (1, q; 0, 1) */
ASSERT (mn[0][0] == 1);
ASSERT (M->p[0][0][0] == 1);
ASSERT (mn[1][1] == 1);
ASSERT (M->p[1][1][0] == 1);
/* Put A <-- A - q * B */
nn = submul (ap, an, bp, bn, M->p[0][1], mn[0][1]);
}
else
{
/* A = m00 a + m01 b ==> a <= A / m00, b <= A / m01.
B = m10 a + m11 b ==> a <= B / m10, b <= B / m11. */
un = MIN (an - mn[0][0], bn - mn[1][0]) + 1;
vn = MIN (an - mn[0][1], bn - mn[1][1]) + 1;
nn = MAX (un, vn);
/* In the range of interest, mulmod_bnm1 should always beat mullo. */
modn = mpn_mulmod_bnm1_next_size (nn + 1);
scratch = TMP_ALLOC_LIMBS (mpn_mulmod_bnm1_itch (modn, modn, M->n));
tp = TMP_ALLOC_LIMBS (modn);
sp = TMP_ALLOC_LIMBS (modn);
ASSERT (n <= 2*modn);
if (n > modn)
{
cy = mpn_add (ap, ap, modn, ap + modn, n - modn);
MPN_INCR_U (ap, modn, cy);
cy = mpn_add (bp, bp, modn, bp + modn, n - modn);
MPN_INCR_U (bp, modn, cy);
n = modn;
}
mpn_mulmod_bnm1 (tp, modn, ap, n, M->p[1][1], mn[1][1], scratch);
mpn_mulmod_bnm1 (sp, modn, bp, n, M->p[0][1], mn[0][1], scratch);
/* FIXME: Handle the small n case in some better way. */
if (n + mn[1][1] < modn)
MPN_ZERO (tp + n + mn[1][1], modn - n - mn[1][1]);
if (n + mn[0][1] < modn)
MPN_ZERO (sp + n + mn[0][1], modn - n - mn[0][1]);
cy = mpn_sub_n (tp, tp, sp, modn);
MPN_DECR_U (tp, modn, cy);
ASSERT (mpn_zero_p (tp + nn, modn - nn));
mpn_mulmod_bnm1 (sp, modn, ap, n, M->p[1][0], mn[1][0], scratch);
MPN_COPY (ap, tp, nn);
mpn_mulmod_bnm1 (tp, modn, bp, n, M->p[0][0], mn[0][0], scratch);
if (n + mn[1][0] < modn)
MPN_ZERO (sp + n + mn[1][0], modn - n - mn[1][0]);
if (n + mn[0][0] < modn)
MPN_ZERO (tp + n + mn[0][0], modn - n - mn[0][0]);
cy = mpn_sub_n (tp, tp, sp, modn);
MPN_DECR_U (tp, modn, cy);
ASSERT (mpn_zero_p (tp + nn, modn - nn));
MPN_COPY (bp, tp, nn);
while ( (ap[nn-1] | bp[nn-1]) == 0)
{
nn--;
ASSERT (nn > 0);
}
}
TMP_FREE;
return nn;
}
/* Computes {rp,MIN(rn,an+bn)} <- {ap,an}*{bp,bn} Mod(B^rn-1)
*
* The result is expected to be ZERO if and only if one of the operand
* already is. Otherwise the class [0] Mod(B^rn-1) is represented by
* B^rn-1. This should not be a problem if mulmod_bnm1 is used to
* combine results and obtain a natural number when one knows in
* advance that the final value is less than (B^rn-1).
* Moreover it should not be a problem if mulmod_bnm1 is used to
* compute the full product with an+bn <= rn, because this condition
* implies (B^an-1)(B^bn-1) < (B^rn-1) .
*
* Requires 0 < bn <= an <= rn and an + bn > rn/2
* Scratch need: rn + (need for recursive call OR rn + 4). This gives
*
* S(n) <= rn + MAX (rn + 4, S(n/2)) <= 2rn + 4
*/
void
mpn_mulmod_bnm1 (mp_ptr rp, mp_size_t rn, mp_srcptr ap, mp_size_t an, mp_srcptr bp, mp_size_t bn, mp_ptr tp)
{
ASSERT (0 < bn);
ASSERT (bn <= an);
ASSERT (an <= rn);
if ((rn & 1) != 0 || BELOW_THRESHOLD (rn, MULMOD_BNM1_THRESHOLD))
{
if (UNLIKELY (bn < rn))
{
if (UNLIKELY (an + bn <= rn))
{
mpn_mul (rp, ap, an, bp, bn);
}
else
{
mp_limb_t cy;
mpn_mul (tp, ap, an, bp, bn);
cy = mpn_add (rp, tp, rn, tp + rn, an + bn - rn);
MPN_INCR_U (rp, rn, cy);
}
}
else
mpn_bc_mulmod_bnm1 (rp, ap, bp, rn, tp);
}
else
{
mp_size_t n;
mp_limb_t cy;
mp_limb_t hi;
n = rn >> 1;
/* We need at least an + bn >= n, to be able to fit one of the
recursive products at rp. Requiring strict inequality makes
the coded slightly simpler. If desired, we could avoid this
restriction by initially halving rn as long as rn is even and
an + bn <= rn/2. */
ASSERT (an + bn > n);
/* Compute xm = a*b mod (B^n - 1), xp = a*b mod (B^n + 1)
and crt together as
x = -xp * B^n + (B^n + 1) * [ (xp + xm)/2 mod (B^n-1)]
*/
#define a0 ap
#define a1 (ap + n)
#define b0 bp
#define b1 (bp + n)
#define xp tp /* 2n + 2 */
/* am1 maybe in {xp, n} */
/* bm1 maybe in {xp + n, n} */
#define sp1 (tp + 2*n + 2)
/* ap1 maybe in {sp1, n + 1} */
/* bp1 maybe in {sp1 + n + 1, n + 1} */
{
mp_srcptr am1, bm1;
mp_size_t anm, bnm;
mp_ptr so;
bm1 = b0;
bnm = bn;
if (LIKELY (an > n))
{
am1 = xp;
cy = mpn_add (xp, a0, n, a1, an - n);
MPN_INCR_U (xp, n, cy);
anm = n;
so = xp + n;
if (LIKELY (bn > n))
{
bm1 = so;
cy = mpn_add (so, b0, n, b1, bn - n);
MPN_INCR_U (so, n, cy);
bnm = n;
so += n;
}
}
else
{
so = xp;
am1 = a0;
anm = an;
}
mpn_mulmod_bnm1 (rp, n, am1, anm, bm1, bnm, so);
}
{
int k;
mp_srcptr ap1, bp1;
mp_size_t anp, bnp;
bp1 = b0;
bnp = bn;
if (LIKELY (an > n)) {
ap1 = sp1;
cy = mpn_sub (sp1, a0, n, a1, an - n);
sp1[n] = 0;
MPN_INCR_U (sp1, n + 1, cy);
anp = n + ap1[n];
if (LIKELY (bn > n)) {
bp1 = sp1 + n + 1;
cy = mpn_sub (sp1 + n + 1, b0, n, b1, bn - n);
sp1[2*n+1] = 0;
MPN_INCR_U (sp1 + n + 1, n + 1, cy);
bnp = n + bp1[n];
}
} else {
ap1 = a0;
anp = an;
}
if (BELOW_THRESHOLD (n, MUL_FFT_MODF_THRESHOLD))
k=0;
else
{
int mask;
k = mpn_fft_best_k (n, 0);
mask = (1<<k) - 1;
while (n & mask) {k--; mask >>=1;};
}
if (k >= FFT_FIRST_K)
xp[n] = mpn_mul_fft (xp, n, ap1, anp, bp1, bnp, k);
else if (UNLIKELY (bp1 == b0))
{
ASSERT (anp + bnp <= 2*n+1);
ASSERT (anp + bnp > n);
ASSERT (anp >= bnp);
mpn_mul (xp, ap1, anp, bp1, bnp);
anp = anp + bnp - n;
ASSERT (anp <= n || xp[2*n]==0);
anp-= anp > n;
cy = mpn_sub (xp, xp, n, xp + n, anp);
xp[n] = 0;
MPN_INCR_U (xp, n+1, cy);
}
else
mpn_bc_mulmod_bnp1 (xp, ap1, bp1, n, xp);
}
/* Here the CRT recomposition begins.
xm <- (xp + xm)/2 = (xp + xm)B^n/2 mod (B^n-1)
Division by 2 is a bitwise rotation.
Assumes xp normalised mod (B^n+1).
The residue class [0] is represented by [B^n-1]; except when
both input are ZERO.
*/
#if HAVE_NATIVE_mpn_rsh1add_n || HAVE_NATIVE_mpn_rsh1add_nc
#if HAVE_NATIVE_mpn_rsh1add_nc
cy = mpn_rsh1add_nc(rp, rp, xp, n, xp[n]); /* B^n = 1 */
hi = cy << (GMP_NUMB_BITS - 1);
cy = 0;
/* next update of rp[n-1] will set cy = 1 only if rp[n-1]+=hi
overflows, i.e. a further increment will not overflow again. */
#else /* ! _nc */
cy = xp[n] + mpn_rsh1add_n(rp, rp, xp, n); /* B^n = 1 */
hi = (cy<<(GMP_NUMB_BITS-1))&GMP_NUMB_MASK; /* (cy&1) << ... */
cy >>= 1;
/* cy = 1 only if xp[n] = 1 i.e. {xp,n} = ZERO, this implies that
the rsh1add was a simple rshift: the top bit is 0. cy=1 => hi=0. */
#endif
#if GMP_NAIL_BITS == 0
add_ssaaaa(cy, rp[n-1], cy, rp[n-1], 0, hi);
#else
cy += (hi & rp[n-1]) >> (GMP_NUMB_BITS-1);
rp[n-1] ^= hi;
#endif
#else /* ! HAVE_NATIVE_mpn_rsh1add_n */
#if HAVE_NATIVE_mpn_add_nc
cy = mpn_add_nc(rp, rp, xp, n, xp[n]);
#else /* ! _nc */
cy = xp[n] + mpn_add_n(rp, rp, xp, n); /* xp[n] == 1 implies {xp,n} == ZERO */
#endif
cy += (rp[0]&1);
mpn_rshift(rp, rp, n, 1);
ASSERT (cy <= 2);
hi = (cy<<(GMP_NUMB_BITS-1))&GMP_NUMB_MASK; /* (cy&1) << ... */
cy >>= 1;
/* We can have cy != 0 only if hi = 0... */
ASSERT ((rp[n-1] & GMP_NUMB_HIGHBIT) == 0);
rp[n-1] |= hi;
/* ... rp[n-1] + cy can not overflow, the following INCR is correct. */
#endif
ASSERT (cy <= 1);
/* Next increment can not overflow, read the previous comments about cy. */
ASSERT ((cy == 0) || ((rp[n-1] & GMP_NUMB_HIGHBIT) == 0));
MPN_INCR_U(rp, n, cy);
/* Compute the highest half:
([(xp + xm)/2 mod (B^n-1)] - xp ) * B^n
*/
if (UNLIKELY (an + bn < rn))
{
/* Note that in this case, the only way the result can equal
zero mod B^{rn} - 1 is if one of the inputs is zero, and
then the output of both the recursive calls and this CRT
reconstruction is zero, not B^{rn} - 1. Which is good,
since the latter representation doesn't fit in the output
area.*/
cy = mpn_sub_n (rp + n, rp, xp, an + bn - n);
/* FIXME: This subtraction of the high parts is not really
necessary, we do it to get the carry out, and for sanity
checking. */
cy = xp[n] + mpn_sub_nc (xp + an + bn - n, rp + an + bn - n,
xp + an + bn - n, rn - (an + bn), cy);
ASSERT (an + bn == rn - 1 ||
mpn_zero_p (xp + an + bn - n + 1, rn - 1 - (an + bn)));
cy = mpn_sub_1 (rp, rp, an + bn, cy);
ASSERT (cy == (xp + an + bn - n)[0]);
}
else
{
cy = xp[n] + mpn_sub_n (rp + n, rp, xp, n);
/* cy = 1 only if {xp,n+1} is not ZERO, i.e. {rp,n} is not ZERO.
DECR will affect _at most_ the lowest n limbs. */
MPN_DECR_U (rp, 2*n, cy);
}
#undef a0
#undef a1
#undef b0
#undef b1
#undef xp
#undef sp1
}
}
mp_size_t
mpn_gcdext (mp_ptr gp, mp_ptr up, mp_size_t *usizep,
mp_ptr ap, mp_size_t an, mp_ptr bp, mp_size_t n)
{
mp_size_t talloc;
mp_size_t scratch;
mp_size_t matrix_scratch;
mp_size_t ualloc = n + 1;
mp_size_t un;
mp_ptr u0;
mp_ptr u1;
mp_ptr tp;
TMP_DECL;
ASSERT (an >= n);
ASSERT (n > 0);
TMP_MARK;
/* FIXME: Check for small sizes first, before setting up temporary
storage etc. */
talloc = MPN_GCDEXT_LEHMER_N_ITCH(n);
/* For initial division */
scratch = an - n + 1;
if (scratch > talloc)
talloc = scratch;
if (ABOVE_THRESHOLD (n, GCDEXT_DC_THRESHOLD))
{
/* For hgcd loop. */
mp_size_t hgcd_scratch;
mp_size_t update_scratch;
mp_size_t p1 = CHOOSE_P_1 (n);
mp_size_t p2 = CHOOSE_P_2 (n);
mp_size_t min_p = MIN(p1, p2);
mp_size_t max_p = MAX(p1, p2);
matrix_scratch = MPN_HGCD_MATRIX_INIT_ITCH (n - min_p);
hgcd_scratch = mpn_hgcd_itch (n - min_p);
update_scratch = max_p + n - 1;
scratch = matrix_scratch + MAX(hgcd_scratch, update_scratch);
if (scratch > talloc)
talloc = scratch;
/* Final mpn_gcdext_lehmer_n call. Need space for u and for
copies of a and b. */
scratch = MPN_GCDEXT_LEHMER_N_ITCH (GCDEXT_DC_THRESHOLD)
+ 3*GCDEXT_DC_THRESHOLD;
if (scratch > talloc)
talloc = scratch;
/* Cofactors u0 and u1 */
talloc += 2*(n+1);
}
tp = TMP_ALLOC_LIMBS(talloc);
if (an > n)
{
mpn_tdiv_qr (tp, ap, 0, ap, an, bp, n);
if (mpn_zero_p (ap, n))
{
MPN_COPY (gp, bp, n);
*usizep = 0;
TMP_FREE;
return n;
}
}
if (BELOW_THRESHOLD (n, GCDEXT_DC_THRESHOLD))
{
mp_size_t gn = mpn_gcdext_lehmer_n(gp, up, usizep, ap, bp, n, tp);
TMP_FREE;
return gn;
}
MPN_ZERO (tp, 2*ualloc);
u0 = tp; tp += ualloc;
u1 = tp; tp += ualloc;
{
/* For the first hgcd call, there are no u updates, and it makes
some sense to use a different choice for p. */
/* FIXME: We could trim use of temporary storage, since u0 and u1
are not used yet. For the hgcd call, we could swap in the u0
and u1 pointers for the relevant matrix elements. */
struct hgcd_matrix M;
mp_size_t p = CHOOSE_P_1 (n);
mp_size_t nn;
mpn_hgcd_matrix_init (&M, n - p, tp);
nn = mpn_hgcd (ap + p, bp + p, n - p, &M, tp + matrix_scratch);
if (nn > 0)
{
ASSERT (M.n <= (n - p - 1)/2);
ASSERT (M.n + p <= (p + n - 1) / 2);
/* Temporary storage 2 (p + M->n) <= p + n - 1 */
n = mpn_hgcd_matrix_adjust (&M, p + nn, ap, bp, p, tp + matrix_scratch);
MPN_COPY (u0, M.p[1][0], M.n);
MPN_COPY (u1, M.p[1][1], M.n);
un = M.n;
while ( (u0[un-1] | u1[un-1] ) == 0)
un--;
}
else
{
/* mpn_hgcd has failed. Then either one of a or b is very
small, or the difference is very small. Perform one
subtraction followed by one division. */
mp_size_t gn;
mp_size_t updated_un = 1;
u1[0] = 1;
/* Temporary storage 2n + 1 */
n = mpn_gcdext_subdiv_step (gp, &gn, up, usizep, ap, bp, n,
u0, u1, &updated_un, tp, tp + n);
if (n == 0)
{
TMP_FREE;
return gn;
}
un = updated_un;
ASSERT (un < ualloc);
}
}
while (ABOVE_THRESHOLD (n, GCDEXT_DC_THRESHOLD))
{
struct hgcd_matrix M;
mp_size_t p = CHOOSE_P_2 (n);
mp_size_t nn;
mpn_hgcd_matrix_init (&M, n - p, tp);
nn = mpn_hgcd (ap + p, bp + p, n - p, &M, tp + matrix_scratch);
if (nn > 0)
{
mp_ptr t0;
t0 = tp + matrix_scratch;
ASSERT (M.n <= (n - p - 1)/2);
ASSERT (M.n + p <= (p + n - 1) / 2);
/* Temporary storage 2 (p + M->n) <= p + n - 1 */
n = mpn_hgcd_matrix_adjust (&M, p + nn, ap, bp, p, t0);
/* By the same analysis as for mpn_hgcd_matrix_mul */
ASSERT (M.n + un <= ualloc);
/* FIXME: This copying could be avoided by some swapping of
* pointers. May need more temporary storage, though. */
MPN_COPY (t0, u0, un);
/* Temporary storage ualloc */
un = hgcd_mul_matrix_vector (&M, u0, t0, u1, un, t0 + un);
ASSERT (un < ualloc);
ASSERT ( (u0[un-1] | u1[un-1]) > 0);
}
else
{
/* mpn_hgcd has failed. Then either one of a or b is very
small, or the difference is very small. Perform one
subtraction followed by one division. */
mp_size_t gn;
mp_size_t updated_un = un;
/* Temporary storage 2n + 1 */
n = mpn_gcdext_subdiv_step (gp, &gn, up, usizep, ap, bp, n,
u0, u1, &updated_un, tp, tp + n);
if (n == 0)
{
TMP_FREE;
return gn;
}
un = updated_un;
ASSERT (un < ualloc);
}
}
if (UNLIKELY (mpn_cmp (ap, bp, n) == 0))
{
/* Must return the smallest cofactor, +u1 or -u0 */
int c;
MPN_COPY (gp, ap, n);
MPN_CMP (c, u0, u1, un);
ASSERT (c != 0);
if (c < 0)
{
MPN_NORMALIZE (u0, un);
MPN_COPY (up, u0, un);
*usizep = -un;
}
else
{
MPN_NORMALIZE_NOT_ZERO (u1, un);
MPN_COPY (up, u1, un);
*usizep = un;
}
TMP_FREE;
return n;
}
else if (mpn_zero_p (u0, un))
{
mp_size_t gn;
ASSERT (un == 1);
ASSERT (u1[0] == 1);
/* g = u a + v b = (u u1 - v u0) A + (...) B = u A + (...) B */
gn = mpn_gcdext_lehmer_n (gp, up, usizep, ap, bp, n, tp);
TMP_FREE;
return gn;
}
else
{
/* We have A = ... a + ... b
B = u0 a + u1 b
a = u1 A + ... B
b = -u0 A + ... B
with bounds
|u0|, |u1| <= B / min(a, b)
Compute g = u a + v b = (u u1 - v u0) A + (...) B
Here, u, v are bounded by
|u| <= b,
|v| <= a
*/
mp_size_t u0n;
mp_size_t u1n;
mp_size_t lehmer_un;
mp_size_t lehmer_vn;
mp_size_t gn;
mp_ptr lehmer_up;
mp_ptr lehmer_vp;
int negate;
lehmer_up = tp; tp += n;
/* Call mpn_gcdext_lehmer_n with copies of a and b. */
MPN_COPY (tp, ap, n);
MPN_COPY (tp + n, bp, n);
gn = mpn_gcdext_lehmer_n (gp, lehmer_up, &lehmer_un, tp, tp + n, n, tp + 2*n);
u0n = un;
MPN_NORMALIZE (u0, u0n);
if (lehmer_un == 0)
{
/* u == 0 ==> v = g / b == 1 ==> g = - u0 A + (...) B */
MPN_COPY (up, u0, u0n);
*usizep = -u0n;
TMP_FREE;
return gn;
}
lehmer_vp = tp;
/* Compute v = (g - u a) / b */
lehmer_vn = compute_v (lehmer_vp,
ap, bp, n, gp, gn, lehmer_up, lehmer_un, tp + n + 1);
if (lehmer_un > 0)
negate = 0;
else
{
lehmer_un = -lehmer_un;
negate = 1;
}
u1n = un;
MPN_NORMALIZE (u1, u1n);
/* It's possible that u0 = 1, u1 = 0 */
if (u1n == 0)
{
ASSERT (un == 1);
ASSERT (u0[0] == 1);
/* u1 == 0 ==> u u1 + v u0 = v */
MPN_COPY (up, lehmer_vp, lehmer_vn);
*usizep = negate ? lehmer_vn : - lehmer_vn;
TMP_FREE;
return gn;
}
ASSERT (lehmer_un + u1n <= ualloc);
ASSERT (lehmer_vn + u0n <= ualloc);
/* Now u0, u1, u are non-zero. We may still have v == 0 */
/* Compute u u0 */
if (lehmer_un <= u1n)
/* Should be the common case */
mpn_mul (up, u1, u1n, lehmer_up, lehmer_un);
else
mpn_mul (up, lehmer_up, lehmer_un, u1, u1n);
un = u1n + lehmer_un;
un -= (up[un - 1] == 0);
if (lehmer_vn > 0)
{
mp_limb_t cy;
/* Overwrites old u1 value */
if (lehmer_vn <= u0n)
/* Should be the common case */
mpn_mul (u1, u0, u0n, lehmer_vp, lehmer_vn);
else
mpn_mul (u1, lehmer_vp, lehmer_vn, u0, u0n);
u1n = u0n + lehmer_vn;
u1n -= (u1[u1n - 1] == 0);
if (u1n <= un)
{
cy = mpn_add (up, up, un, u1, u1n);
}
else
{
cy = mpn_add (up, u1, u1n, up, un);
un = u1n;
}
up[un] = cy;
un += (cy != 0);
ASSERT (un < ualloc);
}
*usizep = negate ? -un : un;
TMP_FREE;
return gn;
}
}
void
mpn_toom22_mul (mp_ptr pp,
mp_srcptr ap, mp_size_t an,
mp_srcptr bp, mp_size_t bn,
mp_ptr scratch)
{
const int __gmpn_cpuvec_initialized = 1;
mp_size_t n, s, t;
int vm1_neg;
mp_limb_t cy, cy2;
mp_ptr asm1;
mp_ptr bsm1;
#define a0 ap
#define a1 (ap + n)
#define b0 bp
#define b1 (bp + n)
s = an >> 1;
n = an - s;
t = bn - n;
ASSERT (an >= bn);
ASSERT (0 < s && s <= n && s >= n - 1);
ASSERT (0 < t && t <= s);
asm1 = pp;
bsm1 = pp + n;
vm1_neg = 0;
/* Compute asm1. */
if (s == n)
{
if (mpn_cmp (a0, a1, n) < 0)
{
mpn_sub_n (asm1, a1, a0, n);
vm1_neg = 1;
}
else
{
mpn_sub_n (asm1, a0, a1, n);
}
}
else /* n - s == 1 */
{
if (a0[s] == 0 && mpn_cmp (a0, a1, s) < 0)
{
mpn_sub_n (asm1, a1, a0, s);
asm1[s] = 0;
vm1_neg = 1;
}
else
{
asm1[s] = a0[s] - mpn_sub_n (asm1, a0, a1, s);
}
}
/* Compute bsm1. */
if (t == n)
{
if (mpn_cmp (b0, b1, n) < 0)
{
mpn_sub_n (bsm1, b1, b0, n);
vm1_neg ^= 1;
}
else
{
mpn_sub_n (bsm1, b0, b1, n);
}
}
else
{
if (mpn_zero_p (b0 + t, n - t) && mpn_cmp (b0, b1, t) < 0)
{
mpn_sub_n (bsm1, b1, b0, t);
MPN_ZERO (bsm1 + t, n - t);
vm1_neg ^= 1;
}
else
{
mpn_sub (bsm1, b0, n, b1, t);
}
}
#define v0 pp /* 2n */
#define vinf (pp + 2 * n) /* s+t */
#define vm1 scratch /* 2n */
#define scratch_out scratch + 2 * n
/* vm1, 2n limbs */
TOOM22_MUL_N_REC (vm1, asm1, bsm1, n, scratch_out);
if (s > t) TOOM22_MUL_REC (vinf, a1, s, b1, t, scratch_out);
else TOOM22_MUL_N_REC (vinf, a1, b1, s, scratch_out);
/* v0, 2n limbs */
TOOM22_MUL_N_REC (v0, ap, bp, n, scratch_out);
/* H(v0) + L(vinf) */
cy = mpn_add_n (pp + 2 * n, v0 + n, vinf, n);
/* L(v0) + H(v0) */
cy2 = cy + mpn_add_n (pp + n, pp + 2 * n, v0, n);
/* L(vinf) + H(vinf) */
cy += mpn_add (pp + 2 * n, pp + 2 * n, n, vinf + n, s + t - n);
if (vm1_neg)
cy += mpn_add_n (pp + n, pp + n, vm1, 2 * n);
else
cy -= mpn_sub_n (pp + n, pp + n, vm1, 2 * n);
ASSERT (cy + 1 <= 3);
ASSERT (cy2 <= 2);
MPN_INCR_U (pp + 2 * n, s + t, cy2);
if (LIKELY (cy <= 2))
/* if s+t==n, cy is zero, but we should not acces pp[3*n] at all. */
MPN_INCR_U (pp + 3 * n, s + t - n, cy);
else
MPN_DECR_U (pp + 3 * n, s + t - n, 1);
}
void
mpz_combit (mpz_ptr d, mp_bitcnt_t bit_index)
{
mp_size_t dsize = SIZ(d);
mp_ptr dp = PTR(d);
mp_size_t limb_index = bit_index / GMP_NUMB_BITS;
mp_limb_t bit = (CNST_LIMB (1) << (bit_index % GMP_NUMB_BITS));
/* Check for the most common case: Positive input, no realloc or
normalization needed. */
if (limb_index + 1 < dsize)
dp[limb_index] ^= bit;
/* Check for the hairy case. d < 0, and we have all zero bits to the
right of the bit to toggle. */
else if (limb_index < -dsize
&& (limb_index == 0 || mpn_zero_p (dp, limb_index))
&& (dp[limb_index] & (bit - 1)) == 0)
{
ASSERT (dsize < 0);
dsize = -dsize;
if (dp[limb_index] & bit)
{
/* We toggle the least significant one bit. Corresponds to
an add, with potential carry propagation, on the absolute
value. */
dp = MPZ_REALLOC (d, 1 + dsize);
dp[dsize] = 0;
MPN_INCR_U (dp + limb_index, 1 + dsize - limb_index, bit);
SIZ(d) = - dsize - dp[dsize];
}
else
{
/* We toggle a zero bit, subtract from the absolute value. */
MPN_DECR_U (dp + limb_index, dsize - limb_index, bit);
/* The absolute value shrinked by at most one bit. */
dsize -= dp[dsize - 1] == 0;
ASSERT (dsize > 0 && dp[dsize - 1] != 0);
SIZ (d) = -dsize;
}
}
else
{
/* Simple case: Toggle the bit in the absolute value. */
dsize = ABS(dsize);
if (limb_index < dsize)
{
mp_limb_t dlimb;
dlimb = dp[limb_index] ^ bit;
dp[limb_index] = dlimb;
/* Can happen only when limb_index = dsize - 1. Avoid SIZ(d)
bookkeeping in the common case. */
if (UNLIKELY ((dlimb == 0) + limb_index == dsize)) /* dsize == limb_index + 1 */
{
/* high limb became zero, must normalize */
MPN_NORMALIZE (dp, limb_index);
SIZ (d) = SIZ (d) >= 0 ? limb_index : -limb_index;
}
}
else
{
dp = MPZ_REALLOC (d, limb_index + 1);
MPN_ZERO(dp + dsize, limb_index - dsize);
dp[limb_index++] = bit;
SIZ(d) = SIZ(d) >= 0 ? limb_index : -limb_index;
}
}
}
/* Temporary storage: Needs n limbs for the quotient, at qp. tp must
point to an area large enough for the resulting cofactor, plus one
limb extra. All in all, 2N + 1 if N is a bound for both inputs and
outputs. */
mp_size_t
mpn_gcdext_subdiv_step (mp_ptr gp, mp_size_t *gn, mp_ptr up, mp_size_t *usizep,
mp_ptr ap, mp_ptr bp, mp_size_t n,
mp_ptr u0, mp_ptr u1, mp_size_t *unp,
mp_ptr qp, mp_ptr tp)
{
mp_size_t an, bn, un;
mp_size_t qn;
mp_size_t u0n;
int swapped;
an = bn = n;
ASSERT (an > 0);
ASSERT (ap[an-1] > 0 || bp[an-1] > 0);
MPN_NORMALIZE (ap, an);
MPN_NORMALIZE (bp, bn);
un = *unp;
swapped = 0;
if (UNLIKELY (an == 0))
{
return_b:
MPN_COPY (gp, bp, bn);
*gn = bn;
MPN_NORMALIZE (u0, un);
MPN_COPY (up, u0, un);
*usizep = swapped ? un : -un;
return 0;
}
else if (UNLIKELY (bn == 0))
{
MPN_COPY (gp, ap, an);
*gn = an;
MPN_NORMALIZE (u1, un);
MPN_COPY (up, u1, un);
*usizep = swapped ? -un : un;
return 0;
}
/* Arrange so that a > b, subtract an -= bn, and maintain
normalization. */
if (an < bn)
{
MPN_PTR_SWAP (ap, an, bp, bn);
MP_PTR_SWAP (u0, u1);
swapped ^= 1;
}
else if (an == bn)
{
int c;
MPN_CMP (c, ap, bp, an);
if (UNLIKELY (c == 0))
{
MPN_COPY (gp, ap, an);
*gn = an;
/* Must return the smallest cofactor, +u1 or -u0 */
MPN_CMP (c, u0, u1, un);
ASSERT (c != 0 || (un == 1 && u0[0] == 1 && u1[0] == 1));
if (c < 0)
{
MPN_NORMALIZE (u0, un);
MPN_COPY (up, u0, un);
swapped ^= 1;
}
else
{
MPN_NORMALIZE_NOT_ZERO (u1, un);
MPN_COPY (up, u1, un);
}
*usizep = swapped ? -un : un;
return 0;
}
else if (c < 0)
{
MP_PTR_SWAP (ap, bp);
MP_PTR_SWAP (u0, u1);
swapped ^= 1;
}
}
/* Reduce a -= b, u1 += u0 */
ASSERT_NOCARRY (mpn_sub (ap, ap, an, bp, bn));
MPN_NORMALIZE (ap, an);
ASSERT (an > 0);
u1[un] = mpn_add_n (u1, u1, u0, un);
un += (u1[un] > 0);
/* Arrange so that a > b, and divide a = q b + r */
if (an < bn)
{
MPN_PTR_SWAP (ap, an, bp, bn);
MP_PTR_SWAP (u0, u1);
swapped ^= 1;
}
else if (an == bn)
{
int c;
MPN_CMP (c, ap, bp, an);
if (UNLIKELY (c == 0))
goto return_b;
else if (c < 0)
{
MP_PTR_SWAP (ap, bp);
MP_PTR_SWAP (u0, u1);
swapped ^= 1;
}
}
/* Reduce a -= q b, u1 += q u0 */
qn = an - bn + 1;
mpn_tdiv_qr (qp, ap, 0, ap, an, bp, bn);
if (mpn_zero_p (ap, bn))
goto return_b;
n = bn;
/* Update u1 += q u0 */
u0n = un;
MPN_NORMALIZE (u0, u0n);
if (u0n > 0)
{
qn -= (qp[qn - 1] == 0);
if (qn > u0n)
mpn_mul (tp, qp, qn, u0, u0n);
else
mpn_mul (tp, u0, u0n, qp, qn);
if (qn + u0n > un)
{
mp_size_t u1n = un;
un = qn + u0n;
un -= (tp[un-1] == 0);
u1[un] = mpn_add (u1, tp, un, u1, u1n);
}
else
{
u1[un] = mpn_add (u1, u1, un, tp, qn + u0n);
}
un += (u1[un] > 0);
}
*unp = un;
return n;
}
void
mpn_toom22_mul (mp_ptr pp,
mp_srcptr ap, mp_size_t an,
mp_srcptr bp, mp_size_t bn,
mp_ptr scratch)
{
mp_size_t n, s, t;
int vm1_neg;
mp_limb_t cy, cy2;
mp_ptr asm1;
mp_ptr bsm1;
#define a0 ap
#define a1 (ap + n)
#define b0 bp
#define b1 (bp + n)
s = an >> 1;
n = an - s;
t = bn - n;
ASSERT (an >= bn);
ASSERT (0 < s && s <= n);
ASSERT (0 < t && t <= s);
asm1 = pp;
bsm1 = pp + n;
vm1_neg = 0;
/* Compute asm1. */
if (s == n)
{
if (mpn_cmp (a0, a1, n) < 0)
{
mpn_sub_n (asm1, a1, a0, n);
vm1_neg = 1;
}
else
{
mpn_sub_n (asm1, a0, a1, n);
}
}
else
{
if (mpn_zero_p (a0 + s, n - s) && mpn_cmp (a0, a1, s) < 0)
{
mpn_sub_n (asm1, a1, a0, s);
MPN_ZERO (asm1 + s, n - s);
vm1_neg = 1;
}
else
{
mpn_sub (asm1, a0, n, a1, s);
}
}
/* Compute bsm1. */
if (t == n)
{
if (mpn_cmp (b0, b1, n) < 0)
{
mpn_sub_n (bsm1, b1, b0, n);
vm1_neg ^= 1;
}
else
{
mpn_sub_n (bsm1, b0, b1, n);
}
}
else
{
if (mpn_zero_p (b0 + t, n - t) && mpn_cmp (b0, b1, t) < 0)
{
mpn_sub_n (bsm1, b1, b0, t);
MPN_ZERO (bsm1 + t, n - t);
vm1_neg ^= 1;
}
else
{
mpn_sub (bsm1, b0, n, b1, t);
}
}
#define v0 pp /* 2n */
#define vinf (pp + 2 * n) /* s+t */
#define vm1 scratch /* 2n */
#define scratch_out scratch + 2 * n
/* vm1, 2n limbs */
TOOM22_MUL_N_REC (vm1, asm1, bsm1, n, scratch_out);
if (s > t) TOOM22_MUL_REC (vinf, a1, s, b1, t, scratch_out);
else TOOM22_MUL_N_REC (vinf, a1, b1, s, scratch_out);
/* v0, 2n limbs */
TOOM22_MUL_N_REC (v0, ap, bp, n, scratch_out);
/* H(v0) + L(vinf) */
cy = mpn_add_n (pp + 2 * n, v0 + n, vinf, n);
/* L(v0) + H(v0) */
cy2 = cy + mpn_add_n (pp + n, pp + 2 * n, v0, n);
/* L(vinf) + H(vinf) */
cy += mpn_add (pp + 2 * n, pp + 2 * n, n, vinf + n, s + t - n);
if (vm1_neg)
cy += mpn_add_n (pp + n, pp + n, vm1, 2 * n);
else
cy -= mpn_sub_n (pp + n, pp + n, vm1, 2 * n);
ASSERT (cy + 1 <= 3);
ASSERT (cy2 <= 2);
mpn_incr_u (pp + 2 * n, cy2);
if (LIKELY (cy <= 2))
mpn_incr_u (pp + 3 * n, cy);
else
mpn_decr_u (pp + 3 * n, 1);
}
void
mpn_toom2_sqr (mp_ptr pp,
mp_srcptr ap, mp_size_t an,
mp_ptr scratch)
{
mp_size_t n, s;
mp_limb_t cy, cy2;
mp_ptr asm1;
#define a0 ap
#define a1 (ap + n)
s = an >> 1;
n = an - s;
ASSERT (0 < s && s <= n);
asm1 = pp;
/* Compute asm1. */
if (s == n)
{
if (mpn_cmp (a0, a1, n) < 0)
{
mpn_sub_n (asm1, a1, a0, n);
}
else
{
mpn_sub_n (asm1, a0, a1, n);
}
}
else
{
if (mpn_zero_p (a0 + s, n - s) && mpn_cmp (a0, a1, s) < 0)
{
mpn_sub_n (asm1, a1, a0, s);
MPN_ZERO (asm1 + s, n - s);
}
else
{
mpn_sub (asm1, a0, n, a1, s);
}
}
#define v0 pp /* 2n */
#define vinf (pp + 2 * n) /* s+s */
#define vm1 scratch /* 2n */
#define scratch_out scratch + 2 * n
/* vm1, 2n limbs */
TOOM2_SQR_REC (vm1, asm1, n, scratch_out);
/* vinf, s+s limbs */
TOOM2_SQR_REC (vinf, a1, s, scratch_out);
/* v0, 2n limbs */
TOOM2_SQR_REC (v0, ap, n, scratch_out);
/* H(v0) + L(vinf) */
cy = mpn_add_n (pp + 2 * n, v0 + n, vinf, n);
/* L(v0) + H(v0) */
cy2 = cy + mpn_add_n (pp + n, pp + 2 * n, v0, n);
/* L(vinf) + H(vinf) */
cy += mpn_add (pp + 2 * n, pp + 2 * n, n, vinf + n, s + s - n);
cy -= mpn_sub_n (pp + n, pp + n, vm1, 2 * n);
ASSERT (cy + 1 <= 3);
ASSERT (cy2 <= 2);
mpn_incr_u (pp + 2 * n, cy2);
if (LIKELY (cy <= 2))
mpn_incr_u (pp + 3 * n, cy);
else
mpn_decr_u (pp + 3 * n, 1);
}
mp_size_t mpn_remove_power_ascending(mp_ptr x, mp_size_t xsize,
mp_ptr p, mp_size_t psize, ulong *exp)
{
int i, maxi;
mp_ptr div;
mp_ptr rem;
mp_ptr square[FLINT_BITS];
mp_size_t square_size[FLINT_BITS];
mp_size_t sqsize;
*exp = 0;
if (psize > xsize)
return xsize;
maxi = 0;
square[0] = p;
square_size[0] = psize;
/* Most likely less memory will be needed, but this way we
avoid reallocations */
div = flint_malloc(sizeof(mp_limb_t) * xsize);
rem = flint_malloc(sizeof(mp_limb_t) * xsize);
/* Remove ascending powers */
for (i = 0; i < FLINT_BITS && xsize >= square_size[i]; i++)
{
mpn_tdiv_qr(div, rem, 0, x, xsize, square[i], square_size[i]);
if (!mpn_zero_p(rem, square_size[i]))
{
i -= 1;
break;
}
*exp += (1 << i);
xsize = xsize - square_size[i] + 1;
if (div[xsize-1] == 0)
xsize--;
mpn_copyi(x, div, xsize);
/* Form next square if needed */
sqsize = square_size[i] * 2;
if (sqsize - 1 > xsize)
break;
maxi = i + 1;
square[i + 1] = flint_malloc(sizeof(mp_limb_t) * sqsize);
mpn_sqr(square[i + 1], square[i], square_size[i]);
if (square[i + 1][sqsize - 1] == 0)
sqsize -= 1;
square_size[i + 1] = sqsize;
}
/* Remove descending powers */
for ( ; i >= 0; i--)
{
if (xsize >= square_size[i])
{
mpn_tdiv_qr(div, rem, 0, x, xsize, square[i], square_size[i]);
if (mpn_zero_p(rem, square_size[i]))
{
*exp += (1 << i);
xsize = xsize - square_size[i] + 1;
if (div[xsize-1] == 0)
xsize--;
mpn_copyi(x, div, xsize);
}
}
}
for (i = 1; i <= maxi; i++)
flint_free(square[i]);
flint_free(div);
flint_free(rem);
return xsize;
}
int
main (int argc, char **argv)
{
gmp_randstate_ptr rands;
mp_ptr ap, rp, pp, app, scratch;
int count = COUNT;
unsigned i;
TMP_DECL;
TMP_MARK;
if (argc > 1)
{
char *end;
count = strtol (argv[1], &end, 0);
if (*end || count <= 0)
{
fprintf (stderr, "Invalid test count: %s.\n", argv[1]);
return 1;
}
}
tests_start ();
rands = RANDS;
ap = TMP_ALLOC_LIMBS (MAX_LIMBS);
rp = TMP_ALLOC_LIMBS (MAX_LIMBS);
pp = TMP_ALLOC_LIMBS (MAX_LIMBS);
app = TMP_ALLOC_LIMBS (MAX_LIMBS);
scratch = TMP_ALLOC_LIMBS (5*MAX_LIMBS);
for (i = 0; i < count; i++)
{
mp_size_t n;
mp_limb_t k;
n = 1 + gmp_urandomm_ui (rands, MAX_LIMBS);
if (i & 1)
mpn_random2 (ap, n);
else
mpn_random (ap, n);
ap[0] |= 1;
if (i < 100)
k = 3 + 2*i;
else
{
mpn_random (&k, 1);
if (k < 3)
k = 3;
else
k |= 1;
}
mpn_brootinv (rp, ap, n, k, scratch);
mpn_powlo (pp, rp, &k, 1, n, scratch);
mpn_mullo_n (app, ap, pp, n);
if (app[0] != 1 || !(n == 1 || mpn_zero_p (app+1, n-1)))
{
gmp_fprintf (stderr,
"mpn_brootinv returned bad result: %u limbs\n",
(unsigned) n);
gmp_fprintf (stderr, "k = %Mx\n", k);
gmp_fprintf (stderr, "a = %Nx\n", ap, n);
gmp_fprintf (stderr, "r = %Nx\n", rp, n);
gmp_fprintf (stderr, "r^n = %Nx\n", pp, n);
gmp_fprintf (stderr, "a r^n = %Nx\n", app, n);
abort ();
}
}
TMP_FREE;
tests_end ();
return 0;
}
mp_bitcnt_t
mpn_remove (mp_ptr wp, mp_size_t *wn,
mp_ptr up, mp_size_t un, mp_ptr vp, mp_size_t vn,
mp_bitcnt_t cap)
{
mp_ptr pwpsp[LOG];
mp_size_t pwpsn[LOG];
mp_size_t npowers;
mp_ptr tp, qp, np, pp, qp2;
mp_size_t pn, nn, qn, i;
mp_bitcnt_t pwr;
TMP_DECL;
ASSERT (un > 0);
ASSERT (vn > 0);
ASSERT (vp[0] % 2 != 0); /* 2-adic division wants odd numbers */
ASSERT (vn > 1 || vp[0] > 1); /* else we would loop indefinitely */
TMP_MARK;
tp = TMP_ALLOC_LIMBS ((un + 1 + vn) / 2); /* remainder */
qp = TMP_ALLOC_LIMBS (un + 1); /* quotient, alternating */
qp2 = TMP_ALLOC_LIMBS (un + 1); /* quotient, alternating */
np = TMP_ALLOC_LIMBS (un + LOG); /* powers of V */
pp = vp;
pn = vn;
MPN_COPY (qp, up, un);
qn = un;
npowers = 0;
while (qn >= pn)
{
qp[qn] = 0;
mpn_bdiv_qr_wrap (qp2, tp, qp, qn + 1, pp, pn);
if (!mpn_zero_p (tp, pn))
break; /* could not divide by V^npowers */
MP_PTR_SWAP (qp, qp2);
qn = qn - pn;
qn += qp[qn] != 0;
pwpsp[npowers] = pp;
pwpsn[npowers] = pn;
npowers++;
if (((mp_bitcnt_t) 2 << npowers) - 1 > cap)
break;
nn = 2 * pn - 1; /* next power will be at least this large */
if (nn > qn)
break; /* next power would be overlarge */
mpn_sqr (np, pp, pn);
nn += np[nn] != 0;
pp = np;
pn = nn;
np += nn;
}
pwr = ((mp_bitcnt_t) 1 << npowers) - 1;
for (i = npowers - 1; i >= 0; i--)
{
pp = pwpsp[i];
pn = pwpsn[i];
if (qn < pn)
continue;
if (pwr + ((mp_bitcnt_t) 1 << i) > cap)
continue; /* V^i would bring us past cap */
qp[qn] = 0;
mpn_bdiv_qr_wrap (qp2, tp, qp, qn + 1, pp, pn);
if (!mpn_zero_p (tp, pn))
continue; /* could not divide by V^i */
MP_PTR_SWAP (qp, qp2);
qn = qn - pn;
qn += qp[qn] != 0;
pwr += (mp_bitcnt_t) 1 << i;
}
MPN_COPY (wp, qp, qn);
*wn = qn;
TMP_FREE;
return pwr;
}
/* Destroys inputs. */
int
mpn_hgcd_appr (mp_ptr ap, mp_ptr bp, mp_size_t n,
struct hgcd_matrix *M, mp_ptr tp)
{
mp_size_t s;
int success = 0;
ASSERT (n > 0);
ASSERT ((ap[n-1] | bp[n-1]) != 0);
if (n <= 2)
/* Implies s = n. A fairly uninteresting case but exercised by the
random inputs of the testsuite. */
return 0;
ASSERT ((n+1)/2 - 1 < M->alloc);
/* We aim for reduction of to GMP_NUMB_BITS * s bits. But each time
we discard some of the least significant limbs, we must keep one
additional bit to account for the truncation error. We maintain
the GMP_NUMB_BITS * s - extra_bits as the current target size. */
s = n/2 + 1;
if (BELOW_THRESHOLD (n, HGCD_APPR_THRESHOLD))
{
unsigned extra_bits = 0;
while (n > 2)
{
mp_size_t nn;
ASSERT (n > s);
ASSERT (n <= 2*s);
nn = mpn_hgcd_step (n, ap, bp, s, M, tp);
if (!nn)
break;
n = nn;
success = 1;
/* We can truncate and discard the lower p bits whenever nbits <=
2*sbits - p. To account for the truncation error, we must
adjust
sbits <-- sbits + 1 - p,
rather than just sbits <-- sbits - p. This adjustment makes
the produced matrix sligthly smaller than it could be. */
if (GMP_NUMB_BITS * (n + 1) + 2 * extra_bits <= 2*GMP_NUMB_BITS * s)
{
mp_size_t p = (GMP_NUMB_BITS * (2*s - n) - 2*extra_bits) / GMP_NUMB_BITS;
if (extra_bits == 0)
{
/* We cross a limb boundary and bump s. We can't do that
if the result is that it makes makes min(U, V)
smaller than 2^{GMP_NUMB_BITS} s. */
if (s + 1 == n
|| mpn_zero_p (ap + s + 1, n - s - 1)
|| mpn_zero_p (bp + s + 1, n - s - 1))
continue;
extra_bits = GMP_NUMB_BITS - 1;
s++;
}
else
{
extra_bits--;
}
/* Drop the p least significant limbs */
ap += p; bp += p; n -= p; s -= p;
}
}
ASSERT (s > 0);
if (extra_bits > 0)
{
/* We can get here only of we have dropped at least one of the
least significant bits, so we can decrement ap and bp. We can
then shift left extra bits using mpn_shiftr. */
/* NOTE: In the unlikely case that n is large, it would be
preferable to do an initial subdiv step to reduce the size
before shifting, but that would mean daplicating
mpn_gcd_subdiv_step with a bit count rather than a limb
count. */
ap--; bp--;
ap[0] = mpn_rshift (ap+1, ap+1, n, GMP_NUMB_BITS - extra_bits);
bp[0] = mpn_rshift (bp+1, bp+1, n, GMP_NUMB_BITS - extra_bits);
n += (ap[n] | bp[n]) > 0;
ASSERT (success);
while (n > 2)
{
mp_size_t nn;
ASSERT (n > s);
ASSERT (n <= 2*s);
nn = mpn_hgcd_step (n, ap, bp, s, M, tp);
if (!nn)
return 1;
n = nn;
}
}
if (n == 2)
{
struct hgcd_matrix1 M1;
ASSERT (s == 1);
if (mpn_hgcd2 (ap[1], ap[0], bp[1], bp[0], &M1))
{
/* Multiply M <- M * M1 */
mpn_hgcd_matrix_mul_1 (M, &M1, tp);
success = 1;
}
}
return success;
}
else
{
mp_size_t n2 = (3*n)/4 + 1;
mp_size_t p = n/2;
mp_size_t nn;
nn = mpn_hgcd_reduce (M, ap, bp, n, p, tp);
if (nn)
{
n = nn;
/* FIXME: Discard some of the low limbs immediately? */
success = 1;
}
while (n > n2)
{
mp_size_t nn;
/* Needs n + 1 storage */
nn = mpn_hgcd_step (n, ap, bp, s, M, tp);
if (!nn)
return success;
n = nn;
success = 1;
}
if (n > s + 2)
{
struct hgcd_matrix M1;
mp_size_t scratch;
p = 2*s - n + 1;
scratch = MPN_HGCD_MATRIX_INIT_ITCH (n-p);
mpn_hgcd_matrix_init(&M1, n - p, tp);
if (mpn_hgcd_appr (ap + p, bp + p, n - p, &M1, tp + scratch))
{
/* We always have max(M) > 2^{-(GMP_NUMB_BITS + 1)} max(M1) */
ASSERT (M->n + 2 >= M1.n);
/* Furthermore, assume M ends with a quotient (1, q; 0, 1),
then either q or q + 1 is a correct quotient, and M1 will
start with either (1, 0; 1, 1) or (2, 1; 1, 1). This
rules out the case that the size of M * M1 is much
smaller than the expected M->n + M1->n. */
ASSERT (M->n + M1.n < M->alloc);
/* We need a bound for of M->n + M1.n. Let n be the original
input size. Then
ceil(n/2) - 1 >= size of product >= M.n + M1.n - 2
and it follows that
M.n + M1.n <= ceil(n/2) + 1
Then 3*(M.n + M1.n) + 5 <= 3 * ceil(n/2) + 8 is the
amount of needed scratch space. */
mpn_hgcd_matrix_mul (M, &M1, tp + scratch);
return 1;
}
}
for(;;)
{
mp_size_t nn;
ASSERT (n > s);
ASSERT (n <= 2*s);
nn = mpn_hgcd_step (n, ap, bp, s, M, tp);
if (!nn)
return success;
n = nn;
success = 1;
}
}
}
