/*-----------------------------------------------------------------------------*/
void node_red(tree_t tree)
{
if(mpz_tstbit(tree->M, 0))
{
mpz_set(tree->M_red, tree->M);
tree->shift = 0;
}
else
{
tree->shift = mpz_scan1(tree->M,0);
mpz_cdiv_q_2exp(tree->M_red, tree->M, tree->shift);
}
}
static cl_fixnum
remove_zeros(cl_object *integer)
{
cl_object buffer = into_bignum(_ecl_big_register0(), *integer);
unsigned long den_twos = mpz_scan1(buffer->big.big_num, 0);
if (den_twos < ULONG_MAX) {
mpz_div_2exp(buffer->big.big_num, buffer->big.big_num, den_twos);
*integer = _ecl_big_register_normalize(buffer);
return -den_twos;
} else {
_ecl_big_register_free(buffer);
return 0;
}
}
int
gmpmee_millerrabin_init(gmpmee_millerrabin_state state, mpz_t n)
{
mpz_init_set(state->n, n);
mpz_init(state->n_minus_1);
mpz_init(state->q);
mpz_init(state->y);
mpz_sub_ui(state->n_minus_1, n, 1L);
/* Define q and k such that n = q*2^k+1. */
state->k = mpz_scan1(state->n_minus_1, 0L);
mpz_tdiv_q_2exp(state->q, state->n_minus_1, state->k);
}
static void ct_label_type_print(const struct expr *expr)
{
unsigned long bit = mpz_scan1(expr->value, 0);
const struct symbolic_constant *s;
for (s = ct_label_tbl->symbols; s->identifier != NULL; s++) {
if (bit != s->value)
continue;
printf("%s", s->identifier);
return;
}
/* can happen when connlabel.conf is altered after rules were added */
gmp_printf("0x%Zx", expr->value);
}
/* RecoverSign : sign extend a MP_INT with the bit width-1 */
void RecoverSign (PtrMP_INT val, Bits width)
{
mpz_setbit (val, width);
if (mpz_scan1 (val, width - 1) == width - 1)
{
PtrMP_INT bitMask = MakeMaskForRange (width, 0);
mpz_com (bitMask, bitMask); /* 00001111 -> 11110000 */
mpz_ior (val, val, bitMask);
DeleteMP_INT (bitMask);
} else
mpz_clrbit (val, width);
}
// Test probable primality of n = 2p +/- 1 based on Euler, Lagrange and Lifchitz
// fSophieGermain:
// true: n = 2p+1, p prime, aka Cunningham Chain of first kind
// false: n = 2p-1, p prime, aka Cunningham Chain of second kind
// Return values
// true: n is probable prime
// false: n is composite; set fractional length in the nLength output
static bool EulerLagrangeLifchitzPrimalityTestFast(const mpz_class& n, bool fSophieGermain, unsigned int& nLength, CPrimalityTestParams& testParams, bool fFastFail = false)
{
mpz_class& mpzNMinusOne = testParams.mpzNMinusOne;
mpz_class& mpzE = testParams.mpzE;
mpz_class& mpzBase = testParams.mpzBase;
mpz_class& mpzR = testParams.mpzR;
mpz_class& mpzR2 = testParams.mpzR2;
mpz_class& mpzFrac = testParams.mpzFrac;
mpzNMinusOne = n - 1;
unsigned int nTrailingZeros = mpz_scan1(mpzNMinusOne.get_mpz_t(), 0);
if ((nTrailingZeros > 9))
nTrailingZeros = 9;
mpz_tdiv_q_2exp(mpzE.get_mpz_t(), mpzNMinusOne.get_mpz_t(), nTrailingZeros);
unsigned int nShiftCount = (1U << (nTrailingZeros - 1)) - 1;
mpzBase = mpzTwo << nShiftCount;
mpz_powm(mpzR.get_mpz_t(), mpzBase.get_mpz_t(), mpzE.get_mpz_t(), n.get_mpz_t());
unsigned int nMod8 = n.get_ui() % 8;
bool fPassedTest = false;
if (fSophieGermain && nMod8 == 7) // Euler & Lagrange
fPassedTest = (mpzR == 1);
else if (fSophieGermain && nMod8 == 3) // Lifchitz
fPassedTest = (mpzR == mpzNMinusOne);
else if (!fSophieGermain && nMod8 == 5) // Lifchitz
fPassedTest = (mpzR == mpzNMinusOne);
else if (!fSophieGermain && nMod8 == 1) // LifChitz
fPassedTest = (mpzR == 1);
else
return false;
if ((fPassedTest))
return true;
if ((fFastFail))
return false;
// Failed test, calculate fractional length
mpzR2 = mpzR * mpzR;
mpzR = mpzR2 % n; // derive Fermat test remainder
mpzFrac = n - mpzR;
mpzFrac <<= nFractionalBits;
mpzFrac /= n;
unsigned int nFractionalLength = mpzFrac.get_ui();
if ((nFractionalLength >= (1 << nFractionalBits)))
return false;
nLength = (nLength & TARGET_LENGTH_MASK) | nFractionalLength;
return false;
}
static void
test_int (void)
{
unsigned long n0 = 1, n1 = 80, n;
mpz_t f;
mpfr_t x, y;
mp_prec_t prec_f, p;
int r;
int inex1, inex2;
mpz_init (f);
mpfr_init (x);
mpfr_init (y);
mpz_fac_ui (f, n0 - 1);
for (n = n0; n <= n1; n++)
{
mpz_mul_ui (f, f, n); /* f = n! */
prec_f = mpz_sizeinbase (f, 2) - mpz_scan1 (f, 0);
for (p = MPFR_PREC_MIN; p <= prec_f; p++)
{
mpfr_set_prec (x, p);
mpfr_set_prec (y, p);
for (r = 0; r < GMP_RND_MAX; r++)
{
inex1 = mpfr_fac_ui (x, n, (mp_rnd_t) r);
inex2 = mpfr_set_z (y, f, (mp_rnd_t) r);
if (mpfr_cmp (x, y))
{
printf ("Error for n=%lu prec=%lu rnd=%s\n",
n, (unsigned long) p, mpfr_print_rnd_mode ((mp_rnd_t) r));
exit (1);
}
if ((inex1 < 0 && inex2 >= 0) || (inex1 == 0 && inex2 != 0)
|| (inex1 > 0 && inex2 <= 0))
{
printf ("Wrong inexact flag for n=%lu prec=%lu rnd=%s\n",
n, (unsigned long) p, mpfr_print_rnd_mode ((mp_rnd_t) r));
exit (1);
}
}
}
}
mpz_clear (f);
mpfr_clear (x);
mpfr_clear (y);
}
static Variant HHVM_FUNCTION(gmp_scan1,
const Variant& data,
int64_t start) {
if (start < 0) {
raise_warning(cs_GMP_INVALID_STARTING_INDEX_IS_NEGATIVE,
cs_GMP_FUNC_NAME_GMP_SCAN1);
return false;
}
mpz_t gmpData;
if (!variantToGMPData(cs_GMP_FUNC_NAME_GMP_SCAN1, gmpData, data)) {
return false;
}
int64_t foundBit = mpz_scan1(gmpData, start);
mpz_clear(gmpData);
return foundBit;
}
//---------------------------------------------------------
// precomputation for sqrt
//---------------------------------------------------------
void bn254_fp2_precomp_sqrt(field_precomp_sqrt_p ps, const Field f)
{
//-----------------------------
// decompose of value
// (p^2-1) = 2^e * v
//-----------------------------
mpz_init_set(ps->v, f->order);
mpz_sub_ui(ps->v, ps->v, 1);
ps->e = (int)mpz_scan1(ps->v, 0);
mpz_fdiv_q_2exp(ps->v, ps->v, ps->e);
//----------------------------------
// n_v = n^v :
// n is some integer (n/p) = -1
//----------------------------------
element_init(ps->n_v, f);
do { element_random(ps->n_v); }
while (element_is_sqr(ps->n_v));
element_pow(ps->n_v, ps->n_v, ps->v);
}
static PyObject *
GMPy_MPZ_bit_scan1_method(PyObject *self, PyObject *args)
{
mp_bitcnt_t index, starting_bit = 0;
if (PyTuple_GET_SIZE(args) == 1) {
starting_bit = mp_bitcnt_t_From_Integer(PyTuple_GET_ITEM(args, 0));
if (starting_bit == (mp_bitcnt_t)(-1) && PyErr_Occurred()) {
return NULL;
}
}
index = mpz_scan1(MPZ(self), starting_bit);
if (index == (mp_bitcnt_t)(-1)) {
Py_RETURN_NONE;
}
else {
return PyIntOrLong_FromMpBitCnt(index);
}
}
static PyObject *
GMPy_MPZ_bit_scan1_function(PyObject *self, PyObject *args)
{
mp_bitcnt_t index, starting_bit = 0;
MPZ_Object *tempx = NULL;
if (PyTuple_GET_SIZE(args) == 0 || PyTuple_GET_SIZE(args) > 2) {
goto err;
}
if (!(tempx = GMPy_MPZ_From_Integer(PyTuple_GET_ITEM(args, 0), NULL))) {
goto err;
}
if (PyTuple_GET_SIZE(args) == 2) {
starting_bit = mp_bitcnt_t_From_Integer(PyTuple_GET_ITEM(args, 1));
if (starting_bit == (mp_bitcnt_t)(-1) && PyErr_Occurred()) {
goto err_index;
}
}
index = mpz_scan1(tempx->z, starting_bit);
Py_DECREF((PyObject*)tempx);
if (index == (mp_bitcnt_t)(-1)) {
Py_RETURN_NONE;
}
else {
return PyIntOrLong_FromMpBitCnt(index);
}
err:
TYPE_ERROR("bit_scan0() requires 'mpz',['int'] arguments");
err_index:
Py_DECREF((PyObject*)tempx);
return NULL;
}
void
hex_random_scan_op (enum hex_random_op op, unsigned long maxbits,
char **ap, unsigned long *b, unsigned long *r)
{
mpz_t a;
unsigned long abits, bbits;
unsigned signs;
mpz_init (a);
abits = gmp_urandomb_ui (state, 32) % maxbits;
bbits = gmp_urandomb_ui (state, 32) % (maxbits + 100);
mpz_rrandomb (a, state, abits);
signs = gmp_urandomb_ui (state, 1);
if (signs & 1)
mpz_neg (a, a);
switch (op)
{
default:
abort ();
case OP_SCAN0:
*r = mpz_scan0 (a, bbits);
break;
case OP_SCAN1:
*r = mpz_scan1 (a, bbits);
break;
}
gmp_asprintf (ap, "%Zx", a);
*b = bbits;
mpz_clear (a);
}
mp_bitcnt_t
mpz_remove (mpz_ptr dest, mpz_srcptr src, mpz_srcptr f)
{
mpz_t fpow[40]; /* inexhaustible...until year 2020 or so */
mpz_t x, rem;
mp_bitcnt_t pwr;
int p;
if (mpz_cmp_ui (f, 1) <= 0)
DIVIDE_BY_ZERO;
if (SIZ (src) == 0)
{
if (src != dest)
mpz_set (dest, src);
return 0;
}
if (mpz_cmp_ui (f, 2) == 0)
{
unsigned long int s0;
s0 = mpz_scan1 (src, 0);
mpz_fdiv_q_2exp (dest, src, s0);
return s0;
}
/* We could perhaps compute mpz_scan1(src,0)/mpz_scan1(f,0). It is an
upper bound of the result we're seeking. We could also shift down the
operands so that they become odd, to make intermediate values smaller. */
mpz_init (rem);
mpz_init (x);
pwr = 0;
mpz_init (fpow[0]);
mpz_set (fpow[0], f);
mpz_set (dest, src);
/* Divide by f, f^2, ..., f^(2^k) until we get a remainder for f^(2^k). */
for (p = 0;; p++)
{
mpz_tdiv_qr (x, rem, dest, fpow[p]);
if (SIZ (rem) != 0)
break;
mpz_init (fpow[p + 1]);
mpz_mul (fpow[p + 1], fpow[p], fpow[p]);
mpz_set (dest, x);
}
pwr = (1 << p) - 1;
mpz_clear (fpow[p]);
/* Divide by f^(2^(k-1)), f^(2^(k-2)), ..., f for all divisors that give a
zero remainder. */
while (--p >= 0)
{
mpz_tdiv_qr (x, rem, dest, fpow[p]);
if (SIZ (rem) == 0)
{
pwr += 1 << p;
mpz_set (dest, x);
}
mpz_clear (fpow[p]);
}
mpz_clear (x);
mpz_clear (rem);
return pwr;
}
int
mpfr_cbrt (mpfr_ptr y, mpfr_srcptr x, mpfr_rnd_t rnd_mode)
{
mpz_t m;
mpfr_exp_t e, r, sh;
mpfr_prec_t n, size_m, tmp;
int inexact, negative;
MPFR_SAVE_EXPO_DECL (expo);
MPFR_LOG_FUNC (
("x[%Pu]=%.*Rg rnd=%d", mpfr_get_prec (x), mpfr_log_prec, x, rnd_mode),
("y[%Pu]=%.*Rg inexact=%d", mpfr_get_prec (y), mpfr_log_prec, y,
inexact));
/* special values */
if (MPFR_UNLIKELY (MPFR_IS_SINGULAR (x)))
{
if (MPFR_IS_NAN (x))
{
MPFR_SET_NAN (y);
MPFR_RET_NAN;
}
else if (MPFR_IS_INF (x))
{
MPFR_SET_INF (y);
MPFR_SET_SAME_SIGN (y, x);
MPFR_RET (0);
}
/* case 0: cbrt(+/- 0) = +/- 0 */
else /* x is necessarily 0 */
{
MPFR_ASSERTD (MPFR_IS_ZERO (x));
MPFR_SET_ZERO (y);
MPFR_SET_SAME_SIGN (y, x);
MPFR_RET (0);
}
}
/* General case */
MPFR_SAVE_EXPO_MARK (expo);
mpz_init (m);
e = mpfr_get_z_2exp (m, x); /* x = m * 2^e */
if ((negative = MPFR_IS_NEG(x)))
mpz_neg (m, m);
r = e % 3;
if (r < 0)
r += 3;
/* x = (m*2^r) * 2^(e-r) = (m*2^r) * 2^(3*q) */
MPFR_MPZ_SIZEINBASE2 (size_m, m);
n = MPFR_PREC (y) + (rnd_mode == MPFR_RNDN);
/* we want 3*n-2 <= size_m + 3*sh + r <= 3*n
i.e. 3*sh + size_m + r <= 3*n */
sh = (3 * (mpfr_exp_t) n - (mpfr_exp_t) size_m - r) / 3;
sh = 3 * sh + r;
if (sh >= 0)
{
mpz_mul_2exp (m, m, sh);
e = e - sh;
}
else if (r > 0)
{
mpz_mul_2exp (m, m, r);
e = e - r;
}
/* invariant: x = m*2^e, with e divisible by 3 */
/* we reuse the variable m to store the cube root, since it is not needed
any more: we just need to know if the root is exact */
inexact = mpz_root (m, m, 3) == 0;
MPFR_MPZ_SIZEINBASE2 (tmp, m);
sh = tmp - n;
if (sh > 0) /* we have to flush to 0 the last sh bits from m */
{
inexact = inexact || ((mpfr_exp_t) mpz_scan1 (m, 0) < sh);
mpz_fdiv_q_2exp (m, m, sh);
e += 3 * sh;
}
if (inexact)
{
if (negative)
rnd_mode = MPFR_INVERT_RND (rnd_mode);
if (rnd_mode == MPFR_RNDU || rnd_mode == MPFR_RNDA
|| (rnd_mode == MPFR_RNDN && mpz_tstbit (m, 0)))
inexact = 1, mpz_add_ui (m, m, 1);
else
inexact = -1;
}
/* either inexact is not zero, and the conversion is exact, i.e. inexact
is not changed; or inexact=0, and inexact is set only when
rnd_mode=MPFR_RNDN and bit (n+1) from m is 1 */
inexact += mpfr_set_z (y, m, MPFR_RNDN);
MPFR_SET_EXP (y, MPFR_GET_EXP (y) + e / 3);
if (negative)
{
MPFR_CHANGE_SIGN (y);
inexact = -inexact;
}
mpz_clear (m);
MPFR_SAVE_EXPO_FREE (expo);
return mpfr_check_range (y, inexact, rnd_mode);
}
size_t GMPISNext(iset_t s, size_t last){
return (size_t) mpz_scan1(*s,last);
}
/* Auxiliary function: Compute the terms from n1 to n2 (excluded)
3/4*sum((-1)^n*n!^2/2^n/(2*n+1)!, n = n1..n2-1).
Numerator is T[0], denominator is Q[0],
Compute P[0] only when need_P is non-zero.
Need 1+ceil(log(n2-n1)/log(2)) cells in T[],P[],Q[].
*/
static void
S (mpz_t *T, mpz_t *P, mpz_t *Q, unsigned long n1, unsigned long n2, int need_P)
{
if (n2 == n1 + 1)
{
if (n1 == 0)
mpz_set_ui (P[0], 3);
else
{
mpz_set_ui (P[0], n1);
mpz_neg (P[0], P[0]);
}
if (n1 <= (ULONG_MAX / 4 - 1) / 2)
mpz_set_ui (Q[0], 4 * (2 * n1 + 1));
else /* to avoid overflow in 4 * (2 * n1 + 1) */
{
mpz_set_ui (Q[0], n1);
mpz_mul_2exp (Q[0], Q[0], 1);
mpz_add_ui (Q[0], Q[0], 1);
mpz_mul_2exp (Q[0], Q[0], 2);
}
mpz_set (T[0], P[0]);
}
else
{
unsigned long m = (n1 / 2) + (n2 / 2) + (n1 & 1UL & n2);
unsigned long v, w;
S (T, P, Q, n1, m, 1);
S (T + 1, P + 1, Q + 1, m, n2, need_P);
mpz_mul (T[0], T[0], Q[1]);
mpz_mul (T[1], T[1], P[0]);
mpz_add (T[0], T[0], T[1]);
if (need_P)
mpz_mul (P[0], P[0], P[1]);
mpz_mul (Q[0], Q[0], Q[1]);
/* remove common trailing zeroes if any */
v = mpz_scan1 (T[0], 0);
if (v > 0)
{
w = mpz_scan1 (Q[0], 0);
if (w < v)
v = w;
if (need_P)
{
w = mpz_scan1 (P[0], 0);
if (w < v)
v = w;
}
/* now v = min(val(T), val(Q), val(P)) */
if (v > 0)
{
mpz_fdiv_q_2exp (T[0], T[0], v);
mpz_fdiv_q_2exp (Q[0], Q[0], v);
if (need_P)
mpz_fdiv_q_2exp (P[0], P[0], v);
}
}
}
}
static int count_lsb_bits(void *a)
{
LTC_ARGCHK(a != NULL);
return mpz_scan1(a, 0);
}
static PyObject *
GMPY_mpz_is_fibonacci_prp(PyObject *self, PyObject *args)
{
MPZ_Object *n, *p, *q;
PyObject *result = 0;
mpz_t pmodn, zP;
/* used for calculating the Lucas V sequence */
mpz_t vl, vh, ql, qh, tmp;
mp_bitcnt_t s = 0, j = 0;
if (PyTuple_Size(args) != 3) {
TYPE_ERROR("is_fibonacci_prp() requires 3 integer arguments");
return NULL;
}
mpz_init(pmodn);
mpz_init(zP);
mpz_init(vl);
mpz_init(vh);
mpz_init(ql);
mpz_init(qh);
mpz_init(tmp);
n = GMPy_MPZ_From_Integer(PyTuple_GET_ITEM(args, 0), NULL);
p = GMPy_MPZ_From_Integer(PyTuple_GET_ITEM(args, 1), NULL);
q = GMPy_MPZ_From_Integer(PyTuple_GET_ITEM(args, 2), NULL);
if (!n || !p || !q) {
TYPE_ERROR("is_fibonacci_prp() requires 3 integer arguments");
goto cleanup;
}
/* Check if p*p - 4*q == 0. */
mpz_mul(tmp, p->z, p->z);
mpz_mul_ui(qh, q->z, 4);
mpz_sub(tmp, tmp, qh);
if (mpz_sgn(tmp) == 0) {
VALUE_ERROR("invalid values for p,q in is_fibonacci_prp()");
goto cleanup;
}
/* Verify q = +/-1 */
if ((mpz_cmp_si(q->z, 1) && mpz_cmp_si(q->z, -1)) || (mpz_sgn(p->z) <= 0)) {
VALUE_ERROR("invalid values for p,q in is_fibonacci_prp()");
goto cleanup;
}
/* Require n > 0. */
if (mpz_sgn(n->z) <= 0) {
VALUE_ERROR("is_fibonacci_prp() requires 'n' be greater than 0");
goto cleanup;
}
/* Check for n == 1 */
if (mpz_cmp_ui(n->z, 1) == 0) {
result = Py_False;
goto cleanup;
}
/* Handle n even. */
if (mpz_divisible_ui_p(n->z, 2)) {
if (mpz_cmp_ui(n->z, 2) == 0)
result = Py_True;
else
result = Py_False;
goto cleanup;
}
mpz_set(zP, p->z);
mpz_mod(pmodn, zP, n->z);
/* mpz_lucasvmod(res, p, q, n, n); */
mpz_set_si(vl, 2);
mpz_set(vh, p->z);
mpz_set_si(ql, 1);
mpz_set_si(qh, 1);
mpz_set_si(tmp,0);
s = mpz_scan1(n->z, 0);
for (j = mpz_sizeinbase(n->z,2)-1; j >= s+1; j--) {
/* ql = ql*qh (mod n) */
mpz_mul(ql, ql, qh);
mpz_mod(ql, ql, n->z);
if (mpz_tstbit(n->z,j) == 1) {
/* qh = ql*q */
mpz_mul(qh, ql, q->z);
/* vl = vh*vl - p*ql (mod n) */
mpz_mul(vl, vh, vl);
mpz_mul(tmp, ql, p->z);
mpz_sub(vl, vl, tmp);
mpz_mod(vl, vl, n->z);
/* vh = vh*vh - 2*qh (mod n) */
mpz_mul(vh, vh, vh);
mpz_mul_si(tmp, qh, 2);
mpz_sub(vh, vh, tmp);
mpz_mod(vh, vh, n->z);
}
else {
/* qh = ql */
mpz_set(qh, ql);
/* vh = vh*vl - p*ql (mod n) */
mpz_mul(vh, vh, vl);
mpz_mul(tmp, ql, p->z);
mpz_sub(vh, vh, tmp);
mpz_mod(vh, vh, n->z);
/* vl = vl*vl - 2*ql (mod n) */
mpz_mul(vl, vl, vl);
mpz_mul_si(tmp, ql, 2);
mpz_sub(vl, vl, tmp);
mpz_mod(vl, vl, n->z);
}
}
/* ql = ql*qh */
mpz_mul(ql, ql, qh);
/* qh = ql*q */
mpz_mul(qh, ql, q->z);
/* vl = vh*vl - p*ql */
mpz_mul(vl, vh, vl);
mpz_mul(tmp, ql, p->z);
mpz_sub(vl, vl, tmp);
/* ql = ql*qh */
mpz_mul(ql, ql, qh);
for (j = 1; j <= s; j++) {
/* vl = vl*vl - 2*ql (mod n) */
mpz_mul(vl, vl, vl);
mpz_mul_si(tmp, ql, 2);
mpz_sub(vl, vl, tmp);
mpz_mod(vl, vl, n->z);
/* ql = ql*ql (mod n) */
mpz_mul(ql, ql, ql);
mpz_mod(ql, ql, n->z);
}
/* vl contains our return value */
mpz_mod(vl, vl, n->z);
if (mpz_cmp(vl, pmodn) == 0)
result = Py_True;
else
result = Py_False;
cleanup:
Py_XINCREF(result);
mpz_clear(pmodn);
mpz_clear(zP);
mpz_clear(vl);
mpz_clear(vh);
mpz_clear(ql);
mpz_clear(qh);
mpz_clear(tmp);
Py_XDECREF((PyObject*)p);
Py_XDECREF((PyObject*)q);
Py_XDECREF((PyObject*)n);
return result;
}
/* return non zero iff x^y is exact.
Assumes x and y are ordinary numbers,
y is not an integer, x is not a power of 2 and x is positive
If x^y is exact, it computes it and sets *inexact.
*/
static int
mpfr_pow_is_exact (mpfr_ptr z, mpfr_srcptr x, mpfr_srcptr y,
mpfr_rnd_t rnd_mode, int *inexact)
{
mpz_t a, c;
mpfr_exp_t d, b;
unsigned long i;
int res;
MPFR_ASSERTD (!MPFR_IS_SINGULAR (y));
MPFR_ASSERTD (!MPFR_IS_SINGULAR (x));
MPFR_ASSERTD (!mpfr_integer_p (y));
MPFR_ASSERTD (mpfr_cmp_si_2exp (x, MPFR_INT_SIGN (x),
MPFR_GET_EXP (x) - 1) != 0);
MPFR_ASSERTD (MPFR_IS_POS (x));
if (MPFR_IS_NEG (y))
return 0; /* x is not a power of two => x^-y is not exact */
/* compute d such that y = c*2^d with c odd integer */
mpz_init (c);
d = mpfr_get_z_2exp (c, y);
i = mpz_scan1 (c, 0);
mpz_fdiv_q_2exp (c, c, i);
d += i;
/* now y=c*2^d with c odd */
/* Since y is not an integer, d is necessarily < 0 */
MPFR_ASSERTD (d < 0);
/* Compute a,b such that x=a*2^b */
mpz_init (a);
b = mpfr_get_z_2exp (a, x);
i = mpz_scan1 (a, 0);
mpz_fdiv_q_2exp (a, a, i);
b += i;
/* now x=a*2^b with a is odd */
for (res = 1 ; d != 0 ; d++)
{
/* a*2^b is a square iff
(i) a is a square when b is even
(ii) 2*a is a square when b is odd */
if (b % 2 != 0)
{
mpz_mul_2exp (a, a, 1); /* 2*a */
b --;
}
MPFR_ASSERTD ((b % 2) == 0);
if (!mpz_perfect_square_p (a))
{
res = 0;
goto end;
}
mpz_sqrt (a, a);
b = b / 2;
}
/* Now x = (a'*2^b')^(2^-d) with d < 0
so x^y = ((a'*2^b')^(2^-d))^(c*2^d)
= ((a'*2^b')^c with c odd integer */
{
mpfr_t tmp;
mpfr_prec_t p;
MPFR_MPZ_SIZEINBASE2 (p, a);
mpfr_init2 (tmp, p); /* prec = 1 should not be possible */
res = mpfr_set_z (tmp, a, MPFR_RNDN);
MPFR_ASSERTD (res == 0);
res = mpfr_mul_2si (tmp, tmp, b, MPFR_RNDN);
MPFR_ASSERTD (res == 0);
*inexact = mpfr_pow_z (z, tmp, c, rnd_mode);
mpfr_clear (tmp);
res = 1;
}
end:
mpz_clear (a);
mpz_clear (c);
return res;
}
/* If x = p/2^r, put in y an approximation of atan(x)/x using 2^m terms
for the series expansion, with an error of at most 1 ulp.
Assumes |x| < 1.
If X=x^2, we want 1 - X/3 + X^2/5 - ... + (-1)^k*X^k/(2k+1) + ...
Assume p is non-zero.
When we sum terms up to x^k/(2k+1), the denominator Q[0] is
3*5*7*...*(2k+1) ~ (2k/e)^k.
*/
static void
mpfr_atan_aux (mpfr_ptr y, mpz_ptr p, long r, int m, mpz_t *tab)
{
mpz_t *S, *Q, *ptoj;
unsigned long n, i, k, j, l;
mpfr_exp_t diff, expo;
int im, done;
mpfr_prec_t mult, *accu, *log2_nb_terms;
mpfr_prec_t precy = MPFR_PREC(y);
MPFR_ASSERTD(mpz_cmp_ui (p, 0) != 0);
accu = (mpfr_prec_t*) (*__gmp_allocate_func) ((2 * m + 2) * sizeof (mpfr_prec_t));
log2_nb_terms = accu + m + 1;
/* Set Tables */
S = tab; /* S */
ptoj = S + 1*(m+1); /* p^2^j Precomputed table */
Q = S + 2*(m+1); /* Product of Odd integer table */
/* From p to p^2, and r to 2r */
mpz_mul (p, p, p);
MPFR_ASSERTD (2 * r > r);
r = 2 * r;
/* Normalize p */
n = mpz_scan1 (p, 0);
mpz_tdiv_q_2exp (p, p, n); /* exact */
MPFR_ASSERTD (r > n);
r -= n;
/* since |p/2^r| < 1, and p is a non-zero integer, necessarily r > 0 */
MPFR_ASSERTD (mpz_sgn (p) > 0);
MPFR_ASSERTD (m > 0);
/* check if p=1 (special case) */
l = 0;
/*
We compute by binary splitting, with X = x^2 = p/2^r:
P(a,b) = p if a+1=b, P(a,c)*P(c,b) otherwise
Q(a,b) = (2a+1)*2^r if a+1=b [except Q(0,1)=1], Q(a,c)*Q(c,b) otherwise
S(a,b) = p*(2a+1) if a+1=b, Q(c,b)*S(a,c)+Q(a,c)*P(a,c)*S(c,b) otherwise
Then atan(x)/x ~ S(0,i)/Q(0,i) for i so that (p/2^r)^i/i is small enough.
The factor 2^(r*(b-a)) in Q(a,b) is implicit, thus we have to take it
into account when we compute with Q.
*/
accu[0] = 0; /* accu[k] = Mult[0] + ... + Mult[k], where Mult[j] is the
number of bits of the corresponding term S[j]/Q[j] */
if (mpz_cmp_ui (p, 1) != 0)
{
/* p <> 1: precompute ptoj table */
mpz_set (ptoj[0], p);
for (im = 1 ; im <= m ; im ++)
mpz_mul (ptoj[im], ptoj[im - 1], ptoj[im - 1]);
/* main loop */
n = 1UL << m;
/* the ith term being X^i/(2i+1) with X=p/2^r, we can stop when
p^i/2^(r*i) < 2^(-precy), i.e. r*i > precy + log2(p^i) */
for (i = k = done = 0; (i < n) && (done == 0); i += 2, k ++)
{
/* initialize both S[k],Q[k] and S[k+1],Q[k+1] */
mpz_set_ui (Q[k+1], 2 * i + 3); /* Q(i+1,i+2) */
mpz_mul_ui (S[k+1], p, 2 * i + 1); /* S(i+1,i+2) */
mpz_mul_2exp (S[k], Q[k+1], r);
mpz_sub (S[k], S[k], S[k+1]); /* S(i,i+2) */
mpz_mul_ui (Q[k], Q[k+1], 2 * i + 1); /* Q(i,i+2) */
log2_nb_terms[k] = 1; /* S[k]/Q[k] corresponds to 2 terms */
for (j = (i + 2) >> 1, l = 1; (j & 1) == 0; l ++, j >>= 1, k --)
{
/* invariant: S[k-1]/Q[k-1] and S[k]/Q[k] correspond
to 2^l terms each. We combine them into S[k-1]/Q[k-1] */
MPFR_ASSERTD (k > 0);
mpz_mul (S[k], S[k], Q[k-1]);
mpz_mul (S[k], S[k], ptoj[l]);
mpz_mul (S[k-1], S[k-1], Q[k]);
mpz_mul_2exp (S[k-1], S[k-1], r << l);
mpz_add (S[k-1], S[k-1], S[k]);
mpz_mul (Q[k-1], Q[k-1], Q[k]);
log2_nb_terms[k-1] = l + 1;
/* now S[k-1]/Q[k-1] corresponds to 2^(l+1) terms */
MPFR_MPZ_SIZEINBASE2(mult, ptoj[l+1]);
/* FIXME: precompute bits(ptoj[l+1]) outside the loop? */
mult = (r << (l + 1)) - mult - 1;
accu[k-1] = (k == 1) ? mult : accu[k-2] + mult;
if (accu[k-1] > precy)
done = 1;
}
}
}
/* Evaluate the expression E and put the result in R. */
void
mpz_eval_expr (mpz_ptr r, expr_t e)
{
mpz_t lhs, rhs;
switch (e->op)
{
case LIT:
mpz_set (r, e->operands.val);
return;
case PLUS:
mpz_init (lhs); mpz_init (rhs);
mpz_eval_expr (lhs, e->operands.ops.lhs);
mpz_eval_expr (rhs, e->operands.ops.rhs);
mpz_add (r, lhs, rhs);
mpz_clear (lhs); mpz_clear (rhs);
return;
case MINUS:
mpz_init (lhs); mpz_init (rhs);
mpz_eval_expr (lhs, e->operands.ops.lhs);
mpz_eval_expr (rhs, e->operands.ops.rhs);
mpz_sub (r, lhs, rhs);
mpz_clear (lhs); mpz_clear (rhs);
return;
case MULT:
mpz_init (lhs); mpz_init (rhs);
mpz_eval_expr (lhs, e->operands.ops.lhs);
mpz_eval_expr (rhs, e->operands.ops.rhs);
mpz_mul (r, lhs, rhs);
mpz_clear (lhs); mpz_clear (rhs);
return;
case DIV:
mpz_init (lhs); mpz_init (rhs);
mpz_eval_expr (lhs, e->operands.ops.lhs);
mpz_eval_expr (rhs, e->operands.ops.rhs);
mpz_fdiv_q (r, lhs, rhs);
mpz_clear (lhs); mpz_clear (rhs);
return;
case MOD:
mpz_init (rhs);
mpz_eval_expr (rhs, e->operands.ops.rhs);
mpz_abs (rhs, rhs);
mpz_eval_mod_expr (r, e->operands.ops.lhs, rhs);
mpz_clear (rhs);
return;
case REM:
/* Check if lhs operand is POW expression and optimize for that case. */
if (e->operands.ops.lhs->op == POW)
{
mpz_t powlhs, powrhs;
mpz_init (powlhs);
mpz_init (powrhs);
mpz_init (rhs);
mpz_eval_expr (powlhs, e->operands.ops.lhs->operands.ops.lhs);
mpz_eval_expr (powrhs, e->operands.ops.lhs->operands.ops.rhs);
mpz_eval_expr (rhs, e->operands.ops.rhs);
mpz_powm (r, powlhs, powrhs, rhs);
if (mpz_cmp_si (rhs, 0L) < 0)
mpz_neg (r, r);
mpz_clear (powlhs);
mpz_clear (powrhs);
mpz_clear (rhs);
return;
}
mpz_init (lhs); mpz_init (rhs);
mpz_eval_expr (lhs, e->operands.ops.lhs);
mpz_eval_expr (rhs, e->operands.ops.rhs);
mpz_fdiv_r (r, lhs, rhs);
mpz_clear (lhs); mpz_clear (rhs);
return;
#if __GNU_MP_VERSION >= 2
case INVMOD:
mpz_init (lhs); mpz_init (rhs);
mpz_eval_expr (lhs, e->operands.ops.lhs);
mpz_eval_expr (rhs, e->operands.ops.rhs);
mpz_invert (r, lhs, rhs);
mpz_clear (lhs); mpz_clear (rhs);
return;
#endif
case POW:
mpz_init (lhs); mpz_init (rhs);
mpz_eval_expr (lhs, e->operands.ops.lhs);
if (mpz_cmpabs_ui (lhs, 1) <= 0)
{
/* For 0^rhs and 1^rhs, we just need to verify that
rhs is well-defined. For (-1)^rhs we need to
determine (rhs mod 2). For simplicity, compute
(rhs mod 2) for all three cases. */
expr_t two, et;
two = malloc (sizeof (struct expr));
two -> op = LIT;
mpz_init_set_ui (two->operands.val, 2L);
makeexp (&et, MOD, e->operands.ops.rhs, two);
e->operands.ops.rhs = et;
}
mpz_eval_expr (rhs, e->operands.ops.rhs);
if (mpz_cmp_si (rhs, 0L) == 0)
/* x^0 is 1 */
mpz_set_ui (r, 1L);
else if (mpz_cmp_si (lhs, 0L) == 0)
/* 0^y (where y != 0) is 0 */
mpz_set_ui (r, 0L);
else if (mpz_cmp_ui (lhs, 1L) == 0)
/* 1^y is 1 */
mpz_set_ui (r, 1L);
else if (mpz_cmp_si (lhs, -1L) == 0)
/* (-1)^y just depends on whether y is even or odd */
mpz_set_si (r, (mpz_get_ui (rhs) & 1) ? -1L : 1L);
else if (mpz_cmp_si (rhs, 0L) < 0)
/* x^(-n) is 0 */
mpz_set_ui (r, 0L);
else
{
unsigned long int cnt;
unsigned long int y;
/* error if exponent does not fit into an unsigned long int. */
if (mpz_cmp_ui (rhs, ~(unsigned long int) 0) > 0)
goto pow_err;
y = mpz_get_ui (rhs);
/* x^y == (x/(2^c))^y * 2^(c*y) */
#if __GNU_MP_VERSION >= 2
cnt = mpz_scan1 (lhs, 0);
#else
cnt = 0;
#endif
if (cnt != 0)
{
if (y * cnt / cnt != y)
goto pow_err;
mpz_tdiv_q_2exp (lhs, lhs, cnt);
mpz_pow_ui (r, lhs, y);
mpz_mul_2exp (r, r, y * cnt);
}
else
mpz_pow_ui (r, lhs, y);
}
mpz_clear (lhs); mpz_clear (rhs);
return;
pow_err:
error = "result of `pow' operator too large";
mpz_clear (lhs); mpz_clear (rhs);
longjmp (errjmpbuf, 1);
case GCD:
mpz_init (lhs); mpz_init (rhs);
mpz_eval_expr (lhs, e->operands.ops.lhs);
mpz_eval_expr (rhs, e->operands.ops.rhs);
mpz_gcd (r, lhs, rhs);
mpz_clear (lhs); mpz_clear (rhs);
return;
#if __GNU_MP_VERSION > 2 || __GNU_MP_VERSION_MINOR >= 1
case LCM:
mpz_init (lhs); mpz_init (rhs);
mpz_eval_expr (lhs, e->operands.ops.lhs);
mpz_eval_expr (rhs, e->operands.ops.rhs);
mpz_lcm (r, lhs, rhs);
mpz_clear (lhs); mpz_clear (rhs);
return;
#endif
case AND:
mpz_init (lhs); mpz_init (rhs);
mpz_eval_expr (lhs, e->operands.ops.lhs);
mpz_eval_expr (rhs, e->operands.ops.rhs);
mpz_and (r, lhs, rhs);
mpz_clear (lhs); mpz_clear (rhs);
return;
case IOR:
mpz_init (lhs); mpz_init (rhs);
mpz_eval_expr (lhs, e->operands.ops.lhs);
mpz_eval_expr (rhs, e->operands.ops.rhs);
mpz_ior (r, lhs, rhs);
mpz_clear (lhs); mpz_clear (rhs);
return;
#if __GNU_MP_VERSION > 2 || __GNU_MP_VERSION_MINOR >= 1
case XOR:
mpz_init (lhs); mpz_init (rhs);
mpz_eval_expr (lhs, e->operands.ops.lhs);
mpz_eval_expr (rhs, e->operands.ops.rhs);
mpz_xor (r, lhs, rhs);
mpz_clear (lhs); mpz_clear (rhs);
return;
#endif
case NEG:
mpz_eval_expr (r, e->operands.ops.lhs);
mpz_neg (r, r);
return;
case NOT:
mpz_eval_expr (r, e->operands.ops.lhs);
mpz_com (r, r);
return;
case SQRT:
mpz_init (lhs);
mpz_eval_expr (lhs, e->operands.ops.lhs);
if (mpz_sgn (lhs) < 0)
{
error = "cannot take square root of negative numbers";
mpz_clear (lhs);
longjmp (errjmpbuf, 1);
}
mpz_sqrt (r, lhs);
return;
#if __GNU_MP_VERSION > 2 || __GNU_MP_VERSION_MINOR >= 1
case ROOT:
mpz_init (lhs); mpz_init (rhs);
mpz_eval_expr (lhs, e->operands.ops.lhs);
mpz_eval_expr (rhs, e->operands.ops.rhs);
if (mpz_sgn (rhs) <= 0)
{
error = "cannot take non-positive root orders";
mpz_clear (lhs); mpz_clear (rhs);
longjmp (errjmpbuf, 1);
}
if (mpz_sgn (lhs) < 0 && (mpz_get_ui (rhs) & 1) == 0)
{
error = "cannot take even root orders of negative numbers";
mpz_clear (lhs); mpz_clear (rhs);
longjmp (errjmpbuf, 1);
}
{
unsigned long int nth = mpz_get_ui (rhs);
if (mpz_cmp_ui (rhs, ~(unsigned long int) 0) > 0)
{
/* If we are asked to take an awfully large root order, cheat and
ask for the largest order we can pass to mpz_root. This saves
some error prone special cases. */
nth = ~(unsigned long int) 0;
}
mpz_root (r, lhs, nth);
}
mpz_clear (lhs); mpz_clear (rhs);
return;
#endif
case FAC:
mpz_eval_expr (r, e->operands.ops.lhs);
if (mpz_size (r) > 1)
{
error = "result of `!' operator too large";
longjmp (errjmpbuf, 1);
}
mpz_fac_ui (r, mpz_get_ui (r));
return;
#if __GNU_MP_VERSION >= 2
case POPCNT:
mpz_eval_expr (r, e->operands.ops.lhs);
{ long int cnt;
cnt = mpz_popcount (r);
mpz_set_si (r, cnt);
}
return;
case HAMDIST:
{ long int cnt;
mpz_init (lhs); mpz_init (rhs);
mpz_eval_expr (lhs, e->operands.ops.lhs);
mpz_eval_expr (rhs, e->operands.ops.rhs);
cnt = mpz_hamdist (lhs, rhs);
mpz_clear (lhs); mpz_clear (rhs);
mpz_set_si (r, cnt);
}
return;
#endif
case LOG2:
mpz_eval_expr (r, e->operands.ops.lhs);
{ unsigned long int cnt;
if (mpz_sgn (r) <= 0)
{
error = "logarithm of non-positive number";
longjmp (errjmpbuf, 1);
}
cnt = mpz_sizeinbase (r, 2);
mpz_set_ui (r, cnt - 1);
}
return;
case LOG:
{ unsigned long int cnt;
mpz_init (lhs); mpz_init (rhs);
mpz_eval_expr (lhs, e->operands.ops.lhs);
mpz_eval_expr (rhs, e->operands.ops.rhs);
if (mpz_sgn (lhs) <= 0)
{
error = "logarithm of non-positive number";
mpz_clear (lhs); mpz_clear (rhs);
longjmp (errjmpbuf, 1);
}
if (mpz_cmp_ui (rhs, 256) >= 0)
{
error = "logarithm base too large";
mpz_clear (lhs); mpz_clear (rhs);
longjmp (errjmpbuf, 1);
}
cnt = mpz_sizeinbase (lhs, mpz_get_ui (rhs));
mpz_set_ui (r, cnt - 1);
mpz_clear (lhs); mpz_clear (rhs);
}
return;
case FERMAT:
{
unsigned long int t;
mpz_init (lhs);
mpz_eval_expr (lhs, e->operands.ops.lhs);
t = (unsigned long int) 1 << mpz_get_ui (lhs);
if (mpz_cmp_ui (lhs, ~(unsigned long int) 0) > 0 || t == 0)
{
error = "too large Mersenne number index";
mpz_clear (lhs);
longjmp (errjmpbuf, 1);
}
mpz_set_ui (r, 1);
mpz_mul_2exp (r, r, t);
mpz_add_ui (r, r, 1);
mpz_clear (lhs);
}
return;
case MERSENNE:
mpz_init (lhs);
mpz_eval_expr (lhs, e->operands.ops.lhs);
if (mpz_cmp_ui (lhs, ~(unsigned long int) 0) > 0)
{
error = "too large Mersenne number index";
mpz_clear (lhs);
longjmp (errjmpbuf, 1);
}
mpz_set_ui (r, 1);
mpz_mul_2exp (r, r, mpz_get_ui (lhs));
mpz_sub_ui (r, r, 1);
mpz_clear (lhs);
return;
case FIBONACCI:
{ mpz_t t;
unsigned long int n, i;
mpz_init (lhs);
mpz_eval_expr (lhs, e->operands.ops.lhs);
if (mpz_sgn (lhs) <= 0 || mpz_cmp_si (lhs, 1000000000) > 0)
{
error = "Fibonacci index out of range";
mpz_clear (lhs);
longjmp (errjmpbuf, 1);
}
n = mpz_get_ui (lhs);
mpz_clear (lhs);
#if __GNU_MP_VERSION > 2 || __GNU_MP_VERSION_MINOR >= 1
mpz_fib_ui (r, n);
#else
mpz_init_set_ui (t, 1);
mpz_set_ui (r, 1);
if (n <= 2)
mpz_set_ui (r, 1);
else
{
for (i = 3; i <= n; i++)
{
mpz_add (t, t, r);
mpz_swap (t, r);
}
}
mpz_clear (t);
#endif
}
return;
case RANDOM:
{
unsigned long int n;
mpz_init (lhs);
mpz_eval_expr (lhs, e->operands.ops.lhs);
if (mpz_sgn (lhs) <= 0 || mpz_cmp_si (lhs, 1000000000) > 0)
{
error = "random number size out of range";
mpz_clear (lhs);
longjmp (errjmpbuf, 1);
}
n = mpz_get_ui (lhs);
mpz_clear (lhs);
mpz_urandomb (r, rstate, n);
}
return;
case NEXTPRIME:
{
mpz_eval_expr (r, e->operands.ops.lhs);
mpz_nextprime (r, r);
}
return;
case BINOM:
mpz_init (lhs); mpz_init (rhs);
mpz_eval_expr (lhs, e->operands.ops.lhs);
mpz_eval_expr (rhs, e->operands.ops.rhs);
{
unsigned long int k;
if (mpz_cmp_ui (rhs, ~(unsigned long int) 0) > 0)
{
error = "k too large in (n over k) expression";
mpz_clear (lhs); mpz_clear (rhs);
longjmp (errjmpbuf, 1);
}
k = mpz_get_ui (rhs);
mpz_bin_ui (r, lhs, k);
}
mpz_clear (lhs); mpz_clear (rhs);
return;
case TIMING:
{
int t0;
t0 = cputime ();
mpz_eval_expr (r, e->operands.ops.lhs);
printf ("time: %d\n", cputime () - t0);
}
return;
default:
abort ();
}
}
/* *******************************************************************************
* mpz_lucas_prp:
* A "Lucas pseudoprime" with parameters (P,Q) is a composite n with D=P^2-4Q,
* (n,2QD)=1 such that U_(n-(D/n)) == 0 mod n [(D/n) is the Jacobi symbol]
* *******************************************************************************/
int mpz_lucas_prp(mpz_t n, long int p, long int q)
{
mpz_t zD;
mpz_t res;
mpz_t index;
mpz_t uh, vl, vh, ql, qh, tmp; /* used for calculating the Lucas U sequence */
int s = 0, j = 0;
int ret = 0;
long int d = p*p - 4*q;
if (d == 0) /* Does not produce a proper Lucas sequence */
return PRP_ERROR;
if (mpz_cmp_ui(n, 2) < 0)
return PRP_COMPOSITE;
if (mpz_divisible_ui_p(n, 2))
{
if (mpz_cmp_ui(n, 2) == 0)
return PRP_PRIME;
else
return PRP_COMPOSITE;
}
mpz_init(index);
mpz_init_set_si(zD, d);
mpz_init(res);
mpz_mul_si(res, zD, q);
mpz_mul_ui(res, res, 2);
mpz_gcd(res, res, n);
if ((mpz_cmp(res, n) != 0) && (mpz_cmp_ui(res, 1) > 0))
{
mpz_clear(zD);
mpz_clear(res);
mpz_clear(index);
return PRP_COMPOSITE;
}
/* index = n-(D/n), where (D/n) is the Jacobi symbol */
mpz_set(index, n);
ret = mpz_jacobi(zD, n);
if (ret == -1)
mpz_add_ui(index, index, 1);
else if (ret == 1)
mpz_sub_ui(index, index, 1);
/* mpz_lucasumod(res, p, q, index, n); */
mpz_init_set_si(uh, 1);
mpz_init_set_si(vl, 2);
mpz_init_set_si(vh, p);
mpz_init_set_si(ql, 1);
mpz_init_set_si(qh, 1);
mpz_init_set_si(tmp,0);
s = mpz_scan1(index, 0);
for (j = mpz_sizeinbase(index,2)-1; j >= s+1; j--)
{
/* ql = ql*qh (mod n) */
mpz_mul(ql, ql, qh);
mpz_mod(ql, ql, n);
if (mpz_tstbit(index,j) == 1)
{
/* qh = ql*q */
mpz_mul_si(qh, ql, q);
/* uh = uh*vh (mod n) */
mpz_mul(uh, uh, vh);
mpz_mod(uh, uh, n);
/* vl = vh*vl - p*ql (mod n) */
mpz_mul(vl, vh, vl);
mpz_mul_si(tmp, ql, p);
mpz_sub(vl, vl, tmp);
mpz_mod(vl, vl, n);
/* vh = vh*vh - 2*qh (mod n) */
mpz_mul(vh, vh, vh);
mpz_mul_si(tmp, qh, 2);
mpz_sub(vh, vh, tmp);
mpz_mod(vh, vh, n);
}
else
{
/* qh = ql */
mpz_set(qh, ql);
/* uh = uh*vl - ql (mod n) */
mpz_mul(uh, uh, vl);
mpz_sub(uh, uh, ql);
mpz_mod(uh, uh, n);
/* vh = vh*vl - p*ql (mod n) */
mpz_mul(vh, vh, vl);
mpz_mul_si(tmp, ql, p);
mpz_sub(vh, vh, tmp);
mpz_mod(vh, vh, n);
/* vl = vl*vl - 2*ql (mod n) */
mpz_mul(vl, vl, vl);
mpz_mul_si(tmp, ql, 2);
mpz_sub(vl, vl, tmp);
mpz_mod(vl, vl, n);
}
}
/* ql = ql*qh */
mpz_mul(ql, ql, qh);
/* qh = ql*q */
mpz_mul_si(qh, ql, q);
/* uh = uh*vl - ql */
mpz_mul(uh, uh, vl);
mpz_sub(uh, uh, ql);
/* vl = vh*vl - p*ql */
mpz_mul(vl, vh, vl);
mpz_mul_si(tmp, ql, p);
mpz_sub(vl, vl, tmp);
/* ql = ql*qh */
mpz_mul(ql, ql, qh);
for (j = 1; j <= s; j++)
{
/* uh = uh*vl (mod n) */
mpz_mul(uh, uh, vl);
mpz_mod(uh, uh, n);
/* vl = vl*vl - 2*ql (mod n) */
mpz_mul(vl, vl, vl);
mpz_mul_si(tmp, ql, 2);
mpz_sub(vl, vl, tmp);
mpz_mod(vl, vl, n);
/* ql = ql*ql (mod n) */
mpz_mul(ql, ql, ql);
mpz_mod(ql, ql, n);
}
mpz_mod(res, uh, n); /* uh contains our return value */
mpz_clear(zD);
mpz_clear(index);
mpz_clear(uh);
mpz_clear(vl);
mpz_clear(vh);
mpz_clear(ql);
mpz_clear(qh);
mpz_clear(tmp);
if (mpz_cmp_ui(res, 0) == 0)
{
mpz_clear(res);
return PRP_PRP;
}
else
{
mpz_clear(res);
return PRP_COMPOSITE;
}
}/* method mpz_lucas_prp */
static PyObject *
GMPY_mpz_is_extrastronglucas_prp(PyObject *self, PyObject *args)
{
MPZ_Object *n, *p;
PyObject *result = 0;
mpz_t zD, s, nmj, nm2, res;
/* these are needed for the LucasU and LucasV part of this function */
mpz_t uh, vl, vh, ql, qh, tmp;
mp_bitcnt_t r = 0, j = 0;
int ret = 0;
if (PyTuple_Size(args) != 2) {
TYPE_ERROR("is_extra_strong_lucas_prp() requires 2 integer arguments");
return NULL;
}
mpz_init(zD);
mpz_init(s);
mpz_init(nmj);
mpz_init(nm2);
mpz_init(res);
mpz_init(uh);
mpz_init(vl);
mpz_init(vh);
mpz_init(ql);
mpz_init(qh);
mpz_init(tmp);
n = GMPy_MPZ_From_Integer(PyTuple_GET_ITEM(args, 0), NULL);
p = GMPy_MPZ_From_Integer(PyTuple_GET_ITEM(args, 1), NULL);
if (!n || !p) {
TYPE_ERROR("is_extra_strong_lucas_prp() requires 2 integer arguments");
goto cleanup;
}
/* Check if p*p - 4 == 0. */
mpz_mul(zD, p->z, p->z);
mpz_sub_ui(zD, zD, 4);
if (mpz_sgn(zD) == 0) {
VALUE_ERROR("invalid value for p in is_extra_strong_lucas_prp()");
goto cleanup;
}
/* Require n > 0. */
if (mpz_sgn(n->z) <= 0) {
VALUE_ERROR("is_extra_strong_lucas_prp() requires 'n' be greater than 0");
goto cleanup;
}
/* Check for n == 1 */
if (mpz_cmp_ui(n->z, 1) == 0) {
result = Py_False;
goto cleanup;
}
/* Handle n even. */
if (mpz_divisible_ui_p(n->z, 2)) {
if (mpz_cmp_ui(n->z, 2) == 0)
result = Py_True;
else
result = Py_False;
goto cleanup;
}
/* Check GCD */
mpz_mul_ui(res, zD, 2);
mpz_gcd(res, res, n->z);
if ((mpz_cmp(res, n->z) != 0) && (mpz_cmp_ui(res, 1) > 0)) {
VALUE_ERROR("is_extra_strong_lucas_prp() requires gcd(n,2*D) == 1");
goto cleanup;
}
/* nmj = n - (D/n), where (D/n) is the Jacobi symbol */
mpz_set(nmj, n->z);
ret = mpz_jacobi(zD, n->z);
if (ret == -1)
mpz_add_ui(nmj, nmj, 1);
else if (ret == 1)
mpz_sub_ui(nmj, nmj, 1);
r = mpz_scan1(nmj, 0);
mpz_fdiv_q_2exp(s, nmj, r);
mpz_set(nm2, n->z);
mpz_sub_ui(nm2, nm2, 2);
/* make sure that either U_s == 0 mod n or V_s == +/-2 mod n, or */
/* V_((2^t)*s) == 0 mod n for some t with 0 <= t < r-1 */
mpz_set_si(uh, 1);
mpz_set_si(vl, 2);
mpz_set(vh, p->z);
mpz_set_si(ql, 1);
mpz_set_si(qh, 1);
mpz_set_si(tmp,0);
for (j = mpz_sizeinbase(s,2)-1; j >= 1; j--) {
/* ql = ql*qh (mod n) */
mpz_mul(ql, ql, qh);
mpz_mod(ql, ql, n->z);
if (mpz_tstbit(s,j) == 1) {
/* qh = ql*q */
mpz_set(qh, ql);
/* uh = uh*vh (mod n) */
mpz_mul(uh, uh, vh);
mpz_mod(uh, uh, n->z);
/* vl = vh*vl - p*ql (mod n) */
mpz_mul(vl, vh, vl);
mpz_mul(tmp, ql, p->z);
mpz_sub(vl, vl, tmp);
mpz_mod(vl, vl, n->z);
/* vh = vh*vh - 2*qh (mod n) */
mpz_mul(vh, vh, vh);
mpz_mul_si(tmp, qh, 2);
mpz_sub(vh, vh, tmp);
mpz_mod(vh, vh, n->z);
}
else {
/* qh = ql */
mpz_set(qh, ql);
/* uh = uh*vl - ql (mod n) */
mpz_mul(uh, uh, vl);
mpz_sub(uh, uh, ql);
mpz_mod(uh, uh, n->z);
/* vh = vh*vl - p*ql (mod n) */
mpz_mul(vh, vh, vl);
mpz_mul(tmp, ql, p->z);
mpz_sub(vh, vh, tmp);
mpz_mod(vh, vh, n->z);
/* vl = vl*vl - 2*ql (mod n) */
mpz_mul(vl, vl, vl);
mpz_mul_si(tmp, ql, 2);
mpz_sub(vl, vl, tmp);
mpz_mod(vl, vl, n->z);
}
}
/* ql = ql*qh */
mpz_mul(ql, ql, qh);
/* qh = ql*q */
mpz_set(qh, ql);
/* uh = uh*vl - ql */
mpz_mul(uh, uh, vl);
mpz_sub(uh, uh, ql);
/* vl = vh*vl - p*ql */
mpz_mul(vl, vh, vl);
mpz_mul(tmp, ql, p->z);
mpz_sub(vl, vl, tmp);
/* ql = ql*qh */
mpz_mul(ql, ql, qh);
mpz_mod(uh, uh, n->z);
mpz_mod(vl, vl, n->z);
/* uh contains LucasU_s and vl contains LucasV_s */
if ((mpz_cmp_ui(uh, 0) == 0) || (mpz_cmp_ui(vl, 0) == 0) ||
(mpz_cmp(vl, nm2) == 0) || (mpz_cmp_si(vl, 2) == 0)) {
result = Py_True;
goto cleanup;
}
for (j = 1; j < r-1; j++) {
/* vl = vl*vl - 2*ql (mod n) */
mpz_mul(vl, vl, vl);
mpz_mul_si(tmp, ql, 2);
mpz_sub(vl, vl, tmp);
mpz_mod(vl, vl, n->z);
/* ql = ql*ql (mod n) */
mpz_mul(ql, ql, ql);
mpz_mod(ql, ql, n->z);
if (mpz_cmp_ui(vl, 0) == 0) {
result = Py_True;
goto cleanup;
}
}
result = Py_False;
cleanup:
Py_XINCREF(result);
mpz_clear(zD);
mpz_clear(s);
mpz_clear(nmj);
mpz_clear(nm2);
mpz_clear(res);
mpz_clear(uh);
mpz_clear(vl);
mpz_clear(vh);
mpz_clear(ql);
mpz_clear(qh);
mpz_clear(tmp);
Py_XDECREF((PyObject*)p);
Py_XDECREF((PyObject*)n);
return result;
}
static PyObject *
GMPY_mpz_is_lucas_prp(PyObject *self, PyObject *args)
{
MPZ_Object *n, *p, *q;
PyObject *result = 0;
mpz_t zD, res, index;
/* used for calculating the Lucas U sequence */
mpz_t uh, vl, vh, ql, qh, tmp;
mp_bitcnt_t s = 0, j = 0;
int ret;
if (PyTuple_Size(args) != 3) {
TYPE_ERROR("is_lucas_prp() requires 3 integer arguments");
return NULL;
}
mpz_init(zD);
mpz_init(res);
mpz_init(index);
mpz_init(uh);
mpz_init(vl);
mpz_init(vh);
mpz_init(ql);
mpz_init(qh);
mpz_init(tmp);
n = GMPy_MPZ_From_Integer(PyTuple_GET_ITEM(args, 0), NULL);
p = GMPy_MPZ_From_Integer(PyTuple_GET_ITEM(args, 1), NULL);
q = GMPy_MPZ_From_Integer(PyTuple_GET_ITEM(args, 2), NULL);
if (!n || !p || !q) {
TYPE_ERROR("is_lucas_prp() requires 3 integer arguments");
goto cleanup;
}
/* Check if p*p - 4*q == 0. */
mpz_mul(zD, p->z, p->z);
mpz_mul_ui(tmp, q->z, 4);
mpz_sub(zD, zD, tmp);
if (mpz_sgn(zD) == 0) {
VALUE_ERROR("invalid values for p,q in is_lucas_prp()");
goto cleanup;
}
/* Require n > 0. */
if (mpz_sgn(n->z) <= 0) {
VALUE_ERROR("is_lucas_prp() requires 'n' be greater than 0");
goto cleanup;
}
/* Check for n == 1 */
if (mpz_cmp_ui(n->z, 1) == 0) {
result = Py_False;
goto cleanup;
}
/* Handle n even. */
if (mpz_divisible_ui_p(n->z, 2)) {
if (mpz_cmp_ui(n->z, 2) == 0)
result = Py_True;
else
result = Py_False;
goto cleanup;
}
/* Check GCD */
mpz_mul(res, zD, q->z);
mpz_mul_ui(res, res, 2);
mpz_gcd(res, res, n->z);
if ((mpz_cmp(res, n->z) != 0) && (mpz_cmp_ui(res, 1) > 0)) {
VALUE_ERROR("is_lucas_prp() requires gcd(n,2*q*D) == 1");
goto cleanup;
}
/* index = n-(D/n), where (D/n) is the Jacobi symbol */
mpz_set(index, n->z);
ret = mpz_jacobi(zD, n->z);
if (ret == -1)
mpz_add_ui(index, index, 1);
else if (ret == 1)
mpz_sub_ui(index, index, 1);
/* mpz_lucasumod(res, p, q, index, n); */
mpz_set_si(uh, 1);
mpz_set_si(vl, 2);
mpz_set(vh, p->z);
mpz_set_si(ql, 1);
mpz_set_si(qh, 1);
mpz_set_si(tmp,0);
s = mpz_scan1(index, 0);
for (j = mpz_sizeinbase(index,2)-1; j >= s+1; j--) {
/* ql = ql*qh (mod n) */
mpz_mul(ql, ql, qh);
mpz_mod(ql, ql, n->z);
if (mpz_tstbit(index,j) == 1) {
/* qh = ql*q */
mpz_mul(qh, ql, q->z);
/* uh = uh*vh (mod n) */
mpz_mul(uh, uh, vh);
mpz_mod(uh, uh, n->z);
/* vl = vh*vl - p*ql (mod n) */
mpz_mul(vl, vh, vl);
mpz_mul(tmp, ql, p->z);
mpz_sub(vl, vl, tmp);
mpz_mod(vl, vl, n->z);
/* vh = vh*vh - 2*qh (mod n) */
mpz_mul(vh, vh, vh);
mpz_mul_si(tmp, qh, 2);
mpz_sub(vh, vh, tmp);
mpz_mod(vh, vh, n->z);
}
else {
/* qh = ql */
mpz_set(qh, ql);
/* uh = uh*vl - ql (mod n) */
mpz_mul(uh, uh, vl);
mpz_sub(uh, uh, ql);
mpz_mod(uh, uh, n->z);
/* vh = vh*vl - p*ql (mod n) */
mpz_mul(vh, vh, vl);
mpz_mul(tmp, ql, p->z);
mpz_sub(vh, vh, tmp);
mpz_mod(vh, vh, n->z);
/* vl = vl*vl - 2*ql (mod n) */
mpz_mul(vl, vl, vl);
mpz_mul_si(tmp, ql, 2);
mpz_sub(vl, vl, tmp);
mpz_mod(vl, vl, n->z);
}
}
/* ql = ql*qh */
mpz_mul(ql, ql, qh);
/* qh = ql*q */
mpz_mul(qh, ql, q->z);
/* uh = uh*vl - ql */
mpz_mul(uh, uh, vl);
mpz_sub(uh, uh, ql);
/* vl = vh*vl - p*ql */
mpz_mul(vl, vh, vl);
mpz_mul(tmp, ql, p->z);
mpz_sub(vl, vl, tmp);
/* ql = ql*qh */
mpz_mul(ql, ql, qh);
for (j = 1; j <= s; j++) {
/* uh = uh*vl (mod n) */
mpz_mul(uh, uh, vl);
mpz_mod(uh, uh, n->z);
/* vl = vl*vl - 2*ql (mod n) */
mpz_mul(vl, vl, vl);
mpz_mul_si(tmp, ql, 2);
mpz_sub(vl, vl, tmp);
mpz_mod(vl, vl, n->z);
/* ql = ql*ql (mod n) */
mpz_mul(ql, ql, ql);
mpz_mod(ql, ql, n->z);
}
/* uh contains our return value */
mpz_mod(res, uh, n->z);
if (mpz_cmp_ui(res, 0) == 0)
result = Py_True;
else
result = Py_False;
cleanup:
Py_XINCREF(result);
mpz_clear(zD);
mpz_clear(res);
mpz_clear(index);
mpz_clear(uh);
mpz_clear(vl);
mpz_clear(vh);
mpz_clear(ql);
mpz_clear(qh);
mpz_clear(tmp);
Py_XDECREF((PyObject*)p);
Py_XDECREF((PyObject*)q);
Py_XDECREF((PyObject*)n);
return result;
}
/* *********************************************************************************************
* mpz_sprp: (also called a Miller-Rabin pseudoprime)
* A "strong pseudoprime" to the base a is an odd composite n = (2^r)*s+1 with s odd such that
* either a^s == 1 mod n, or a^((2^t)*s) == -1 mod n, for some integer t, with 0 <= t < r.
* *********************************************************************************************/
int mpz_sprp(mpz_t n, mpz_t a)
{
mpz_t s;
mpz_t nm1;
mpz_t mpz_test;
unsigned long int r = 0;
if (mpz_cmp_ui(a, 2) < 0)
return PRP_ERROR;
if (mpz_cmp_ui(n, 2) < 0)
return PRP_COMPOSITE;
if (mpz_divisible_ui_p(n, 2))
{
if (mpz_cmp_ui(n, 2) == 0)
return PRP_PRIME;
else
return PRP_COMPOSITE;
}
mpz_init_set_ui(mpz_test, 0);
mpz_init_set_ui(s, 0);
mpz_init_set(nm1, n);
mpz_sub_ui(nm1, nm1, 1);
/***********************************************/
/* Find s and r satisfying: n-1=(2^r)*s, s odd */
r = mpz_scan1(nm1, 0);
mpz_fdiv_q_2exp(s, nm1, r);
/******************************************/
/* Check a^((2^t)*s) mod n for 0 <= t < r */
mpz_powm(mpz_test, a, s, n);
if ( (mpz_cmp_ui(mpz_test, 1) == 0) || (mpz_cmp(mpz_test, nm1) == 0) )
{
mpz_clear(s);
mpz_clear(nm1);
mpz_clear(mpz_test);
return PRP_PRP;
}
while ( --r )
{
/* mpz_test = mpz_test^2%n */
mpz_mul(mpz_test, mpz_test, mpz_test);
mpz_mod(mpz_test, mpz_test, n);
if (mpz_cmp(mpz_test, nm1) == 0)
{
mpz_clear(s);
mpz_clear(nm1);
mpz_clear(mpz_test);
return PRP_PRP;
}
}
mpz_clear(s);
mpz_clear(nm1);
mpz_clear(mpz_test);
return PRP_COMPOSITE;
}/* method mpz_sprp */
int
mpfr_grandom (mpfr_ptr rop1, mpfr_ptr rop2, gmp_randstate_t rstate,
mpfr_rnd_t rnd)
{
int inex1, inex2, s1, s2;
mpz_t x, y, xp, yp, t, a, b, s;
mpfr_t sfr, l, r1, r2;
mpfr_prec_t tprec, tprec0;
inex2 = inex1 = 0;
if (rop2 == NULL) /* only one output requested. */
{
tprec0 = MPFR_PREC (rop1);
}
else
{
tprec0 = MAX (MPFR_PREC (rop1), MPFR_PREC (rop2));
}
tprec0 += 11;
/* We use "Marsaglia polar method" here (cf.
George Marsaglia, Normal (Gaussian) random variables for supercomputers
The Journal of Supercomputing, Volume 5, Number 1, 49–55
DOI: 10.1007/BF00155857).
First we draw uniform x and y in [0,1] using mpz_urandomb (in
fixed precision), and scale them to [-1, 1].
*/
mpz_init (xp);
mpz_init (yp);
mpz_init (x);
mpz_init (y);
mpz_init (t);
mpz_init (s);
mpz_init (a);
mpz_init (b);
mpfr_init2 (sfr, MPFR_PREC_MIN);
mpfr_init2 (l, MPFR_PREC_MIN);
mpfr_init2 (r1, MPFR_PREC_MIN);
if (rop2 != NULL)
mpfr_init2 (r2, MPFR_PREC_MIN);
mpz_set_ui (xp, 0);
mpz_set_ui (yp, 0);
for (;;)
{
tprec = tprec0;
do
{
mpz_urandomb (xp, rstate, tprec);
mpz_urandomb (yp, rstate, tprec);
mpz_mul (a, xp, xp);
mpz_mul (b, yp, yp);
mpz_add (s, a, b);
}
while (mpz_sizeinbase (s, 2) > tprec * 2); /* x^2 + y^2 <= 2^{2tprec} */
for (;;)
{
/* FIXME: compute s as s += 2x + 2y + 2 */
mpz_add_ui (a, xp, 1);
mpz_add_ui (b, yp, 1);
mpz_mul (a, a, a);
mpz_mul (b, b, b);
mpz_add (s, a, b);
if ((mpz_sizeinbase (s, 2) <= 2 * tprec) ||
((mpz_sizeinbase (s, 2) == 2 * tprec + 1) &&
(mpz_scan1 (s, 0) == 2 * tprec)))
goto yeepee;
/* Extend by 32 bits */
mpz_mul_2exp (xp, xp, 32);
mpz_mul_2exp (yp, yp, 32);
mpz_urandomb (x, rstate, 32);
mpz_urandomb (y, rstate, 32);
mpz_add (xp, xp, x);
mpz_add (yp, yp, y);
tprec += 32;
mpz_mul (a, xp, xp);
mpz_mul (b, yp, yp);
mpz_add (s, a, b);
if (mpz_sizeinbase (s, 2) > tprec * 2)
break;
}
}
yeepee:
/* FIXME: compute s with s -= 2x + 2y + 2 */
mpz_mul (a, xp, xp);
mpz_mul (b, yp, yp);
mpz_add (s, a, b);
/* Compute the signs of the output */
mpz_urandomb (x, rstate, 2);
s1 = mpz_tstbit (x, 0);
s2 = mpz_tstbit (x, 1);
for (;;)
{
/* s = xp^2 + yp^2 (loop invariant) */
mpfr_set_prec (sfr, 2 * tprec);
mpfr_set_prec (l, tprec);
mpfr_set_z (sfr, s, MPFR_RNDN); /* exact */
mpfr_mul_2si (sfr, sfr, -2 * tprec, MPFR_RNDN); /* exact */
mpfr_log (l, sfr, MPFR_RNDN);
mpfr_neg (l, l, MPFR_RNDN);
mpfr_mul_2si (l, l, 1, MPFR_RNDN);
mpfr_div (l, l, sfr, MPFR_RNDN);
mpfr_sqrt (l, l, MPFR_RNDN);
mpfr_set_prec (r1, tprec);
mpfr_mul_z (r1, l, xp, MPFR_RNDN);
mpfr_div_2ui (r1, r1, tprec, MPFR_RNDN); /* exact */
if (s1)
mpfr_neg (r1, r1, MPFR_RNDN);
if (MPFR_CAN_ROUND (r1, tprec - 2, MPFR_PREC (rop1), rnd))
{
if (rop2 != NULL)
{
mpfr_set_prec (r2, tprec);
mpfr_mul_z (r2, l, yp, MPFR_RNDN);
mpfr_div_2ui (r2, r2, tprec, MPFR_RNDN); /* exact */
if (s2)
mpfr_neg (r2, r2, MPFR_RNDN);
if (MPFR_CAN_ROUND (r2, tprec - 2, MPFR_PREC (rop2), rnd))
break;
}
else
break;
}
/* Extend by 32 bits */
mpz_mul_2exp (xp, xp, 32);
mpz_mul_2exp (yp, yp, 32);
mpz_urandomb (x, rstate, 32);
mpz_urandomb (y, rstate, 32);
mpz_add (xp, xp, x);
mpz_add (yp, yp, y);
tprec += 32;
mpz_mul (a, xp, xp);
mpz_mul (b, yp, yp);
mpz_add (s, a, b);
}
inex1 = mpfr_set (rop1, r1, rnd);
if (rop2 != NULL)
{
inex2 = mpfr_set (rop2, r2, rnd);
inex2 = mpfr_check_range (rop2, inex2, rnd);
}
inex1 = mpfr_check_range (rop1, inex1, rnd);
if (rop2 != NULL)
mpfr_clear (r2);
mpfr_clear (r1);
mpfr_clear (l);
mpfr_clear (sfr);
mpz_clear (b);
mpz_clear (a);
mpz_clear (s);
mpz_clear (t);
mpz_clear (y);
mpz_clear (x);
mpz_clear (yp);
mpz_clear (xp);
return INEX (inex1, inex2);
}
/* *************************************************************************
* mpz_fibonacci_prp:
* A "Fibonacci pseudoprime" with parameters (P,Q), P > 0, Q=+/-1, is a
* composite n for which V_n == P mod n
* [V is the Lucas V sequence with parameters P,Q]
* *************************************************************************/
int mpz_fibonacci_prp(mpz_t n, long int p, long int q)
{
mpz_t pmodn, zP;
mpz_t vl, vh, ql, qh, tmp; /* used for calculating the Lucas V sequence */
int s = 0, j = 0;
if (p*p-4*q == 0)
return PRP_ERROR;
if (((q != 1) && (q != -1)) || (p <= 0))
return PRP_ERROR;
if (mpz_cmp_ui(n, 2) < 0)
return PRP_COMPOSITE;
if (mpz_divisible_ui_p(n, 2))
{
if (mpz_cmp_ui(n, 2) == 0)
return PRP_PRIME;
else
return PRP_COMPOSITE;
}
mpz_init_set_ui(zP, p);
mpz_init(pmodn);
mpz_mod(pmodn, zP, n);
/* mpz_lucasvmod(res, p, q, n, n); */
mpz_init_set_si(vl, 2);
mpz_init_set_si(vh, p);
mpz_init_set_si(ql, 1);
mpz_init_set_si(qh, 1);
mpz_init_set_si(tmp,0);
s = mpz_scan1(n, 0);
for (j = mpz_sizeinbase(n,2)-1; j >= s+1; j--)
{
/* ql = ql*qh (mod n) */
mpz_mul(ql, ql, qh);
mpz_mod(ql, ql, n);
if (mpz_tstbit(n,j) == 1)
{
/* qh = ql*q */
mpz_mul_si(qh, ql, q);
/* vl = vh*vl - p*ql (mod n) */
mpz_mul(vl, vh, vl);
mpz_mul_si(tmp, ql, p);
mpz_sub(vl, vl, tmp);
mpz_mod(vl, vl, n);
/* vh = vh*vh - 2*qh (mod n) */
mpz_mul(vh, vh, vh);
mpz_mul_si(tmp, qh, 2);
mpz_sub(vh, vh, tmp);
mpz_mod(vh, vh, n);
}
else
{
/* qh = ql */
mpz_set(qh, ql);
/* vh = vh*vl - p*ql (mod n) */
mpz_mul(vh, vh, vl);
mpz_mul_si(tmp, ql, p);
mpz_sub(vh, vh, tmp);
mpz_mod(vh, vh, n);
/* vl = vl*vl - 2*ql (mod n) */
mpz_mul(vl, vl, vl);
mpz_mul_si(tmp, ql, 2);
mpz_sub(vl, vl, tmp);
mpz_mod(vl, vl, n);
}
}
/* ql = ql*qh */
mpz_mul(ql, ql, qh);
/* qh = ql*q */
mpz_mul_si(qh, ql, q);
/* vl = vh*vl - p*ql */
mpz_mul(vl, vh, vl);
mpz_mul_si(tmp, ql, p);
mpz_sub(vl, vl, tmp);
/* ql = ql*qh */
mpz_mul(ql, ql, qh);
for (j = 1; j <= s; j++)
{
/* vl = vl*vl - 2*ql (mod n) */
mpz_mul(vl, vl, vl);
mpz_mul_si(tmp, ql, 2);
mpz_sub(vl, vl, tmp);
mpz_mod(vl, vl, n);
/* ql = ql*ql (mod n) */
mpz_mul(ql, ql, ql);
mpz_mod(ql, ql, n);
}
mpz_mod(vl, vl, n); /* vl contains our return value */
if (mpz_cmp(vl, pmodn) == 0)
{
mpz_clear(zP);
mpz_clear(pmodn);
mpz_clear(vl);
mpz_clear(vh);
mpz_clear(ql);
mpz_clear(qh);
mpz_clear(tmp);
return PRP_PRP;
}
mpz_clear(zP);
mpz_clear(pmodn);
mpz_clear(vl);
mpz_clear(vh);
mpz_clear(ql);
mpz_clear(qh);
mpz_clear(tmp);
return PRP_COMPOSITE;
}/* method mpz_fibonacci_prp */
static PyObject *
GMPY_mpz_is_strong_prp(PyObject *self, PyObject *args)
{
MPZ_Object *a, *n;
PyObject *result = 0;
mpz_t s, nm1, mpz_test;
mp_bitcnt_t r = 0;
if (PyTuple_Size(args) != 2) {
TYPE_ERROR("is_strong_prp() requires 2 integer arguments");
return NULL;
}
n = GMPy_MPZ_From_Integer(PyTuple_GET_ITEM(args, 0), NULL);
a = GMPy_MPZ_From_Integer(PyTuple_GET_ITEM(args, 1), NULL);
if (!a || !n) {
TYPE_ERROR("is_strong_prp() requires 2 integer arguments");
goto cleanup;
}
mpz_init(s);
mpz_init(nm1);
mpz_init(mpz_test);
/* Require a >= 2. */
if (mpz_cmp_ui(a->z, 2) < 0) {
VALUE_ERROR("is_strong_prp() requires 'a' greater than or equal to 2");
goto cleanup;
}
/* Require n > 0. */
if (mpz_sgn(n->z) <= 0) {
VALUE_ERROR("is_strong_prp() requires 'n' be greater than 0");
goto cleanup;
}
/* Check for n == 1 */
if (mpz_cmp_ui(n->z, 1) == 0) {
result = Py_False;
goto cleanup;
}
/* Handle n even. */
if (mpz_divisible_ui_p(n->z, 2)) {
if (mpz_cmp_ui(n->z, 2) == 0)
result = Py_True;
else
result = Py_False;
goto cleanup;
}
/* Check gcd(a,b) */
mpz_gcd(s, n->z, a->z);
if (mpz_cmp_ui(s, 1) > 0) {
VALUE_ERROR("is_strong_prp() requires gcd(n,a) == 1");
goto cleanup;
}
mpz_set(nm1, n->z);
mpz_sub_ui(nm1, nm1, 1);
/* Find s and r satisfying: n-1=(2^r)*s, s odd */
r = mpz_scan1(nm1, 0);
mpz_fdiv_q_2exp(s, nm1, r);
/* Check a^((2^t)*s) mod n for 0 <= t < r */
mpz_powm(mpz_test, a->z, s, n->z);
if ((mpz_cmp_ui(mpz_test, 1) == 0) || (mpz_cmp(mpz_test, nm1) == 0)) {
result = Py_True;
goto cleanup;
}
while (--r) {
/* mpz_test = mpz_test^2%n */
mpz_mul(mpz_test, mpz_test, mpz_test);
mpz_mod(mpz_test, mpz_test, n->z);
if (mpz_cmp(mpz_test, nm1) == 0) {
result = Py_True;
goto cleanup;
}
}
result = Py_False;
cleanup:
Py_XINCREF(result);
mpz_clear(s);
mpz_clear(nm1);
mpz_clear(mpz_test);
Py_XDECREF((PyObject*)a);
Py_XDECREF((PyObject*)n);
return result;
}
/* *******************************************************************************************
* mpz_extrastronglucas_prp:
* Let U_n = LucasU(p,1), V_n = LucasV(p,1), and D=p^2-4.
* An "extra strong Lucas pseudoprime" to the base p is a composite n = (2^r)*s+(D/n), where
* s is odd and (n,2D)=1, such that either U_s == 0 mod n and V_s == +/-2 mod n, or
* V_((2^t)*s) == 0 mod n for some t with 0 <= t < r-1 [(D/n) is the Jacobi symbol]
* *******************************************************************************************/
int mpz_extrastronglucas_prp(mpz_t n, long int p)
{
mpz_t zD;
mpz_t s;
mpz_t nmj; /* n minus jacobi(D/n) */
mpz_t res;
mpz_t uh, vl, vh, ql, qh, tmp; /* these are needed for the LucasU and LucasV part of this function */
long int d = p*p - 4;
long int q = 1;
unsigned long int r = 0;
int ret = 0;
int j = 0;
if (d == 0) /* Does not produce a proper Lucas sequence */
return PRP_ERROR;
if (mpz_cmp_ui(n, 2) < 0)
return PRP_COMPOSITE;
if (mpz_divisible_ui_p(n, 2))
{
if (mpz_cmp_ui(n, 2) == 0)
return PRP_PRIME;
else
return PRP_COMPOSITE;
}
mpz_init_set_si(zD, d);
mpz_init(res);
mpz_mul_ui(res, zD, 2);
mpz_gcd(res, res, n);
if ((mpz_cmp(res, n) != 0) && (mpz_cmp_ui(res, 1) > 0))
{
mpz_clear(zD);
mpz_clear(res);
return PRP_COMPOSITE;
}
mpz_init(s);
mpz_init(nmj);
/* nmj = n - (D/n), where (D/n) is the Jacobi symbol */
mpz_set(nmj, n);
ret = mpz_jacobi(zD, n);
if (ret == -1)
mpz_add_ui(nmj, nmj, 1);
else if (ret == 1)
mpz_sub_ui(nmj, nmj, 1);
r = mpz_scan1(nmj, 0);
mpz_fdiv_q_2exp(s, nmj, r);
/* make sure that either (U_s == 0 mod n and V_s == +/-2 mod n), or */
/* V_((2^t)*s) == 0 mod n for some t with 0 <= t < r-1 */
mpz_init_set_si(uh, 1);
mpz_init_set_si(vl, 2);
mpz_init_set_si(vh, p);
mpz_init_set_si(ql, 1);
mpz_init_set_si(qh, 1);
mpz_init_set_si(tmp,0);
for (j = mpz_sizeinbase(s,2)-1; j >= 1; j--)
{
/* ql = ql*qh (mod n) */
mpz_mul(ql, ql, qh);
mpz_mod(ql, ql, n);
if (mpz_tstbit(s,j) == 1)
{
/* qh = ql*q */
mpz_mul_si(qh, ql, q);
/* uh = uh*vh (mod n) */
mpz_mul(uh, uh, vh);
mpz_mod(uh, uh, n);
/* vl = vh*vl - p*ql (mod n) */
mpz_mul(vl, vh, vl);
mpz_mul_si(tmp, ql, p);
mpz_sub(vl, vl, tmp);
mpz_mod(vl, vl, n);
/* vh = vh*vh - 2*qh (mod n) */
mpz_mul(vh, vh, vh);
mpz_mul_si(tmp, qh, 2);
mpz_sub(vh, vh, tmp);
mpz_mod(vh, vh, n);
}
else
{
/* qh = ql */
mpz_set(qh, ql);
/* uh = uh*vl - ql (mod n) */
mpz_mul(uh, uh, vl);
mpz_sub(uh, uh, ql);
mpz_mod(uh, uh, n);
/* vh = vh*vl - p*ql (mod n) */
mpz_mul(vh, vh, vl);
mpz_mul_si(tmp, ql, p);
mpz_sub(vh, vh, tmp);
mpz_mod(vh, vh, n);
/* vl = vl*vl - 2*ql (mod n) */
mpz_mul(vl, vl, vl);
mpz_mul_si(tmp, ql, 2);
mpz_sub(vl, vl, tmp);
mpz_mod(vl, vl, n);
}
}
/* ql = ql*qh */
mpz_mul(ql, ql, qh);
/* qh = ql*q */
mpz_mul_si(qh, ql, q);
/* uh = uh*vl - ql */
mpz_mul(uh, uh, vl);
mpz_sub(uh, uh, ql);
/* vl = vh*vl - p*ql */
mpz_mul(vl, vh, vl);
mpz_mul_si(tmp, ql, p);
mpz_sub(vl, vl, tmp);
/* ql = ql*qh */
mpz_mul(ql, ql, qh);
mpz_mod(uh, uh, n);
mpz_mod(vl, vl, n);
/* tmp = n-2, for the following comparison */
mpz_sub_ui(tmp, n, 2);
/* uh contains LucasU_s and vl contains LucasV_s */
if (((mpz_cmp_ui(uh, 0) == 0) && ((mpz_cmp(vl, tmp) == 0) || (mpz_cmp_si(vl, 2) == 0)))
|| (mpz_cmp_ui(vl, 0) == 0))
{
mpz_clear(zD);
mpz_clear(s);
mpz_clear(nmj);
mpz_clear(res);
mpz_clear(uh);
mpz_clear(vl);
mpz_clear(vh);
mpz_clear(ql);
mpz_clear(qh);
mpz_clear(tmp);
return PRP_PRP;
}
for (j = 1; j < r-1; j++)
{
/* vl = vl*vl - 2*ql (mod n) */
mpz_mul(vl, vl, vl);
mpz_mul_si(tmp, ql, 2);
mpz_sub(vl, vl, tmp);
mpz_mod(vl, vl, n);
/* ql = ql*ql (mod n) */
mpz_mul(ql, ql, ql);
mpz_mod(ql, ql, n);
if (mpz_cmp_ui(vl, 0) == 0)
{
mpz_clear(zD);
mpz_clear(s);
mpz_clear(nmj);
mpz_clear(res);
mpz_clear(uh);
mpz_clear(vl);
mpz_clear(vh);
mpz_clear(ql);
mpz_clear(qh);
mpz_clear(tmp);
return PRP_PRP;
}
}
mpz_clear(zD);
mpz_clear(s);
mpz_clear(nmj);
mpz_clear(res);
mpz_clear(uh);
mpz_clear(vl);
mpz_clear(vh);
mpz_clear(ql);
mpz_clear(qh);
mpz_clear(tmp);
return PRP_COMPOSITE;
}/* method mpz_extrastronglucas_prp */
int
mpc_log10 (mpc_ptr rop, mpc_srcptr op, mpc_rnd_t rnd)
{
int ok = 0, loops = 0, check_exact = 0, special_re, special_im,
inex, inex_re, inex_im;
mpfr_prec_t prec;
mpfr_t log10;
mpc_t log;
mpfr_init2 (log10, 2);
mpc_init2 (log, 2);
prec = MPC_MAX_PREC (rop);
/* compute log(op)/log(10) */
while (ok == 0) {
loops ++;
prec += (loops <= 2) ? mpc_ceil_log2 (prec) + 4 : prec / 2;
mpfr_set_prec (log10, prec);
mpc_set_prec (log, prec);
inex = mpc_log (log, op, rnd); /* error <= 1 ulp */
if (!mpfr_number_p (mpc_imagref (log))
|| mpfr_zero_p (mpc_imagref (log))) {
/* no need to divide by log(10) */
special_im = 1;
ok = 1;
}
else {
special_im = 0;
mpfr_const_log10 (log10);
mpfr_div (mpc_imagref (log), mpc_imagref (log), log10, MPFR_RNDN);
ok = mpfr_can_round (mpc_imagref (log), prec - 2,
MPFR_RNDN, MPFR_RNDZ,
MPC_PREC_IM(rop) + (MPC_RND_IM (rnd) == MPFR_RNDN));
}
if (ok) {
if (!mpfr_number_p (mpc_realref (log))
|| mpfr_zero_p (mpc_realref (log)))
special_re = 1;
else {
special_re = 0;
if (special_im)
/* log10 not yet computed */
mpfr_const_log10 (log10);
mpfr_div (mpc_realref (log), mpc_realref (log), log10, MPFR_RNDN);
/* error <= 24/7 ulp < 4 ulp for prec >= 4, see algorithms.tex */
ok = mpfr_can_round (mpc_realref (log), prec - 2,
MPFR_RNDN, MPFR_RNDZ,
MPC_PREC_RE(rop) + (MPC_RND_RE (rnd) == MPFR_RNDN));
}
/* Special code to deal with cases where the real part of log10(x+i*y)
is exact, like x=3 and y=1. Since Re(log10(x+i*y)) = log10(x^2+y^2)/2
this happens whenever x^2+y^2 is a nonnegative power of 10.
Indeed x^2+y^2 cannot equal 10^(a/2^b) for a, b integers, a odd, b>0,
since x^2+y^2 is rational, and 10^(a/2^b) is irrational.
Similarly, for b=0, x^2+y^2 cannot equal 10^a for a < 0 since x^2+y^2
is a rational with denominator a power of 2.
Now let x^2+y^2 = 10^s. Without loss of generality we can assume
x = u/2^e and y = v/2^e with u, v, e integers: u^2+v^2 = 10^s*2^(2e)
thus u^2+v^2 = 0 mod 2^(2e). By recurrence on e, necessarily
u = v = 0 mod 2^e, thus x and y are necessarily integers.
*/
if (!ok && !check_exact && mpfr_integer_p (mpc_realref (op)) &&
mpfr_integer_p (mpc_imagref (op))) {
mpz_t x, y;
unsigned long s, v;
check_exact = 1;
mpz_init (x);
mpz_init (y);
mpfr_get_z (x, mpc_realref (op), MPFR_RNDN); /* exact */
mpfr_get_z (y, mpc_imagref (op), MPFR_RNDN); /* exact */
mpz_mul (x, x, x);
mpz_mul (y, y, y);
mpz_add (x, x, y); /* x^2+y^2 */
v = mpz_scan1 (x, 0);
/* if x = 10^s then necessarily s = v */
s = mpz_sizeinbase (x, 10);
/* since s is either the number of digits of x or one more,
then x = 10^(s-1) or 10^(s-2) */
if (s == v + 1 || s == v + 2) {
mpz_div_2exp (x, x, v);
mpz_ui_pow_ui (y, 5, v);
if (mpz_cmp (y, x) == 0) {
/* Re(log10(x+i*y)) is exactly v/2
we reset the precision of Re(log) so that v can be
represented exactly */
mpfr_set_prec (mpc_realref (log),
sizeof(unsigned long)*CHAR_BIT);
mpfr_set_ui_2exp (mpc_realref (log), v, -1, MPFR_RNDN);
/* exact */
ok = 1;
}
}
mpz_clear (x);
mpz_clear (y);
}
}
}
inex_re = mpfr_set (mpc_realref(rop), mpc_realref (log), MPC_RND_RE (rnd));
if (special_re)
inex_re = MPC_INEX_RE (inex);
/* recover flag from call to mpc_log above */
inex_im = mpfr_set (mpc_imagref(rop), mpc_imagref (log), MPC_RND_IM (rnd));
if (special_im)
inex_im = MPC_INEX_IM (inex);
mpfr_clear (log10);
mpc_clear (log);
return MPC_INEX(inex_re, inex_im);
}
