mp_limb_t
mpn_dc_divappr_q_n (mp_ptr qp, mp_ptr np, mp_srcptr dp, mp_size_t n,
mp_srcptr dip, mp_ptr tp)
{
mp_size_t lo, hi;
mp_limb_t cy, qh, ql;
lo = n >> 1; /* floor(n/2) */
hi = n - lo; /* ceil(n/2) */
if (BELOW_THRESHOLD (hi, DC_DIV_QR_THRESHOLD))
qh = mpn_sb_div_qr (qp + lo, np + 2 * lo, 2 * hi, dp + lo, hi, dip);
else
qh = mpn_dc_div_qr_n (qp + lo, np + 2 * lo, dp + lo, hi, dip, tp);
mpn_mul (tp, qp + lo, hi, dp, lo);
cy = mpn_sub_n (np + lo, np + lo, tp, n);
if (qh != 0)
cy += mpn_sub_n (np + n, np + n, dp, lo);
while (cy != 0)
{
qh -= mpn_sub_1 (qp + lo, qp + lo, hi, 1);
cy -= mpn_add_n (np + lo, np + lo, dp, n);
}
if (BELOW_THRESHOLD (lo, DC_DIVAPPR_Q_THRESHOLD))
ql = mpn_sb_divappr_q (qp, np + hi, 2 * lo, dp + hi, lo, dip);
else
ql = mpn_dc_divappr_q_n (qp, np + hi, dp + hi, lo, dip, tp);
if (UNLIKELY (ql != 0))
{
mp_size_t i;
for (i = 0; i < lo; i++)
qp[i] = GMP_NUMB_MASK;
}
return qh;
}
/* Check divide and conquer division routine. */
void
check_dc_divappr_q_n (void)
{
mp_limb_t tp[DC_DIVAPPR_Q_N_ITCH(MAX_LIMBS)];
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[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 - 6)) + 6;
nn = 2*dn;
mpn_rrandom (np, rands, nn);
mpn_rrandom (dp, rands, dn);
dp[dn-1] |= GMP_LIMB_HIGHBIT;
MPN_COPY(np2, np, nn);
invert_1(dip, dp[dn - 1], dp[dn - 2]);
qn = nn - dn + 1;
qp[qn - 1] = mpn_dc_divappr_q_n(qp, np, dp, dn, dip, tp);
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);
}
mp_limb_t
mpn_dc_divappr_q_n (mp_ptr qp, mp_ptr np, mp_srcptr dp, mp_size_t n,
mp_limb_t dip, mp_limb_t d1ip, mp_ptr tp)
{
mp_limb_t qh, cy;
mp_ptr q_hi;
mp_size_t m;
mp_limb_t ret = 0;
ASSERT (n >= 6);
/* if the top n limbs of np are >= dp, high limb of quotient is 1 */
if (mpn_cmp(np + n, dp, n) >= 0)
{
ret = 1;
mpn_sub_n(np + n, np + n, dp, n);
}
/* top n limbs of np are now < dp */
m = (n + 1) / 2;
q_hi = qp + n - m;
/*
FIXME: we could probably avoid this copy if we could guarantee
that sb_div_appr_q/dc_divappr_q_n did not destroy the "bottom
half" of N */
MPN_COPY (tp, np, 2*n);
/* estimate high m+1 limbs of quotient, using a 2*m by m division
the quotient may be computed 1 too large as it is approximate,
moreover, even computed precisely it may be two too large due
to the truncation we've done to a 2*m by m division... */
if (m < DC_DIVAPPR_Q_N_THRESHOLD)
qh = mpn_sb_divappr_q (q_hi, tp + 2*n - 2*m, 2*m,
dp + n - m, m, dip, d1ip);
else
qh = mpn_dc_divappr_q_n (q_hi, tp + 2*n - 2*m,
dp + n - m, m, dip, d1ip, tp + 2*n);
/* we therefore decrease the estimate by 3... */
qh -= mpn_sub_1 (q_hi, q_hi, m, (mp_limb_t) 3);
/* ensuring it doesn't become negative */
if (qh & GMP_NUMB_HIGHBIT)
{
MPN_ZERO (q_hi, m);
qh = 0;
}
/* note qh is now always zero as the quotient we have is definitely
correct or up to two too small, and we already normalised np */
ASSERT (qh == 0);
/* we know that {np+n-m, n+m} = q_hi * D + e0, where 0 <= e0 < C*B^n,
where C is a small positive constant. Estimate q_hi * D using
middle product, developing one additional limb, i.e. develop
n - m + 3 limbs. The bottom limb is meaningless and the next limb
may be too small by up to some small multiple of n, but recall
n << B. */
mpn_mulmid (tp, dp, n, q_hi + 1, m - 2);
/* do some parts of the middle product "manually": */
tp[n - m + 2] += mpn_addmul_1 (tp, dp + m - 2, n - m + 2, q_hi[0]);
mpn_addmul_1 (tp + 1, dp, n - m + 2, q_hi[m-1]);
/* subtract that estimate from N. We note the limb at np + n - 2
is then meaningless, and the next limb mght be too large by a
small amount, i.e. the bottom n limbs of np are now possibly
too large by a quantity much less than dp */
mpn_sub_n (np + n - 2, np + n - 2, tp, n - m + 3);
/* recursively divide to obtain low half of quotient, developing
one more limb than we would need if everything had been exact.
As this extra limb is out by only a small amount, rounding the
remaining limbs based on its value and discarding the extra limb
results in a quotient which is at most 1 too large */
if (n - m + 2 < DC_DIVAPPR_Q_N_THRESHOLD)
cy = mpn_sb_divappr_q (tp, np + m - 3, 2*n - 2*m + 4,
dp + m - 2, n - m + 2, dip, d1ip);
else
cy = mpn_dc_divappr_q_n (tp, np + m - 3, dp + m - 2, n - m + 2,
dip, d1ip, tp + n - m + 2);
/* FIXME: The only reason this copy happens is that we elected to
develop one extra quotient limb in the second recursive quotient. */
MPN_COPY (qp, tp + 1, n - m);
/* Construct final quotient from low and hi parts... */
ret += mpn_add_1 (qp + n - m, qp + n - m, m, tp[n-m+1]);
ret += mpn_add_1 (qp + n - m + 1, qp + n - m + 1, m - 1, cy);
if (tp[0] >= GMP_NUMB_HIGHBIT)
ret += mpn_add_1 (qp, qp, n, 1); /* ...rounding quotient up */
/* As the final quotient may be 1 too large, we may have ret == 2
(it is very unlikely, but can be relatively easily triggered
at random when dp = 0x80000...0000), then Q must be 2000....
and we should return instead 1ffff.... */
if (ret == 2)
{
ret -= mpn_sub_1 (qp, qp, n, 1);
ASSERT (ret == 1);
}
return ret;
}
mp_limb_t
mpn_preinv_dc_divappr_q (mp_ptr qp,
mp_ptr np, mp_size_t nn,
mp_srcptr dp, mp_size_t dn,
mp_srcptr dip)
{
mp_size_t qn;
mp_limb_t qh, cy, qsave;
mp_ptr tp;
TMP_DECL;
TMP_MARK;
tp = TMP_SALLOC_LIMBS (dn+1);
qn = nn - dn;
qp += qn;
np += nn;
dp += dn;
if (qn > dn)
{
qn++; /* pretend we'll need an extra limb */
/* Reduce qn mod dn without division, optimizing small operations. */
do
qn -= dn;
while (qn > dn);
qp -= qn; /* point at low limb of next quotient block */
np -= qn; /* point in the middle of partial remainder */
/* Perform the typically smaller block first. */
if (BELOW_THRESHOLD (qn, DC_DIV_QR_THRESHOLD))
qh = mpn_sb_div_qr (qp, np - qn, 2 * qn, dp - qn, qn, dip);
else
qh = mpn_dc_div_qr_n (qp, np - qn, dp - qn, qn, dip, tp);
if (qn != dn)
{
if (qn > dn - qn)
mpn_mul (tp, qp, qn, dp - dn, dn - qn);
else
mpn_mul (tp, dp - dn, dn - qn, qp, qn);
cy = mpn_sub_n (np - dn, np - dn, tp, dn);
if (qh != 0)
cy += mpn_sub_n (np - dn + qn, np - dn + qn, dp - dn, dn - qn);
while (cy != 0)
{
qh -= mpn_sub_1 (qp, qp, qn, 1);
cy -= mpn_add_n (np - dn, np - dn, dp - dn, dn);
}
}
qn = nn - dn - qn + 1;
while (qn > dn)
{
qp -= dn;
np -= dn;
mpn_dc_div_qr_n (qp, np - dn, dp - dn, dn, dip, tp);
qn -= dn;
}
/* Since we pretended we'd need an extra quotient limb before, we now
have made sure the code above left just dn-1=qn quotient limbs to
develop. Develop that plus a guard limb. */
qn--;
qp -= qn;
np -= dn;
qsave = qp[qn];
mpn_dc_divappr_q_n (qp, np - dn, dp - dn, dn, dip, tp);
MPN_COPY_INCR (qp, qp + 1, qn);
qp[qn] = qsave;
}
else
{
if (qn == 0)
{
qh = mpn_cmp (np - dn, dp - dn, dn) >= 0;
if (qh)
mpn_sub_n (np - dn, np - dn, dp - dn, dn);
TMP_FREE;
return qh;
}
qp -= qn; /* point at low limb of next quotient block */
np -= qn; /* point in the middle of partial remainder */
if (BELOW_THRESHOLD (qn, DC_DIVAPPR_Q_THRESHOLD))
/* Full precision. Optimal? */
qh = mpn_sb_divappr_q (qp, np - dn, nn, dp - dn, dn, dip);
else
{
/* Put quotient in tp, use qp as temporary, since qp lacks a limb. */
qh = mpn_dc_divappr_q_n (tp, np - qn - 2, dp - (qn + 1), qn + 1, dip, qp);
MPN_COPY (qp, tp + 1, qn);
}
}
TMP_FREE;
return qh;
}
