int
_mpq_cmp_ui (mpq_srcptr op1, unsigned long int num2, unsigned long int den2)
{
mp_size_t num1_size = SIZ(NUM(op1));
mp_size_t den1_size = SIZ(DEN(op1));
mp_size_t tmp1_size, tmp2_size;
mp_ptr tmp1_ptr, tmp2_ptr;
mp_limb_t cy_limb;
int cc;
TMP_DECL;
#if GMP_NAIL_BITS != 0
if ((num2 | den2) > GMP_NUMB_MAX)
{
mpq_t op2;
mpq_init (op2);
mpz_set_ui (mpq_numref (op2), num2);
mpz_set_ui (mpq_denref (op2), den2);
cc = mpq_cmp (op1, op2);
mpq_clear (op2);
return cc;
}
#endif
/* need canonical sign to get right result */
ASSERT (den1_size > 0);
if (UNLIKELY (den2 == 0))
DIVIDE_BY_ZERO;
if (num2 == 0)
return num1_size;
if (num1_size <= 0)
return -1;
/* NUM1 x DEN2 is either TMP1_SIZE limbs or TMP1_SIZE-1 limbs.
Same for NUM1 x DEN1 with respect to TMP2_SIZE. */
if (num1_size > den1_size + 1)
/* NUM1 x DEN2 is surely larger in magnitude than NUM2 x DEN1. */
return num1_size;
if (den1_size > num1_size + 1)
/* NUM1 x DEN2 is surely smaller in magnitude than NUM2 x DEN1. */
return -num1_size;
TMP_MARK;
TMP_ALLOC_LIMBS_2 (tmp1_ptr, num1_size + 1, tmp2_ptr, den1_size + 1);
cy_limb = mpn_mul_1 (tmp1_ptr, PTR(NUM(op1)), num1_size,
(mp_limb_t) den2);
tmp1_ptr[num1_size] = cy_limb;
tmp1_size = num1_size + (cy_limb != 0);
cy_limb = mpn_mul_1 (tmp2_ptr, PTR(DEN(op1)), den1_size,
(mp_limb_t) num2);
tmp2_ptr[den1_size] = cy_limb;
tmp2_size = den1_size + (cy_limb != 0);
cc = tmp1_size - tmp2_size != 0
? tmp1_size - tmp2_size : mpn_cmp (tmp1_ptr, tmp2_ptr, tmp1_size);
TMP_FREE;
return cc;
}
int
mpq_cmp (const MP_RAT *op1, const MP_RAT *op2)
{
mp_size_t num1_size = SIZ(NUM(op1));
mp_size_t den1_size = SIZ(DEN(op1));
mp_size_t num2_size = SIZ(NUM(op2));
mp_size_t den2_size = SIZ(DEN(op2));
mp_size_t tmp1_size, tmp2_size;
mp_ptr tmp1_ptr, tmp2_ptr;
mp_size_t num1_sign;
int cc;
TMP_DECL;
/* need canonical signs to get right result */
ASSERT (den1_size > 0);
ASSERT (den2_size > 0);
if (num1_size == 0)
return -num2_size;
if (num2_size == 0)
return num1_size;
if ((num1_size ^ num2_size) < 0) /* I.e. are the signs different? */
return num1_size;
num1_sign = num1_size;
num1_size = ABS (num1_size);
num2_size = ABS (num2_size);
tmp1_size = num1_size + den2_size;
tmp2_size = num2_size + den1_size;
/* 1. Check to see if we can tell which operand is larger by just looking at
the number of limbs. */
/* NUM1 x DEN2 is either TMP1_SIZE limbs or TMP1_SIZE-1 limbs.
Same for NUM1 x DEN1 with respect to TMP2_SIZE. */
if (tmp1_size > tmp2_size + 1)
/* NUM1 x DEN2 is surely larger in magnitude than NUM2 x DEN1. */
return num1_sign;
if (tmp2_size > tmp1_size + 1)
/* NUM1 x DEN2 is surely smaller in magnitude than NUM2 x DEN1. */
return -num1_sign;
/* 2. Same, but compare the number of significant bits. */
{
int cnt1, cnt2;
mp_bitcnt_t bits1, bits2;
count_leading_zeros (cnt1, PTR(NUM(op1))[num1_size - 1]);
count_leading_zeros (cnt2, PTR(DEN(op2))[den2_size - 1]);
bits1 = tmp1_size * GMP_NUMB_BITS - cnt1 - cnt2 + 2 * GMP_NAIL_BITS;
count_leading_zeros (cnt1, PTR(NUM(op2))[num2_size - 1]);
count_leading_zeros (cnt2, PTR(DEN(op1))[den1_size - 1]);
bits2 = tmp2_size * GMP_NUMB_BITS - cnt1 - cnt2 + 2 * GMP_NAIL_BITS;
if (bits1 > bits2 + 1)
return num1_sign;
if (bits2 > bits1 + 1)
return -num1_sign;
}
/* 3. Finally, cross multiply and compare. */
TMP_MARK;
TMP_ALLOC_LIMBS_2 (tmp1_ptr,tmp1_size, tmp2_ptr,tmp2_size);
if (num1_size >= den2_size)
tmp1_size -= 0 == mpn_mul (tmp1_ptr,
PTR(NUM(op1)), num1_size,
PTR(DEN(op2)), den2_size);
else
tmp1_size -= 0 == mpn_mul (tmp1_ptr,
PTR(DEN(op2)), den2_size,
PTR(NUM(op1)), num1_size);
if (num2_size >= den1_size)
tmp2_size -= 0 == mpn_mul (tmp2_ptr,
PTR(NUM(op2)), num2_size,
PTR(DEN(op1)), den1_size);
else
tmp2_size -= 0 == mpn_mul (tmp2_ptr,
PTR(DEN(op1)), den1_size,
PTR(NUM(op2)), num2_size);
cc = tmp1_size - tmp2_size != 0
? tmp1_size - tmp2_size : mpn_cmp (tmp1_ptr, tmp2_ptr, tmp1_size);
TMP_FREE;
return num1_sign < 0 ? -cc : cc;
}
void
mpz_gcdext (mpz_ptr g, mpz_ptr s, mpz_ptr t, mpz_srcptr a, mpz_srcptr b)
{
mp_size_t asize, bsize;
mp_ptr tmp_ap, tmp_bp;
mp_size_t gsize, ssize, tmp_ssize;
mp_ptr gp, tmp_gp, tmp_sp;
TMP_DECL;
/* mpn_gcdext requires that Usize >= Vsize. Therefore, we often
have to swap U and V. The computed cofactor will be the
"smallest" one, which is faster to produce. The wanted one will
be computed here; this is needed anyway when both are requested. */
asize = ABSIZ (a);
bsize = ABSIZ (b);
if (asize < bsize)
{
MPZ_SRCPTR_SWAP (a, b);
MP_SIZE_T_SWAP (asize, bsize);
MPZ_PTR_SWAP (s, t);
}
if (bsize == 0)
{
/* g = |a|, s = sgn(a), t = 0. */
ssize = SIZ (a) >= 0 ? (asize != 0) : -1;
gp = MPZ_REALLOC (g, asize);
MPN_COPY (gp, PTR (a), asize);
SIZ (g) = asize;
if (t != NULL)
SIZ (t) = 0;
if (s != NULL)
{
SIZ (s) = ssize;
PTR (s)[0] = 1;
}
return;
}
TMP_MARK;
TMP_ALLOC_LIMBS_2 (tmp_ap, asize, tmp_bp, bsize);
MPN_COPY (tmp_ap, PTR (a), asize);
MPN_COPY (tmp_bp, PTR (b), bsize);
TMP_ALLOC_LIMBS_2 (tmp_gp, bsize, tmp_sp, bsize + 1);
gsize = mpn_gcdext (tmp_gp, tmp_sp, &tmp_ssize, tmp_ap, asize, tmp_bp, bsize);
ssize = ABS (tmp_ssize);
tmp_ssize = SIZ (a) >= 0 ? tmp_ssize : -tmp_ssize;
if (t != NULL)
{
mpz_t x;
__mpz_struct gtmp, stmp;
PTR (>mp) = tmp_gp;
SIZ (>mp) = gsize;
PTR (&stmp) = tmp_sp;
SIZ (&stmp) = tmp_ssize;
MPZ_TMP_INIT (x, ssize + asize + 1);
mpz_mul (x, &stmp, a);
mpz_sub (x, >mp, x);
mpz_divexact (t, x, b);
}
if (s != NULL)
{
mp_ptr sp;
sp = MPZ_REALLOC (s, ssize);
MPN_COPY (sp, tmp_sp, ssize);
SIZ (s) = tmp_ssize;
}
gp = MPZ_REALLOC (g, gsize);
MPN_COPY (gp, tmp_gp, gsize);
SIZ (g) = gsize;
TMP_FREE;
}
void
mpz_xor (mpz_ptr res, mpz_srcptr op1, mpz_srcptr op2)
{
mp_srcptr op1_ptr, op2_ptr;
mp_size_t op1_size, op2_size;
mp_ptr res_ptr;
mp_size_t res_size, res_alloc;
TMP_DECL;
TMP_MARK;
op1_size = SIZ(op1);
op2_size = SIZ(op2);
op1_ptr = PTR(op1);
op2_ptr = PTR(op2);
res_ptr = PTR(res);
if (op1_size >= 0)
{
if (op2_size >= 0)
{
if (op1_size >= op2_size)
{
if (ALLOC(res) < op1_size)
{
_mpz_realloc (res, op1_size);
/* No overlapping possible: op1_ptr = PTR(op1); */
op2_ptr = PTR(op2);
res_ptr = PTR(res);
}
if (res_ptr != op1_ptr)
MPN_COPY (res_ptr + op2_size, op1_ptr + op2_size,
op1_size - op2_size);
if (LIKELY (op2_size != 0))
mpn_xor_n (res_ptr, op1_ptr, op2_ptr, op2_size);
res_size = op1_size;
}
else
{
if (ALLOC(res) < op2_size)
{
_mpz_realloc (res, op2_size);
op1_ptr = PTR(op1);
/* No overlapping possible: op2_ptr = PTR(op2); */
res_ptr = PTR(res);
}
if (res_ptr != op2_ptr)
MPN_COPY (res_ptr + op1_size, op2_ptr + op1_size,
op2_size - op1_size);
if (LIKELY (op1_size != 0))
mpn_xor_n (res_ptr, op1_ptr, op2_ptr, op1_size);
res_size = op2_size;
}
MPN_NORMALIZE (res_ptr, res_size);
SIZ(res) = res_size;
return;
}
else /* op2_size < 0 */
{
/* Fall through to the code at the end of the function. */
}
}
else
{
if (op2_size < 0)
{
mp_ptr opx, opy;
/* Both operands are negative, the result will be positive.
(-OP1) ^ (-OP2) =
= ~(OP1 - 1) ^ ~(OP2 - 1) =
= (OP1 - 1) ^ (OP2 - 1) */
op1_size = -op1_size;
op2_size = -op2_size;
/* Possible optimization: Decrease mpn_sub precision,
as we won't use the entire res of both. */
TMP_ALLOC_LIMBS_2 (opx, op1_size, opy, op2_size);
mpn_sub_1 (opx, op1_ptr, op1_size, (mp_limb_t) 1);
op1_ptr = opx;
mpn_sub_1 (opy, op2_ptr, op2_size, (mp_limb_t) 1);
op2_ptr = opy;
if (op1_size > op2_size)
MPN_SRCPTR_SWAP (op1_ptr,op1_size, op2_ptr,op2_size);
res_alloc = op2_size;
res_ptr = MPZ_REALLOC (res, res_alloc);
MPN_COPY (res_ptr + op1_size, op2_ptr + op1_size,
op2_size - op1_size);
mpn_xor_n (res_ptr, op1_ptr, op2_ptr, op1_size);
res_size = op2_size;
MPN_NORMALIZE (res_ptr, res_size);
SIZ(res) = res_size;
TMP_FREE;
return;
}
else
{
/* We should compute -OP1 ^ OP2. Swap OP1 and OP2 and fall
through to the code that handles OP1 ^ -OP2. */
MPZ_SRCPTR_SWAP (op1, op2);
MPN_SRCPTR_SWAP (op1_ptr,op1_size, op2_ptr,op2_size);
}
}
{
mp_ptr opx;
mp_limb_t cy;
/* Operand 2 negative, so will be the result.
-(OP1 ^ (-OP2)) = -(OP1 ^ ~(OP2 - 1)) =
= ~(OP1 ^ ~(OP2 - 1)) + 1 =
= (OP1 ^ (OP2 - 1)) + 1 */
op2_size = -op2_size;
opx = TMP_ALLOC_LIMBS (op2_size);
mpn_sub_1 (opx, op2_ptr, op2_size, (mp_limb_t) 1);
op2_ptr = opx;
res_alloc = MAX (op1_size, op2_size) + 1;
if (ALLOC(res) < res_alloc)
{
_mpz_realloc (res, res_alloc);
op1_ptr = PTR(op1);
/* op2_ptr points to temporary space. */
res_ptr = PTR(res);
}
if (op1_size > op2_size)
{
MPN_COPY (res_ptr + op2_size, op1_ptr + op2_size, op1_size - op2_size);
mpn_xor_n (res_ptr, op1_ptr, op2_ptr, op2_size);
res_size = op1_size;
}
else
{
MPN_COPY (res_ptr + op1_size, op2_ptr + op1_size, op2_size - op1_size);
if (LIKELY (op1_size != 0))
mpn_xor_n (res_ptr, op1_ptr, op2_ptr, op1_size);
res_size = op2_size;
}
cy = mpn_add_1 (res_ptr, res_ptr, res_size, (mp_limb_t) 1);
res_ptr[res_size] = cy;
res_size += (cy != 0);
MPN_NORMALIZE (res_ptr, res_size);
SIZ(res) = -res_size;
TMP_FREE;
}
}