mp_exp_t
mpfr_get_z_exp (mpz_ptr z, mpfr_srcptr f)
{
mp_size_t fn;
int sh;
MPFR_ASSERTD (MPFR_IS_FP (f));
if (MPFR_UNLIKELY (MPFR_IS_ZERO (f)))
{
mpz_set_ui (z, 0);
return __gmpfr_emin;
}
fn = MPFR_LIMB_SIZE(f);
/* check whether allocated space for z is enough */
if (MPFR_UNLIKELY (ALLOC (z) < fn))
MPZ_REALLOC (z, fn);
MPFR_UNSIGNED_MINUS_MODULO (sh, MPFR_PREC (f));
if (MPFR_LIKELY (sh))
mpn_rshift (PTR (z), MPFR_MANT (f), fn, sh);
else
MPN_COPY (PTR (z), MPFR_MANT (f), fn);
SIZ(z) = MPFR_IS_NEG (f) ? -fn : fn;
/* Test if the result is representable. Later, we could choose
to return MPFR_EXP_MIN if it isn't, or perhaps MPFR_EXP_MAX
to signal an error. The mantissa would still be meaningful. */
MPFR_ASSERTD ((mp_exp_unsigned_t) MPFR_GET_EXP (f) - MPFR_EXP_MIN
>= (mp_exp_unsigned_t) MPFR_PREC(f));
return MPFR_GET_EXP (f) - MPFR_PREC (f);
}
int
mpfr_sub1sp (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mpfr_rnd_t rnd_mode)
{
mpfr_exp_t bx,cx;
mpfr_uexp_t d;
mpfr_prec_t p, sh, cnt;
mp_size_t n;
mp_limb_t *ap, *bp, *cp;
mp_limb_t limb;
int inexact;
mp_limb_t bcp,bcp1; /* Cp and C'p+1 */
mp_limb_t bbcp = (mp_limb_t) -1, bbcp1 = (mp_limb_t) -1; /* Cp+1 and C'p+2,
gcc claims that they might be used uninitialized. We fill them with invalid
values, which should produce a failure if so. See README.dev file. */
MPFR_TMP_DECL(marker);
MPFR_TMP_MARK(marker);
MPFR_ASSERTD(MPFR_PREC(a) == MPFR_PREC(b) && MPFR_PREC(b) == MPFR_PREC(c));
MPFR_ASSERTD(MPFR_IS_PURE_FP(b));
MPFR_ASSERTD(MPFR_IS_PURE_FP(c));
/* Read prec and num of limbs */
p = MPFR_PREC (b);
n = MPFR_PREC2LIMBS (p);
/* Fast cmp of |b| and |c|*/
bx = MPFR_GET_EXP (b);
cx = MPFR_GET_EXP (c);
if (MPFR_UNLIKELY(bx == cx))
{
mp_size_t k = n - 1;
/* Check mantissa since exponent are equals */
bp = MPFR_MANT(b);
cp = MPFR_MANT(c);
while (k>=0 && MPFR_UNLIKELY(bp[k] == cp[k]))
k--;
if (MPFR_UNLIKELY(k < 0))
/* b == c ! */
{
/* Return exact number 0 */
if (rnd_mode == MPFR_RNDD)
MPFR_SET_NEG(a);
else
MPFR_SET_POS(a);
MPFR_SET_ZERO(a);
MPFR_RET(0);
}
else if (bp[k] > cp[k])
goto BGreater;
else
{
MPFR_ASSERTD(bp[k]<cp[k]);
goto CGreater;
}
}
else if (MPFR_UNLIKELY(bx < cx))
{
/* Swap b and c and set sign */
mpfr_srcptr t;
mpfr_exp_t tx;
CGreater:
MPFR_SET_OPPOSITE_SIGN(a,b);
t = b; b = c; c = t;
tx = bx; bx = cx; cx = tx;
}
else
{
/* b > c */
BGreater:
MPFR_SET_SAME_SIGN(a,b);
}
/* Now b > c */
MPFR_ASSERTD(bx >= cx);
d = (mpfr_uexp_t) bx - cx;
DEBUG (printf ("New with diff=%lu\n", (unsigned long) d));
if (MPFR_UNLIKELY(d <= 1))
{
if (MPFR_LIKELY(d < 1))
{
/* <-- b -->
<-- c --> : exact sub */
ap = MPFR_MANT(a);
mpn_sub_n (ap, MPFR_MANT(b), MPFR_MANT(c), n);
/* Normalize */
ExactNormalize:
limb = ap[n-1];
if (MPFR_LIKELY(limb))
{
/* First limb is not zero. */
count_leading_zeros(cnt, limb);
/* cnt could be == 0 <= SubD1Lose */
if (MPFR_LIKELY(cnt))
{
mpn_lshift(ap, ap, n, cnt); /* Normalize number */
bx -= cnt; /* Update final expo */
}
/* Last limb should be ok */
MPFR_ASSERTD(!(ap[0] & MPFR_LIMB_MASK((unsigned int) (-p)
% GMP_NUMB_BITS)));
}
else
{
/* First limb is zero */
mp_size_t k = n-1, len;
/* Find the first limb not equal to zero.
FIXME:It is assume it exists (since |b| > |c| and same prec)*/
do
{
MPFR_ASSERTD( k > 0 );
limb = ap[--k];
}
while (limb == 0);
MPFR_ASSERTD(limb != 0);
count_leading_zeros(cnt, limb);
k++;
len = n - k; /* Number of last limb */
MPFR_ASSERTD(k >= 0);
if (MPFR_LIKELY(cnt))
mpn_lshift(ap+len, ap, k, cnt); /* Normalize the High Limb*/
else
{
/* Must use DECR since src and dest may overlap & dest>=src*/
MPN_COPY_DECR(ap+len, ap, k);
}
MPN_ZERO(ap, len); /* Zeroing the last limbs */
bx -= cnt + len*GMP_NUMB_BITS; /* Update Expo */
/* Last limb should be ok */
MPFR_ASSERTD(!(ap[len]&MPFR_LIMB_MASK((unsigned int) (-p)
% GMP_NUMB_BITS)));
}
/* Check expo underflow */
if (MPFR_UNLIKELY(bx < __gmpfr_emin))
{
MPFR_TMP_FREE(marker);
/* inexact=0 */
DEBUG( printf("(D==0 Underflow)\n") );
if (rnd_mode == MPFR_RNDN &&
(bx < __gmpfr_emin - 1 ||
(/*inexact >= 0 &&*/ mpfr_powerof2_raw (a))))
rnd_mode = MPFR_RNDZ;
return mpfr_underflow (a, rnd_mode, MPFR_SIGN(a));
}
MPFR_SET_EXP (a, bx);
/* No rounding is necessary since the result is exact */
MPFR_ASSERTD(ap[n-1] > ~ap[n-1]);
MPFR_TMP_FREE(marker);
return 0;
}
else /* if (d == 1) */
{
/* | <-- b -->
| <-- c --> */
mp_limb_t c0, mask;
mp_size_t k;
MPFR_UNSIGNED_MINUS_MODULO(sh, p);
/* If we lose at least one bit, compute 2*b-c (Exact)
* else compute b-c/2 */
bp = MPFR_MANT(b);
cp = MPFR_MANT(c);
k = n-1;
limb = bp[k] - cp[k]/2;
if (limb > MPFR_LIMB_HIGHBIT)
{
/* We can't lose precision: compute b-c/2 */
/* Shift c in the allocated temporary block */
SubD1NoLose:
c0 = cp[0] & (MPFR_LIMB_ONE<<sh);
cp = MPFR_TMP_LIMBS_ALLOC (n);
mpn_rshift(cp, MPFR_MANT(c), n, 1);
if (MPFR_LIKELY(c0 == 0))
{
/* Result is exact: no need of rounding! */
ap = MPFR_MANT(a);
mpn_sub_n (ap, bp, cp, n);
MPFR_SET_EXP(a, bx); /* No expo overflow! */
/* No truncate or normalize is needed */
MPFR_ASSERTD(ap[n-1] > ~ap[n-1]);
/* No rounding is necessary since the result is exact */
MPFR_TMP_FREE(marker);
return 0;
}
ap = MPFR_MANT(a);
mask = ~MPFR_LIMB_MASK(sh);
cp[0] &= mask; /* Delete last bit of c */
mpn_sub_n (ap, bp, cp, n);
MPFR_SET_EXP(a, bx); /* No expo overflow! */
MPFR_ASSERTD( !(ap[0] & ~mask) ); /* Check last bits */
/* No normalize is needed */
MPFR_ASSERTD(ap[n-1] > ~ap[n-1]);
/* Rounding is necessary since c0 = 1*/
/* Cp =-1 and C'p+1=0 */
bcp = 1; bcp1 = 0;
if (MPFR_LIKELY(rnd_mode == MPFR_RNDN))
{
/* Even Rule apply: Check Ap-1 */
if (MPFR_LIKELY( (ap[0] & (MPFR_LIMB_ONE<<sh)) == 0) )
goto truncate;
else
goto sub_one_ulp;
}
MPFR_UPDATE_RND_MODE(rnd_mode, MPFR_IS_NEG(a));
if (rnd_mode == MPFR_RNDZ)
goto sub_one_ulp;
else
goto truncate;
}
else if (MPFR_LIKELY(limb < MPFR_LIMB_HIGHBIT))
{
/* We lose at least one bit of prec */
/* Calcul of 2*b-c (Exact) */
/* Shift b in the allocated temporary block */
SubD1Lose:
bp = MPFR_TMP_LIMBS_ALLOC (n);
mpn_lshift (bp, MPFR_MANT(b), n, 1);
ap = MPFR_MANT(a);
mpn_sub_n (ap, bp, cp, n);
bx--;
goto ExactNormalize;
}
else
{
/* Case: limb = 100000000000 */
/* Check while b[k] == c'[k] (C' is C shifted by 1) */
/* If b[k]<c'[k] => We lose at least one bit*/
/* If b[k]>c'[k] => We don't lose any bit */
/* If k==-1 => We don't lose any bit
AND the result is 100000000000 0000000000 00000000000 */
mp_limb_t carry;
do {
carry = cp[k]&MPFR_LIMB_ONE;
k--;
} while (k>=0 &&
bp[k]==(carry=cp[k]/2+(carry<<(GMP_NUMB_BITS-1))));
if (MPFR_UNLIKELY(k<0))
{
/*If carry then (sh==0 and Virtual c'[-1] > Virtual b[-1]) */
if (MPFR_UNLIKELY(carry)) /* carry = cp[0]&MPFR_LIMB_ONE */
{
/* FIXME: Can be faster? */
MPFR_ASSERTD(sh == 0);
goto SubD1Lose;
}
/* Result is a power of 2 */
ap = MPFR_MANT (a);
MPN_ZERO (ap, n);
ap[n-1] = MPFR_LIMB_HIGHBIT;
MPFR_SET_EXP (a, bx); /* No expo overflow! */
/* No Normalize is needed*/
/* No Rounding is needed */
MPFR_TMP_FREE (marker);
return 0;
}
/* carry = cp[k]/2+(cp[k-1]&1)<<(GMP_NUMB_BITS-1) = c'[k]*/
else if (bp[k] > carry)
goto SubD1NoLose;
else
{
MPFR_ASSERTD(bp[k]<carry);
goto SubD1Lose;
}
}
}
}
else if (MPFR_UNLIKELY(d >= p))
{
ap = MPFR_MANT(a);
MPFR_UNSIGNED_MINUS_MODULO(sh, p);
/* We can't set A before since we use cp for rounding... */
/* Perform rounding: check if a=b or a=b-ulp(b) */
if (MPFR_UNLIKELY(d == p))
{
/* cp == -1 and c'p+1 = ? */
bcp = 1;
/* We need Cp+1 later for a very improbable case. */
bbcp = (MPFR_MANT(c)[n-1] & (MPFR_LIMB_ONE<<(GMP_NUMB_BITS-2)));
/* We need also C'p+1 for an even more unprobable case... */
if (MPFR_LIKELY( bbcp ))
bcp1 = 1;
else
{
cp = MPFR_MANT(c);
if (MPFR_UNLIKELY(cp[n-1] == MPFR_LIMB_HIGHBIT))
{
mp_size_t k = n-1;
do {
k--;
} while (k>=0 && cp[k]==0);
bcp1 = (k>=0);
}
else
bcp1 = 1;
}
DEBUG( printf("(D=P) Cp=-1 Cp+1=%d C'p+1=%d \n", bbcp!=0, bcp1!=0) );
bp = MPFR_MANT (b);
/* Even if src and dest overlap, it is ok using MPN_COPY */
if (MPFR_LIKELY(rnd_mode == MPFR_RNDN))
{
if (MPFR_UNLIKELY( bcp && bcp1==0 ))
/* Cp=-1 and C'p+1=0: Even rule Apply! */
/* Check Ap-1 = Bp-1 */
if ((bp[0] & (MPFR_LIMB_ONE<<sh)) == 0)
{
MPN_COPY(ap, bp, n);
goto truncate;
}
MPN_COPY(ap, bp, n);
goto sub_one_ulp;
}
MPFR_UPDATE_RND_MODE(rnd_mode, MPFR_IS_NEG(a));
if (rnd_mode == MPFR_RNDZ)
{
MPN_COPY(ap, bp, n);
goto sub_one_ulp;
}
else
{
MPN_COPY(ap, bp, n);
goto truncate;
}
}
else
{
/* Cp=0, Cp+1=-1 if d==p+1, C'p+1=-1 */
bcp = 0; bbcp = (d==p+1); bcp1 = 1;
DEBUG( printf("(D>P) Cp=%d Cp+1=%d C'p+1=%d\n", bcp!=0,bbcp!=0,bcp1!=0) );
/* Need to compute C'p+2 if d==p+1 and if rnd_mode=NEAREST
(Because of a very improbable case) */
if (MPFR_UNLIKELY(d==p+1 && rnd_mode==MPFR_RNDN))
{
cp = MPFR_MANT(c);
if (MPFR_UNLIKELY(cp[n-1] == MPFR_LIMB_HIGHBIT))
{
mp_size_t k = n-1;
do {
k--;
} while (k>=0 && cp[k]==0);
bbcp1 = (k>=0);
}
else
bbcp1 = 1;
DEBUG( printf("(D>P) C'p+2=%d\n", bbcp1!=0) );
}
/* Copy mantissa B in A */
MPN_COPY(ap, MPFR_MANT(b), n);
/* Round */
if (MPFR_LIKELY(rnd_mode == MPFR_RNDN))
goto truncate;
MPFR_UPDATE_RND_MODE(rnd_mode, MPFR_IS_NEG(a));
if (rnd_mode == MPFR_RNDZ)
goto sub_one_ulp;
else /* rnd_mode = AWAY */
goto truncate;
}
}
else
{
mpfr_uexp_t dm;
mp_size_t m;
mp_limb_t mask;
/* General case: 2 <= d < p */
MPFR_UNSIGNED_MINUS_MODULO(sh, p);
cp = MPFR_TMP_LIMBS_ALLOC (n);
/* Shift c in temporary allocated place */
dm = d % GMP_NUMB_BITS;
m = d / GMP_NUMB_BITS;
if (MPFR_UNLIKELY(dm == 0))
{
/* dm = 0 and m > 0: Just copy */
MPFR_ASSERTD(m!=0);
MPN_COPY(cp, MPFR_MANT(c)+m, n-m);
MPN_ZERO(cp+n-m, m);
}
else if (MPFR_LIKELY(m == 0))
{
/* dm >=2 and m == 0: just shift */
MPFR_ASSERTD(dm >= 2);
mpn_rshift(cp, MPFR_MANT(c), n, dm);
}
else
{
/* dm > 0 and m > 0: shift and zero */
mpn_rshift(cp, MPFR_MANT(c)+m, n-m, dm);
MPN_ZERO(cp+n-m, m);
}
DEBUG( mpfr_print_mant_binary("Before", MPFR_MANT(c), p) );
DEBUG( mpfr_print_mant_binary("B= ", MPFR_MANT(b), p) );
DEBUG( mpfr_print_mant_binary("After ", cp, p) );
/* Compute bcp=Cp and bcp1=C'p+1 */
if (MPFR_LIKELY(sh))
{
/* Try to compute them from C' rather than C (FIXME: Faster?) */
bcp = (cp[0] & (MPFR_LIMB_ONE<<(sh-1))) ;
if (MPFR_LIKELY( cp[0] & MPFR_LIMB_MASK(sh-1) ))
bcp1 = 1;
else
{
/* We can't compute C'p+1 from C'. Compute it from C */
/* Start from bit x=p-d+sh in mantissa C
(+sh since we have already looked sh bits in C'!) */
mpfr_prec_t x = p-d+sh-1;
if (MPFR_LIKELY(x>p))
/* We are already looked at all the bits of c, so C'p+1 = 0*/
bcp1 = 0;
else
{
mp_limb_t *tp = MPFR_MANT(c);
mp_size_t kx = n-1 - (x / GMP_NUMB_BITS);
mpfr_prec_t sx = GMP_NUMB_BITS-1-(x%GMP_NUMB_BITS);
DEBUG (printf ("(First) x=%lu Kx=%ld Sx=%lu\n",
(unsigned long) x, (long) kx,
(unsigned long) sx));
/* Looks at the last bits of limb kx (if sx=0 does nothing)*/
if (tp[kx] & MPFR_LIMB_MASK(sx))
bcp1 = 1;
else
{
/*kx += (sx==0);*/
/*If sx==0, tp[kx] hasn't been checked*/
do {
kx--;
} while (kx>=0 && tp[kx]==0);
bcp1 = (kx >= 0);
}
}
}
}
else
{
/* Compute Cp and C'p+1 from C with sh=0 */
mp_limb_t *tp = MPFR_MANT(c);
/* Start from bit x=p-d in mantissa C */
mpfr_prec_t x = p-d;
mp_size_t kx = n-1 - (x / GMP_NUMB_BITS);
mpfr_prec_t sx = GMP_NUMB_BITS-1-(x%GMP_NUMB_BITS);
MPFR_ASSERTD(p >= d);
bcp = (tp[kx] & (MPFR_LIMB_ONE<<sx));
/* Looks at the last bits of limb kx (If sx=0, does nothing)*/
if (tp[kx] & MPFR_LIMB_MASK(sx))
bcp1 = 1;
else
{
/*kx += (sx==0);*/ /*If sx==0, tp[kx] hasn't been checked*/
do {
kx--;
} while (kx>=0 && tp[kx]==0);
bcp1 = (kx>=0);
}
}
DEBUG( printf("sh=%lu Cp=%d C'p+1=%d\n", sh, bcp!=0, bcp1!=0) );
/* Check if we can lose a bit, and if so compute Cp+1 and C'p+2 */
bp = MPFR_MANT(b);
if (MPFR_UNLIKELY((bp[n-1]-cp[n-1]) <= MPFR_LIMB_HIGHBIT))
{
/* We can lose a bit so we precompute Cp+1 and C'p+2 */
/* Test for trivial case: since C'p+1=0, Cp+1=0 and C'p+2 =0 */
if (MPFR_LIKELY(bcp1 == 0))
{
bbcp = 0;
bbcp1 = 0;
}
else /* bcp1 != 0 */
{
/* We can lose a bit:
compute Cp+1 and C'p+2 from mantissa C */
mp_limb_t *tp = MPFR_MANT(c);
/* Start from bit x=(p+1)-d in mantissa C */
mpfr_prec_t x = p+1-d;
mp_size_t kx = n-1 - (x/GMP_NUMB_BITS);
mpfr_prec_t sx = GMP_NUMB_BITS-1-(x%GMP_NUMB_BITS);
MPFR_ASSERTD(p > d);
DEBUG (printf ("(pre) x=%lu Kx=%ld Sx=%lu\n",
(unsigned long) x, (long) kx,
(unsigned long) sx));
bbcp = (tp[kx] & (MPFR_LIMB_ONE<<sx)) ;
/* Looks at the last bits of limb kx (If sx=0, does nothing)*/
/* If Cp+1=0, since C'p+1!=0, C'p+2=1 ! */
if (MPFR_LIKELY(bbcp==0 || (tp[kx]&MPFR_LIMB_MASK(sx))))
bbcp1 = 1;
else
{
/*kx += (sx==0);*/ /*If sx==0, tp[kx] hasn't been checked*/
do {
kx--;
} while (kx>=0 && tp[kx]==0);
bbcp1 = (kx>=0);
DEBUG (printf ("(Pre) Scan done for %ld\n", (long) kx));
}
} /*End of Bcp1 != 0*/
DEBUG( printf("(Pre) Cp+1=%d C'p+2=%d\n", bbcp!=0, bbcp1!=0) );
} /* End of "can lose a bit" */
/* Clean shifted C' */
mask = ~MPFR_LIMB_MASK (sh);
cp[0] &= mask;
/* Subtract the mantissa c from b in a */
ap = MPFR_MANT(a);
mpn_sub_n (ap, bp, cp, n);
DEBUG( mpfr_print_mant_binary("Sub= ", ap, p) );
/* Normalize: we lose at max one bit*/
if (MPFR_UNLIKELY(MPFR_LIMB_MSB(ap[n-1]) == 0))
{
/* High bit is not set and we have to fix it! */
/* Ap >= 010000xxx001 */
mpn_lshift(ap, ap, n, 1);
/* Ap >= 100000xxx010 */
if (MPFR_UNLIKELY(bcp!=0)) /* Check if Cp = -1 */
/* Since Cp == -1, we have to substract one more */
{
mpn_sub_1(ap, ap, n, MPFR_LIMB_ONE<<sh);
MPFR_ASSERTD(MPFR_LIMB_MSB(ap[n-1]) != 0);
}
/* Ap >= 10000xxx001 */
/* Final exponent -1 since we have shifted the mantissa */
bx--;
/* Update bcp and bcp1 */
MPFR_ASSERTN(bbcp != (mp_limb_t) -1);
MPFR_ASSERTN(bbcp1 != (mp_limb_t) -1);
bcp = bbcp;
bcp1 = bbcp1;
/* We dont't have anymore a valid Cp+1!
But since Ap >= 100000xxx001, the final sub can't unnormalize!*/
}
MPFR_ASSERTD( !(ap[0] & ~mask) );
/* Rounding */
if (MPFR_LIKELY(rnd_mode == MPFR_RNDN))
{
if (MPFR_LIKELY(bcp==0))
goto truncate;
else if ((bcp1) || ((ap[0] & (MPFR_LIMB_ONE<<sh)) != 0))
goto sub_one_ulp;
else
goto truncate;
}
/* Update rounding mode */
MPFR_UPDATE_RND_MODE(rnd_mode, MPFR_IS_NEG(a));
if (rnd_mode == MPFR_RNDZ && (MPFR_LIKELY(bcp || bcp1)))
goto sub_one_ulp;
goto truncate;
}
MPFR_RET_NEVER_GO_HERE ();
/* Sub one ulp to the result */
sub_one_ulp:
mpn_sub_1 (ap, ap, n, MPFR_LIMB_ONE << sh);
/* Result should be smaller than exact value: inexact=-1 */
inexact = -1;
/* Check normalisation */
if (MPFR_UNLIKELY(MPFR_LIMB_MSB(ap[n-1]) == 0))
{
/* ap was a power of 2, and we lose a bit */
/* Now it is 0111111111111111111[00000 */
mpn_lshift(ap, ap, n, 1);
bx--;
/* And the lost bit x depends on Cp+1, and Cp */
/* Compute Cp+1 if it isn't already compute (ie d==1) */
/* FIXME: Is this case possible? */
if (MPFR_UNLIKELY(d == 1))
bbcp = 0;
DEBUG( printf("(SubOneUlp)Cp=%d, Cp+1=%d C'p+1=%d\n", bcp!=0,bbcp!=0,bcp1!=0));
/* Compute the last bit (Since we have shifted the mantissa)
we need one more bit!*/
MPFR_ASSERTN(bbcp != (mp_limb_t) -1);
if ( (rnd_mode == MPFR_RNDZ && bcp==0)
|| (rnd_mode==MPFR_RNDN && bbcp==0)
|| (bcp && bcp1==0) ) /*Exact result*/
{
ap[0] |= MPFR_LIMB_ONE<<sh;
if (rnd_mode == MPFR_RNDN)
inexact = 1;
DEBUG( printf("(SubOneUlp) Last bit set\n") );
}
/* Result could be exact if C'p+1 = 0 and rnd == Zero
since we have had one more bit to the result */
/* Fixme: rnd_mode == MPFR_RNDZ needed ? */
if (bcp1==0 && rnd_mode==MPFR_RNDZ)
{
DEBUG( printf("(SubOneUlp) Exact result\n") );
inexact = 0;
}
}
goto end_of_sub;
truncate:
/* Check if the result is an exact power of 2: 100000000000
in which cases, we could have to do sub_one_ulp due to some nasty reasons:
If Result is a Power of 2:
+ If rnd = AWAY,
| If Cp=-1 and C'p+1 = 0, SubOneUlp and the result is EXACT.
If Cp=-1 and C'p+1 =-1, SubOneUlp and the result is above.
Otherwise truncate
+ If rnd = NEAREST,
If Cp= 0 and Cp+1 =-1 and C'p+2=-1, SubOneUlp and the result is above
If cp=-1 and C'p+1 = 0, SubOneUlp and the result is exact.
Otherwise truncate.
X bit should always be set if SubOneUlp*/
if (MPFR_UNLIKELY(ap[n-1] == MPFR_LIMB_HIGHBIT))
{
mp_size_t k = n-1;
do {
k--;
} while (k>=0 && ap[k]==0);
if (MPFR_UNLIKELY(k<0))
{
/* It is a power of 2! */
/* Compute Cp+1 if it isn't already compute (ie d==1) */
/* FIXME: Is this case possible? */
if (d == 1)
bbcp=0;
DEBUG( printf("(Truncate) Cp=%d, Cp+1=%d C'p+1=%d C'p+2=%d\n", \
bcp!=0, bbcp!=0, bcp1!=0, bbcp1!=0) );
MPFR_ASSERTN(bbcp != (mp_limb_t) -1);
MPFR_ASSERTN((rnd_mode != MPFR_RNDN) || (bcp != 0) || (bbcp == 0) || (bbcp1 != (mp_limb_t) -1));
if (((rnd_mode != MPFR_RNDZ) && bcp)
||
((rnd_mode == MPFR_RNDN) && (bcp == 0) && (bbcp) && (bbcp1)))
{
DEBUG( printf("(Truncate) Do sub\n") );
mpn_sub_1 (ap, ap, n, MPFR_LIMB_ONE << sh);
mpn_lshift(ap, ap, n, 1);
ap[0] |= MPFR_LIMB_ONE<<sh;
bx--;
/* FIXME: Explain why it works (or why not)... */
inexact = (bcp1 == 0) ? 0 : (rnd_mode==MPFR_RNDN) ? -1 : 1;
goto end_of_sub;
}
}
}
/* Calcul of Inexact flag.*/
inexact = MPFR_LIKELY(bcp || bcp1) ? 1 : 0;
end_of_sub:
/* Update Expo */
/* FIXME: Is this test really useful?
If d==0 : Exact case. This is never called.
if 1 < d < p : bx=MPFR_EXP(b) or MPFR_EXP(b)-1 > MPFR_EXP(c) > emin
if d == 1 : bx=MPFR_EXP(b). If we could lose any bits, the exact
normalisation is called.
if d >= p : bx=MPFR_EXP(b) >= MPFR_EXP(c) + p > emin
After SubOneUlp, we could have one bit less.
if 1 < d < p : bx >= MPFR_EXP(b)-2 >= MPFR_EXP(c) > emin
if d == 1 : bx >= MPFR_EXP(b)-1 = MPFR_EXP(c) > emin.
if d >= p : bx >= MPFR_EXP(b)-1 > emin since p>=2.
*/
MPFR_ASSERTD( bx >= __gmpfr_emin);
/*
if (MPFR_UNLIKELY(bx < __gmpfr_emin))
{
DEBUG( printf("(Final Underflow)\n") );
if (rnd_mode == MPFR_RNDN &&
(bx < __gmpfr_emin - 1 ||
(inexact >= 0 && mpfr_powerof2_raw (a))))
rnd_mode = MPFR_RNDZ;
MPFR_TMP_FREE(marker);
return mpfr_underflow (a, rnd_mode, MPFR_SIGN(a));
}
*/
MPFR_SET_EXP (a, bx);
MPFR_TMP_FREE(marker);
MPFR_RET (inexact * MPFR_INT_SIGN (a));
}
int
mpfr_rint (mpfr_ptr r, mpfr_srcptr u, mpfr_rnd_t rnd_mode)
{
int sign;
int rnd_away;
mp_exp_t exp;
if (MPFR_UNLIKELY( MPFR_IS_SINGULAR(u) ))
{
if (MPFR_IS_NAN(u))
{
MPFR_SET_NAN(r);
MPFR_RET_NAN;
}
MPFR_SET_SAME_SIGN(r, u);
if (MPFR_IS_INF(u))
{
MPFR_SET_INF(r);
MPFR_RET(0); /* infinity is exact */
}
else /* now u is zero */
{
MPFR_ASSERTD(MPFR_IS_ZERO(u));
MPFR_SET_ZERO(r);
MPFR_RET(0); /* zero is exact */
}
}
MPFR_SET_SAME_SIGN (r, u); /* Does nothing if r==u */
sign = MPFR_INT_SIGN (u);
exp = MPFR_GET_EXP (u);
rnd_away =
rnd_mode == GMP_RNDD ? sign < 0 :
rnd_mode == GMP_RNDU ? sign > 0 :
rnd_mode == GMP_RNDZ ? 0 : -1;
/* rnd_away:
1 if round away from zero,
0 if round to zero,
-1 if not decided yet.
*/
if (MPFR_UNLIKELY (exp <= 0)) /* 0 < |u| < 1 ==> round |u| to 0 or 1 */
{
/* Note: in the GMP_RNDN mode, 0.5 must be rounded to 0. */
if (rnd_away != 0 &&
(rnd_away > 0 ||
(exp == 0 && (rnd_mode == GMP_RNDNA ||
!mpfr_powerof2_raw (u)))))
{
mp_limb_t *rp;
mp_size_t rm;
rp = MPFR_MANT(r);
rm = (MPFR_PREC(r) - 1) / BITS_PER_MP_LIMB;
rp[rm] = MPFR_LIMB_HIGHBIT;
MPN_ZERO(rp, rm);
MPFR_SET_EXP (r, 1); /* |r| = 1 */
MPFR_RET(sign > 0 ? 2 : -2);
}
else
{
MPFR_SET_ZERO(r); /* r = 0 */
MPFR_RET(sign > 0 ? -2 : 2);
}
}
else /* exp > 0, |u| >= 1 */
{
mp_limb_t *up, *rp;
mp_size_t un, rn, ui;
int sh, idiff;
int uflags;
/*
* uflags will contain:
* _ 0 if u is an integer representable in r,
* _ 1 if u is an integer not representable in r,
* _ 2 if u is not an integer.
*/
up = MPFR_MANT(u);
rp = MPFR_MANT(r);
un = MPFR_LIMB_SIZE(u);
rn = MPFR_LIMB_SIZE(r);
MPFR_UNSIGNED_MINUS_MODULO (sh, MPFR_PREC (r));
MPFR_SET_EXP (r, exp); /* Does nothing if r==u */
if ((exp - 1) / BITS_PER_MP_LIMB >= un)
{
ui = un;
idiff = 0;
uflags = 0; /* u is an integer, representable or not in r */
}
else
{
mp_size_t uj;
ui = (exp - 1) / BITS_PER_MP_LIMB + 1; /* #limbs of the int part */
MPFR_ASSERTD (un >= ui);
uj = un - ui; /* lowest limb of the integer part */
idiff = exp % BITS_PER_MP_LIMB; /* #int-part bits in up[uj] or 0 */
uflags = idiff == 0 || (up[uj] << idiff) == 0 ? 0 : 2;
if (uflags == 0)
while (uj > 0)
if (up[--uj] != 0)
{
uflags = 2;
break;
}
}
if (ui > rn)
{
/* More limbs in the integer part of u than in r.
Just round u with the precision of r. */
MPFR_ASSERTD (rp != up && un > rn);
MPN_COPY (rp, up + (un - rn), rn); /* r != u */
if (rnd_away < 0)
{
/* This is a rounding to nearest mode (GMP_RNDN or GMP_RNDNA).
Decide the rounding direction here. */
if (rnd_mode == GMP_RNDN &&
(rp[0] & (MPFR_LIMB_ONE << sh)) == 0)
{ /* halfway cases rounded toward zero */
mp_limb_t a, b;
/* a: rounding bit and some of the following bits */
/* b: boundary for a (weight of the rounding bit in a) */
if (sh != 0)
{
a = rp[0] & ((MPFR_LIMB_ONE << sh) - 1);
b = MPFR_LIMB_ONE << (sh - 1);
}
else
{
a = up[un - rn - 1];
b = MPFR_LIMB_HIGHBIT;
}
rnd_away = a > b;
if (a == b)
{
mp_size_t i;
for (i = un - rn - 1 - (sh == 0); i >= 0; i--)
if (up[i] != 0)
{
rnd_away = 1;
break;
}
}
}
else /* halfway cases rounded away from zero */
rnd_away = /* rounding bit */
((sh != 0 && (rp[0] & (MPFR_LIMB_ONE << (sh - 1))) != 0) ||
(sh == 0 && (up[un - rn - 1] & MPFR_LIMB_HIGHBIT) != 0));
}
if (uflags == 0)
{ /* u is an integer; determine if it is representable in r */
if (sh != 0 && rp[0] << (BITS_PER_MP_LIMB - sh) != 0)
uflags = 1; /* u is not representable in r */
else
{
mp_size_t i;
for (i = un - rn - 1; i >= 0; i--)
if (up[i] != 0)
{
uflags = 1; /* u is not representable in r */
break;
}
}
}
}
else /* ui <= rn */
{
mp_size_t uj, rj;
int ush;
uj = un - ui; /* lowest limb of the integer part in u */
rj = rn - ui; /* lowest limb of the integer part in r */
if (MPFR_LIKELY (rp != up))
MPN_COPY(rp + rj, up + uj, ui);
/* Ignore the lowest rj limbs, all equal to zero. */
rp += rj;
rn = ui;
/* number of fractional bits in whole rp[0] */
ush = idiff == 0 ? 0 : BITS_PER_MP_LIMB - idiff;
if (rj == 0 && ush < sh)
{
/* If u is an integer (uflags == 0), we need to determine
if it is representable in r, i.e. if its sh - ush bits
in the non-significant part of r are all 0. */
if (uflags == 0 && (rp[0] & ((MPFR_LIMB_ONE << sh) -
(MPFR_LIMB_ONE << ush))) != 0)
uflags = 1; /* u is an integer not representable in r */
}
else /* The integer part of u fits in r, we'll round to it. */
sh = ush;
if (rnd_away < 0)
{
/* This is a rounding to nearest mode.
Decide the rounding direction here. */
if (uj == 0 && sh == 0)
rnd_away = 0; /* rounding bit = 0 (not represented in u) */
else if (rnd_mode == GMP_RNDN &&
(rp[0] & (MPFR_LIMB_ONE << sh)) == 0)
{ /* halfway cases rounded toward zero */
mp_limb_t a, b;
/* a: rounding bit and some of the following bits */
/* b: boundary for a (weight of the rounding bit in a) */
if (sh != 0)
{
a = rp[0] & ((MPFR_LIMB_ONE << sh) - 1);
b = MPFR_LIMB_ONE << (sh - 1);
}
else
{
MPFR_ASSERTD (uj >= 1); /* see above */
a = up[uj - 1];
b = MPFR_LIMB_HIGHBIT;
}
rnd_away = a > b;
if (a == b)
{
mp_size_t i;
for (i = uj - 1 - (sh == 0); i >= 0; i--)
if (up[i] != 0)
{
rnd_away = 1;
break;
}
}
}
else /* halfway cases rounded away from zero */
rnd_away = /* rounding bit */
((sh != 0 && (rp[0] & (MPFR_LIMB_ONE << (sh - 1))) != 0) ||
(sh == 0 && (MPFR_ASSERTD (uj >= 1),
up[uj - 1] & MPFR_LIMB_HIGHBIT) != 0));
}
/* Now we can make the low rj limbs to 0 */
MPN_ZERO (rp-rj, rj);
}
if (sh != 0)
rp[0] &= MP_LIMB_T_MAX << sh;
/* If u is a representable integer, there is no rounding. */
if (uflags == 0)
MPFR_RET(0);
MPFR_ASSERTD (rnd_away >= 0); /* rounding direction is defined */
if (rnd_away && mpn_add_1(rp, rp, rn, MPFR_LIMB_ONE << sh))
{
if (exp == __gmpfr_emax)
return mpfr_overflow(r, rnd_mode, MPFR_SIGN(r)) >= 0 ?
uflags : -uflags;
else
{
MPFR_SET_EXP(r, exp + 1);
rp[rn-1] = MPFR_LIMB_HIGHBIT;
}
}
MPFR_RET (rnd_away ^ (sign < 0) ? uflags : -uflags);
} /* exp > 0, |u| >= 1 */
}
int
mpfr_sqrt (mpfr_ptr r, mpfr_srcptr u, mpfr_rnd_t rnd_mode)
{
mp_size_t rsize; /* number of limbs of r (plus 1 if exact limb multiple) */
mp_size_t rrsize;
mp_size_t usize; /* number of limbs of u */
mp_size_t tsize; /* number of limbs of the sqrtrem remainder */
mp_size_t k;
mp_size_t l;
mpfr_limb_ptr rp, rp0;
mpfr_limb_ptr up;
mpfr_limb_ptr sp;
mp_limb_t sticky0; /* truncated part of input */
mp_limb_t sticky1; /* truncated part of rp[0] */
mp_limb_t sticky;
int odd_exp;
int sh; /* number of extra bits in rp[0] */
int inexact; /* return ternary flag */
mpfr_exp_t expr;
MPFR_TMP_DECL(marker);
MPFR_LOG_FUNC
(("x[%Pu]=%.*Rg rnd=%d", mpfr_get_prec (u), mpfr_log_prec, u, rnd_mode),
("y[%Pu]=%.*Rg inexact=%d",
mpfr_get_prec (r), mpfr_log_prec, r, inexact));
if (MPFR_UNLIKELY(MPFR_IS_SINGULAR(u)))
{
if (MPFR_IS_NAN(u))
{
MPFR_SET_NAN(r);
MPFR_RET_NAN;
}
else if (MPFR_IS_ZERO(u))
{
/* 0+ or 0- */
MPFR_SET_SAME_SIGN(r, u);
MPFR_SET_ZERO(r);
MPFR_RET(0); /* zero is exact */
}
else
{
MPFR_ASSERTD(MPFR_IS_INF(u));
/* sqrt(-Inf) = NAN */
if (MPFR_IS_NEG(u))
{
MPFR_SET_NAN(r);
MPFR_RET_NAN;
}
MPFR_SET_POS(r);
MPFR_SET_INF(r);
MPFR_RET(0);
}
}
if (MPFR_UNLIKELY(MPFR_IS_NEG(u)))
{
MPFR_SET_NAN(r);
MPFR_RET_NAN;
}
MPFR_SET_POS(r);
MPFR_TMP_MARK (marker);
MPFR_UNSIGNED_MINUS_MODULO(sh,MPFR_PREC(r));
if (sh == 0 && rnd_mode == MPFR_RNDN)
sh = GMP_NUMB_BITS; /* ugly case */
rsize = MPFR_LIMB_SIZE(r) + (sh == GMP_NUMB_BITS);
/* rsize is the number of limbs of r + 1 if exact limb multiple and rounding
to nearest, this is the number of wanted limbs for the square root */
rrsize = rsize + rsize;
usize = MPFR_LIMB_SIZE(u); /* number of limbs of u */
rp0 = MPFR_MANT(r);
rp = (sh < GMP_NUMB_BITS) ? rp0 : MPFR_TMP_LIMBS_ALLOC (rsize);
up = MPFR_MANT(u);
sticky0 = MPFR_LIMB_ZERO; /* truncated part of input */
sticky1 = MPFR_LIMB_ZERO; /* truncated part of rp[0] */
odd_exp = (unsigned int) MPFR_GET_EXP (u) & 1;
inexact = -1; /* return ternary flag */
sp = MPFR_TMP_LIMBS_ALLOC (rrsize);
/* copy the most significant limbs of u to {sp, rrsize} */
if (MPFR_LIKELY(usize <= rrsize)) /* in case r and u have the same precision,
we have indeed rrsize = 2 * usize */
{
k = rrsize - usize;
if (MPFR_LIKELY(k))
MPN_ZERO (sp, k);
if (odd_exp)
{
if (MPFR_LIKELY(k))
sp[k - 1] = mpn_rshift (sp + k, up, usize, 1);
else
sticky0 = mpn_rshift (sp, up, usize, 1);
}
else
MPN_COPY (sp + rrsize - usize, up, usize);
}
else /* usize > rrsize: truncate the input */
{
k = usize - rrsize;
if (odd_exp)
sticky0 = mpn_rshift (sp, up + k, rrsize, 1);
else
MPN_COPY (sp, up + k, rrsize);
l = k;
while (sticky0 == MPFR_LIMB_ZERO && l != 0)
sticky0 = up[--l];
}
/* sticky0 is non-zero iff the truncated part of the input is non-zero */
/* mpn_rootrem with NULL 2nd argument is faster than mpn_sqrtrem, thus use
it if available and if the user asked to use GMP internal functions */
#if defined(WANT_GMP_INTERNALS) && defined(HAVE___GMPN_ROOTREM)
tsize = __gmpn_rootrem (rp, NULL, sp, rrsize, 2);
#else
tsize = mpn_sqrtrem (rp, NULL, sp, rrsize);
#endif
/* a return value of zero in mpn_sqrtrem indicates a perfect square */
sticky = sticky0 || tsize != 0;
/* truncate low bits of rp[0] */
sticky1 = rp[0] & ((sh < GMP_NUMB_BITS) ? MPFR_LIMB_MASK(sh)
: ~MPFR_LIMB_ZERO);
rp[0] -= sticky1;
sticky = sticky || sticky1;
expr = (MPFR_GET_EXP(u) + odd_exp) / 2; /* exact */
if (rnd_mode == MPFR_RNDZ || rnd_mode == MPFR_RNDD || sticky == MPFR_LIMB_ZERO)
{
inexact = (sticky == MPFR_LIMB_ZERO) ? 0 : -1;
goto truncate;
}
else if (rnd_mode == MPFR_RNDN)
{
/* if sh < GMP_NUMB_BITS, the round bit is bit (sh-1) of sticky1
and the sticky bit is formed by the low sh-1 bits from
sticky1, together with the sqrtrem remainder and sticky0. */
if (sh < GMP_NUMB_BITS)
{
if (sticky1 & (MPFR_LIMB_ONE << (sh - 1)))
{ /* round bit is set */
if (sticky1 == (MPFR_LIMB_ONE << (sh - 1)) && tsize == 0
&& sticky0 == 0)
goto even_rule;
else
goto add_one_ulp;
}
else /* round bit is zero */
goto truncate; /* with the default inexact=-1 */
}
else /* sh = GMP_NUMB_BITS: the round bit is the most significant bit
of rp[0], and the remaining GMP_NUMB_BITS-1 bits contribute to
the sticky bit */
{
if (sticky1 & MPFR_LIMB_HIGHBIT)
{ /* round bit is set */
if (sticky1 == MPFR_LIMB_HIGHBIT && tsize == 0 && sticky0 == 0)
goto even_rule;
else
goto add_one_ulp;
}
else /* round bit is zero */
goto truncate; /* with the default inexact=-1 */
}
}
else /* rnd_mode=GMP_RDNU, necessarily sticky <> 0, thus add 1 ulp */
goto add_one_ulp;
even_rule: /* has to set inexact */
if (sh < GMP_NUMB_BITS)
inexact = (rp[0] & (MPFR_LIMB_ONE << sh)) ? 1 : -1;
else
inexact = (rp[1] & MPFR_LIMB_ONE) ? 1 : -1;
if (inexact == -1)
goto truncate;
/* else go through add_one_ulp */
add_one_ulp:
inexact = 1; /* always here */
if (sh == GMP_NUMB_BITS)
{
rp ++;
rsize --;
sh = 0;
}
if (mpn_add_1 (rp0, rp, rsize, MPFR_LIMB_ONE << sh))
{
expr ++;
rp[rsize - 1] = MPFR_LIMB_HIGHBIT;
}
goto end;
truncate: /* inexact = 0 or -1 */
if (sh == GMP_NUMB_BITS)
MPN_COPY (rp0, rp + 1, rsize - 1);
end:
MPFR_ASSERTN (expr >= MPFR_EMIN_MIN && expr <= MPFR_EMAX_MAX);
MPFR_EXP (r) = expr;
MPFR_TMP_FREE(marker);
return mpfr_check_range (r, inexact, rnd_mode);
}
/* compute sign(b) * (|b| + |c|)
Returns 0 iff result is exact,
a negative value when the result is less than the exact value,
a positive value otherwise. */
int
mpfr_add1sp (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mpfr_rnd_t rnd_mode)
{
mpfr_uexp_t d;
mpfr_prec_t p;
unsigned int sh;
mp_size_t n;
mp_limb_t *ap, *cp;
mpfr_exp_t bx;
mp_limb_t limb;
int inexact;
MPFR_TMP_DECL(marker);
MPFR_TMP_MARK(marker);
MPFR_ASSERTD(MPFR_PREC(a) == MPFR_PREC(b) && MPFR_PREC(b) == MPFR_PREC(c));
MPFR_ASSERTD(MPFR_IS_PURE_FP(b));
MPFR_ASSERTD(MPFR_IS_PURE_FP(c));
MPFR_ASSERTD(MPFR_GET_EXP(b) >= MPFR_GET_EXP(c));
/* Read prec and num of limbs */
p = MPFR_PREC(b);
n = MPFR_PREC2LIMBS (p);
MPFR_UNSIGNED_MINUS_MODULO(sh, p);
bx = MPFR_GET_EXP(b);
d = (mpfr_uexp_t) (bx - MPFR_GET_EXP(c));
DEBUG (printf ("New add1sp with diff=%lu\n", (unsigned long) d));
if (MPFR_UNLIKELY(d == 0))
{
/* d==0 */
DEBUG( mpfr_print_mant_binary("C= ", MPFR_MANT(c), p) );
DEBUG( mpfr_print_mant_binary("B= ", MPFR_MANT(b), p) );
bx++; /* exp + 1 */
ap = MPFR_MANT(a);
limb = mpn_add_n(ap, MPFR_MANT(b), MPFR_MANT(c), n);
DEBUG( mpfr_print_mant_binary("A= ", ap, p) );
MPFR_ASSERTD(limb != 0); /* There must be a carry */
limb = ap[0]; /* Get LSB (In fact, LSW) */
mpn_rshift(ap, ap, n, 1); /* Shift mantissa A */
ap[n-1] |= MPFR_LIMB_HIGHBIT; /* Set MSB */
ap[0] &= ~MPFR_LIMB_MASK(sh); /* Clear LSB bit */
if (MPFR_LIKELY((limb&(MPFR_LIMB_ONE<<sh)) == 0)) /* Check exact case */
{ inexact = 0; goto set_exponent; }
/* Zero: Truncate
Nearest: Even Rule => truncate or add 1
Away: Add 1 */
if (MPFR_LIKELY(rnd_mode==MPFR_RNDN))
{
if (MPFR_LIKELY((ap[0]&(MPFR_LIMB_ONE<<sh))==0))
{ inexact = -1; goto set_exponent; }
else
goto add_one_ulp;
}
MPFR_UPDATE_RND_MODE(rnd_mode, MPFR_IS_NEG(b));
if (rnd_mode==MPFR_RNDZ)
{ inexact = -1; goto set_exponent; }
else
goto add_one_ulp;
}
else if (MPFR_UNLIKELY (d >= p))
{
if (MPFR_LIKELY (d > p))
{
/* d > p : Copy B in A */
/* Away: Add 1
Nearest: Trunc
Zero: Trunc */
if (MPFR_LIKELY (rnd_mode==MPFR_RNDN
|| MPFR_IS_LIKE_RNDZ (rnd_mode, MPFR_IS_NEG (b))))
{
copy_set_exponent:
ap = MPFR_MANT (a);
MPN_COPY (ap, MPFR_MANT(b), n);
inexact = -1;
goto set_exponent;
}
else
{
copy_add_one_ulp:
ap = MPFR_MANT(a);
MPN_COPY (ap, MPFR_MANT(b), n);
goto add_one_ulp;
}
}
else
{
/* d==p : Copy B in A */
/* Away: Add 1
Nearest: Even Rule if C is a power of 2, else Add 1
Zero: Trunc */
if (MPFR_LIKELY(rnd_mode==MPFR_RNDN))
{
/* Check if C was a power of 2 */
cp = MPFR_MANT(c);
if (MPFR_UNLIKELY(cp[n-1] == MPFR_LIMB_HIGHBIT))
{
mp_size_t k = n-1;
do {
k--;
} while (k>=0 && cp[k]==0);
if (MPFR_UNLIKELY(k<0))
/* Power of 2: Even rule */
if ((MPFR_MANT (b)[0]&(MPFR_LIMB_ONE<<sh))==0)
goto copy_set_exponent;
}
/* Not a Power of 2 */
goto copy_add_one_ulp;
}
else if (MPFR_IS_LIKE_RNDZ (rnd_mode, MPFR_IS_NEG (b)))
goto copy_set_exponent;
else
goto copy_add_one_ulp;
}
}
else
{
mp_limb_t mask;
mp_limb_t bcp, bcp1; /* Cp and C'p+1 */
/* General case: 1 <= d < p */
cp = MPFR_TMP_LIMBS_ALLOC (n);
/* Shift c in temporary allocated place */
{
mpfr_uexp_t dm;
mp_size_t m;
dm = d % GMP_NUMB_BITS;
m = d / GMP_NUMB_BITS;
if (MPFR_UNLIKELY(dm == 0))
{
/* dm = 0 and m > 0: Just copy */
MPFR_ASSERTD(m!=0);
MPN_COPY(cp, MPFR_MANT(c)+m, n-m);
MPN_ZERO(cp+n-m, m);
}
else if (MPFR_LIKELY(m == 0))
{
/* dm >=1 and m == 0: just shift */
MPFR_ASSERTD(dm >= 1);
mpn_rshift(cp, MPFR_MANT(c), n, dm);
}
else
{
/* dm > 0 and m > 0: shift and zero */
mpn_rshift(cp, MPFR_MANT(c)+m, n-m, dm);
MPN_ZERO(cp+n-m, m);
}
}
DEBUG( mpfr_print_mant_binary("Before", MPFR_MANT(c), p) );
DEBUG( mpfr_print_mant_binary("B= ", MPFR_MANT(b), p) );
DEBUG( mpfr_print_mant_binary("After ", cp, p) );
/* Compute bcp=Cp and bcp1=C'p+1 */
if (MPFR_LIKELY (sh > 0))
{
/* Try to compute them from C' rather than C */
bcp = (cp[0] & (MPFR_LIMB_ONE<<(sh-1))) ;
if (MPFR_LIKELY(cp[0]&MPFR_LIMB_MASK(sh-1)))
bcp1 = 1;
else
{
/* We can't compute C'p+1 from C'. Compute it from C */
/* Start from bit x=p-d+sh in mantissa C
(+sh since we have already looked sh bits in C'!) */
mpfr_prec_t x = p-d+sh-1;
if (MPFR_LIKELY(x>p))
/* We are already looked at all the bits of c, so C'p+1 = 0*/
bcp1 = 0;
else
{
mp_limb_t *tp = MPFR_MANT(c);
mp_size_t kx = n-1 - (x / GMP_NUMB_BITS);
mpfr_prec_t sx = GMP_NUMB_BITS-1-(x%GMP_NUMB_BITS);
DEBUG (printf ("(First) x=%lu Kx=%ld Sx=%lu\n",
(unsigned long) x, (long) kx,
(unsigned long) sx));
/* Looks at the last bits of limb kx (if sx=0 does nothing)*/
if (tp[kx] & MPFR_LIMB_MASK(sx))
bcp1 = 1;
else
{
/*kx += (sx==0);*/
/*If sx==0, tp[kx] hasn't been checked*/
do {
kx--;
} while (kx>=0 && tp[kx]==0);
bcp1 = (kx >= 0);
}
}
}
}
else /* sh == 0 */
{
/* Compute Cp and C'p+1 from C with sh=0 */
mp_limb_t *tp = MPFR_MANT(c);
/* Start from bit x=p-d in mantissa C */
mpfr_prec_t x = p-d;
mp_size_t kx = n-1 - (x / GMP_NUMB_BITS);
mpfr_prec_t sx = GMP_NUMB_BITS-1-(x%GMP_NUMB_BITS);
MPFR_ASSERTD(p >= d);
bcp = tp[kx] & (MPFR_LIMB_ONE<<sx);
/* Looks at the last bits of limb kx (If sx=0, does nothing)*/
if (tp[kx]&MPFR_LIMB_MASK(sx))
bcp1 = 1;
else
{
do {
kx--;
} while (kx>=0 && tp[kx]==0);
bcp1 = (kx>=0);
}
}
DEBUG (printf("sh=%u Cp=%lu C'p+1=%lu\n", sh,
(unsigned long) bcp, (unsigned long) bcp1));
/* Clean shifted C' */
mask = ~MPFR_LIMB_MASK(sh);
cp[0] &= mask;
/* Add the mantissa c from b in a */
ap = MPFR_MANT(a);
limb = mpn_add_n (ap, MPFR_MANT(b), cp, n);
DEBUG( mpfr_print_mant_binary("Add= ", ap, p) );
/* Check for overflow */
if (MPFR_UNLIKELY (limb))
{
limb = ap[0] & (MPFR_LIMB_ONE<<sh); /* Get LSB */
mpn_rshift (ap, ap, n, 1); /* Shift mantissa*/
bx++; /* Fix exponent */
ap[n-1] |= MPFR_LIMB_HIGHBIT; /* Set MSB */
ap[0] &= mask; /* Clear LSB bit */
bcp1 |= bcp; /* Recompute C'p+1 */
bcp = limb; /* Recompute Cp */
DEBUG (printf ("(Overflow) Cp=%lu C'p+1=%lu\n",
(unsigned long) bcp, (unsigned long) bcp1));
DEBUG (mpfr_print_mant_binary ("Add= ", ap, p));
}
/* Round:
Zero: Truncate but could be exact.
Away: Add 1 if Cp or C'p+1 !=0
Nearest: Truncate but could be exact if Cp==0
Add 1 if C'p+1 !=0,
Even rule else */
if (MPFR_LIKELY(rnd_mode == MPFR_RNDN))
{
if (MPFR_LIKELY(bcp == 0))
{ inexact = MPFR_LIKELY(bcp1) ? -1 : 0; goto set_exponent; }
else if (MPFR_UNLIKELY(bcp1==0) && (ap[0]&(MPFR_LIMB_ONE<<sh))==0)
{ inexact = -1; goto set_exponent; }
else
goto add_one_ulp;
}
MPFR_UPDATE_RND_MODE(rnd_mode, MPFR_IS_NEG(b));
if (rnd_mode == MPFR_RNDZ)
{
inexact = MPFR_LIKELY(bcp || bcp1) ? -1 : 0;
goto set_exponent;
}
else
{
if (MPFR_UNLIKELY(bcp==0 && bcp1==0))
{ inexact = 0; goto set_exponent; }
else
goto add_one_ulp;
}
}
MPFR_ASSERTN(0);
add_one_ulp:
/* add one unit in last place to a */
DEBUG( printf("AddOneUlp\n") );
if (MPFR_UNLIKELY( mpn_add_1(ap, ap, n, MPFR_LIMB_ONE<<sh) ))
{
/* Case 100000x0 = 0x1111x1 + 1*/
DEBUG( printf("Pow of 2\n") );
bx++;
ap[n-1] = MPFR_LIMB_HIGHBIT;
}
inexact = 1;
set_exponent:
if (MPFR_UNLIKELY(bx > __gmpfr_emax)) /* Check for overflow */
{
DEBUG( printf("Overflow\n") );
MPFR_TMP_FREE(marker);
MPFR_SET_SAME_SIGN(a,b);
return mpfr_overflow(a, rnd_mode, MPFR_SIGN(a));
}
MPFR_SET_EXP (a, bx);
MPFR_SET_SAME_SIGN(a,b);
MPFR_TMP_FREE(marker);
MPFR_RET (inexact * MPFR_INT_SIGN (a));
}