/* Check divide and conquer division routine. */
void
check_dc_divappr_q (void)
{
mp_limb_t np[2*MAX_LIMBS];
mp_limb_t np2[2*MAX_LIMBS];
mp_limb_t rp[2*MAX_LIMBS];
mp_limb_t dp[MAX_LIMBS];
mp_limb_t qp[2*MAX_LIMBS];
mp_limb_t dip;
mp_size_t nn, rn, dn, qn;
gmp_randstate_t rands;
int i, j, s;
gmp_randinit_default(rands);
for (i = 0; i < ITERS; i++)
{
dn = (random() % (MAX_LIMBS - 5)) + 6;
nn = (random() % (MAX_LIMBS - 3)) + dn + 3;
mpn_rrandom (np, rands, nn);
mpn_rrandom (dp, rands, dn);
dp[dn-1] |= GMP_LIMB_HIGHBIT;
MPN_COPY(np2, np, nn);
mpir_invert_pi1(dip, dp[dn - 1], dp[dn - 2]);
qn = nn - dn + 1;
qp[qn - 1] = mpn_dc_divappr_q(qp, np, nn, dp, dn, dip);
MPN_NORMALIZE(qp, qn);
if (qn)
{
if (qn >= dn) mpn_mul(rp, qp, qn, dp, dn);
else mpn_mul(rp, dp, dn, qp, qn);
rn = dn + qn;
MPN_NORMALIZE(rp, rn);
s = (rn < nn) ? -1 : (rn > nn) ? 1 : mpn_cmp(rp, np2, nn);
if (s <= 0)
{
mpn_sub(rp, np2, nn, rp, rn);
rn = nn;
MPN_NORMALIZE(rp, rn);
} else
{
mpn_sub(rp, rp, rn, np2, nn);
MPN_NORMALIZE(rp, rn);
}
} else
{
rn = nn;
MPN_COPY(rp, np, nn);
}
s = (rn < dn) ? -1 : (rn > dn) ? 1 : mpn_cmp(rp, dp, dn);
if (s >= 0)
{
printf ("failed:\n");
printf ("nn = %lu, dn = %lu, qn = %lu, rn = %lu\n\n", nn, dn, qn, rn);
gmp_printf (" np: %Nx\n\n", np2, nn);
gmp_printf (" dp: %Nx\n\n", dp, dn);
gmp_printf (" qp: %Nx\n\n", qp, qn);
gmp_printf (" rp: %Nx\n\n", rp, rn);
abort ();
}
}
gmp_randclear(rands);
}
void
mpn_tdiv_q (mp_ptr qp,
mp_srcptr np, mp_size_t nn,
mp_srcptr dp, mp_size_t dn)
{
mp_ptr new_dp, new_np, tp, rp, scratch;
mp_limb_t cy, dh, qh;
mp_size_t new_nn, qn;
mp_limb_t dinv;
int cnt;
TMP_DECL;
TMP_MARK;
ASSERT (nn >= dn);
ASSERT (dn > 0);
ASSERT (dp[dn - 1] != 0);
ASSERT (! MPN_OVERLAP_P (qp, nn - dn + 1, np, nn));
ASSERT (! MPN_OVERLAP_P (qp, nn - dn + 1, dp, dn));
ASSERT_ALWAYS (FUDGE >= 2);
if (dn == 1)
{
mpn_divrem_1 (qp, 0L, np, nn, dp[dn - 1]);
return;
}
scratch = TMP_ALLOC_LIMBS(nn + 1);
qn = nn - dn + 1; /* Quotient size, high limb might be zero */
if (qn + FUDGE >= dn)
{
/* |________________________|
|_______| */
new_np = scratch;
dh = dp[dn - 1];
if (LIKELY ((dh & GMP_NUMB_HIGHBIT) == 0))
{
count_leading_zeros (cnt, dh);
cy = mpn_lshift (new_np, np, nn, cnt);
new_np[nn] = cy;
new_nn = nn + (cy != 0);
new_dp = TMP_ALLOC_LIMBS (dn);
mpn_lshift (new_dp, dp, dn, cnt);
if (dn == 2)
{
qh = mpn_divrem_2 (qp, 0L, new_np, new_nn, new_dp);
}
else if (BELOW_THRESHOLD (dn, DC_DIV_Q_THRESHOLD) ||
BELOW_THRESHOLD (new_nn - dn, DC_DIV_Q_THRESHOLD))
{
invert_1(dinv, new_dp[dn - 1], new_dp[dn - 2]);
qh = mpn_sb_div_q (qp, new_np, new_nn, new_dp, dn, dinv);
}
else if (BELOW_THRESHOLD (dn, INV_DIV_Q_THRESHOLD) ||
BELOW_THRESHOLD (nn, 2 * INV_DIV_Q_THRESHOLD))
{
invert_1(dinv, new_dp[dn - 1], new_dp[dn - 2]);
qh = mpn_dc_div_q (qp, new_np, new_nn, new_dp, dn, dinv);
}
else
{
mp_ptr inv = TMP_ALLOC_LIMBS(dn);
mpn_invert(inv, new_dp, dn);
qh = mpn_inv_div_q (qp, new_np, new_nn, new_dp, dn, inv);
}
if (cy == 0)
qp[qn - 1] = qh;
else if (UNLIKELY (qh != 0))
{
/* This happens only when the quotient is close to B^n and
mpn_*_divappr_q returned B^n. */
mp_size_t i, n;
n = new_nn - dn;
for (i = 0; i < n; i++)
qp[i] = GMP_NUMB_MAX;
qh = 0; /* currently ignored */
}
}
else /* divisor is already normalised */
{
if (new_np != np)
MPN_COPY (new_np, np, nn);
if (dn == 2)
{
qh = mpn_divrem_2 (qp, 0L, new_np, nn, dp);
}
else if (BELOW_THRESHOLD (dn, DC_DIV_Q_THRESHOLD) ||
BELOW_THRESHOLD (nn - dn, DC_DIV_Q_THRESHOLD))
{
invert_1(dinv, dh, dp[dn - 2]);
qh = mpn_sb_div_q (qp, new_np, nn, dp, dn, dinv);
}
else if (BELOW_THRESHOLD (dn, INV_DIV_Q_THRESHOLD) ||
BELOW_THRESHOLD (nn, 2 * INV_DIV_Q_THRESHOLD))
{
invert_1(dinv, dh, dp[dn - 2]);
qh = mpn_dc_div_q (qp, new_np, nn, dp, dn, dinv);
}
else
{
mp_ptr inv = TMP_ALLOC_LIMBS(dn);
mpn_invert(inv, dp, dn);
qh = mpn_inv_div_q (qp, new_np, nn, dp, dn, inv);
}
qp[nn - dn] = qh;
}
}
else
{
/* |________________________|
|_________________| */
tp = TMP_ALLOC_LIMBS (qn + 1);
new_np = scratch;
new_nn = 2 * qn + 1;
if (new_np == np)
/* We need {np,nn} to remain untouched until the final adjustment, so
we need to allocate separate space for new_np. */
new_np = TMP_ALLOC_LIMBS (new_nn + 1);
dh = dp[dn - 1];
if (LIKELY ((dh & GMP_NUMB_HIGHBIT) == 0))
{
count_leading_zeros (cnt, dh);
cy = mpn_lshift (new_np, np + nn - new_nn, new_nn, cnt);
new_np[new_nn] = cy;
new_nn += (cy != 0);
new_dp = TMP_ALLOC_LIMBS (qn + 1);
mpn_lshift (new_dp, dp + dn - (qn + 1), qn + 1, cnt);
new_dp[0] |= dp[dn - (qn + 1) - 1] >> (GMP_NUMB_BITS - cnt);
if (qn + 1 == 2)
{
qh = mpn_divrem_2 (tp, 0L, new_np, new_nn, new_dp);
}
else if (BELOW_THRESHOLD (qn - 1, DC_DIVAPPR_Q_THRESHOLD))
{
invert_1(dinv, new_dp[qn], new_dp[qn - 1]);
qh = mpn_sb_divappr_q (tp, new_np, new_nn, new_dp, qn + 1, dinv);
}
else if (BELOW_THRESHOLD (qn - 1, INV_DIVAPPR_Q_THRESHOLD))
{
invert_1(dinv, new_dp[qn], new_dp[qn - 1]);
qh = mpn_dc_divappr_q (tp, new_np, new_nn, new_dp, qn + 1, dinv);
}
else
{
mp_ptr inv = TMP_ALLOC_LIMBS(qn + 1);
mpn_invert(inv, new_dp, qn + 1);
qh = mpn_inv_divappr_q (tp, new_np, new_nn, new_dp, qn + 1, inv);
}
if (cy == 0)
tp[qn] = qh;
else if (UNLIKELY (qh != 0))
{
/* This happens only when the quotient is close to B^n and
mpn_*_divappr_q returned B^n. */
mp_size_t i, n;
n = new_nn - (qn + 1);
for (i = 0; i < n; i++)
tp[i] = GMP_NUMB_MAX;
qh = 0; /* currently ignored */
}
}
else /* divisor is already normalised */
{
mp_limb_t
mpn_dc_divappr_q (mp_ptr qp, mp_ptr np, mp_size_t nn,
mp_srcptr dp, mp_size_t dn, mp_limb_t dinv)
{
mp_size_t q_orig, qn, sh, sl, i;
mp_limb_t qh, cy, cy2;
mp_ptr tp;
TMP_DECL;
ASSERT (dn >= 6);
ASSERT (nn >= dn + 3);
ASSERT (dp[dn-1] & GMP_NUMB_HIGHBIT);
qn = nn - dn;
if (qn + 1 < dn)
{
dp += dn - (qn + 1);
dn = qn + 1;
}
q_orig = qn;
qh = mpn_cmp(np + nn - dn, dp, dn) >= 0;
if (qh != 0)
mpn_sub_n(np + nn - dn, np + nn - dn, dp, dn);
np += nn - dn - qn;
nn = dn + qn;
/* Reduce until dn - 1 >= qn */
while (dn - 1 < qn)
{
sh = MIN(dn, qn - dn + 1);
if (sh <= DC_DIV_QR_THRESHOLD) cy2 = mpn_sb_div_qr(qp + qn - sh, np + nn - dn - sh, dn + sh, dp, dn, dinv);
else cy2 = mpn_dc_div_qr(qp + qn - sh, np + nn - dn - sh, dn + sh, dp, dn, dinv);
qn -= sh; nn -= sh;
}
cy = np[nn - 1];
/* split into two parts */
sh = qn/2; sl = qn - sh;
/* Rare case where truncation ruins normalisation */
if (cy > dp[dn - 1] || (cy == dp[dn - 1]
&& mpn_cmp(np + nn - qn, dp + dn - qn, qn - 1) >= 0))
{
__divappr_helper(qp, np + nn - qn - 2, dp + dn - qn - 1, qn);
return qh;
}
if (mpn_cmp(np + sl + dn - 1, dp + dn - sh - 1, sh + 1) >= 0)
__divappr_helper(qp + sl, np + dn + sl - 2, dp + dn - sh - 1, sh);
else
{
if (sh < SB_DIVAPPR_Q_CUTOFF)
mpn_sb_divappr_q(qp + sl, np + sl, dn + sh, dp, dn, dinv);
else
mpn_dc_divappr_q(qp + sl, np + sl, dn + sh, dp, dn, dinv);
}
cy = np[nn - sh];
TMP_MARK;
tp = TMP_ALLOC_LIMBS(sl + 2);
mpn_mulmid(tp, dp + dn - qn - 1, qn - 1, qp + sl, sh);
cy -= mpn_sub_n(np + nn - qn - 2, np + nn - qn - 2, tp, sl + 2);
TMP_FREE;
while ((mp_limb_signed_t) cy < 0)
{
qh -= mpn_sub_1(qp + sl, qp + sl, q_orig - sl, 1); /* ensure quotient is not too big */
/*
correct remainder, noting that "digits" of quotient aren't base B
but in base varying with truncation, thus correction needs fixup
*/
cy += mpn_add_n(np + nn - qn - 2, np + nn - qn - 2, dp + dn - sl - 2, sl + 2);
for (i = 0; i < sh - 1 && qp[sl + i] == ~CNST_LIMB(0); i++)
cy += mpn_add_1(np + nn - qn - 2, np + nn - qn - 2, sl + 2, dp[dn - sl - 3 - i]);
}
if (cy != 0) /* special case: unable to canonicalise */
__divappr_helper(qp, np + nn - qn - 2, dp + dn - sl - 1, sl);
else
{
if (mpn_cmp(np + dn - 1, dp + dn - sl - 1, sl + 1) >= 0)
__divappr_helper(qp, np + dn - 2, dp + dn - sl - 1, sl);
else
{
if (sl < SB_DIVAPPR_Q_CUTOFF)
mpn_sb_divappr_q(qp, np, dn + sl, dp, dn, dinv);
else
mpn_dc_divappr_q(qp, np, dn + sl, dp, dn, dinv);
}
}
return qh;
}
