ecl_uint64_t
ecl_to_uint64_t(cl_object x) {
if (!ecl_minusp(x)) {
if (ECL_FIXNUMP(x)) {
return (ecl_uint64_t)ecl_fixnum(x);
} else if (!ECL_BIGNUMP(x)) {
(void)0;
} else if (mpz_fits_ulong_p(x->big.big_num)) {
return (ecl_uint64_t)mpz_get_ui(x->big.big_num);
} else {
cl_object copy = _ecl_big_register0();
mpz_fdiv_q_2exp(copy->big.big_num, x->big.big_num, 32);
if (mpz_fits_ulong_p(copy->big.big_num)) {
volatile ecl_uint64_t output;
output = (ecl_uint64_t)mpz_get_ui(copy->big.big_num);
output = (output << 32) +
(ecl_uint64_t)mpz_get_ui(x->big.big_num);
return output;
}
}
}
FEwrong_type_argument(cl_list(3,ECL_SYM("INTEGER",437),ecl_make_fixnum(0),
ecl_one_minus(ecl_ash(ecl_make_fixnum(1), 64))),
x);
}
ecl_ulong_long_t
ecl_to_ulong_long(cl_object x) {
if (!ecl_minusp(x)) {
if (ECL_FIXNUMP(x)) {
return (ecl_ulong_long_t)ecl_fixnum(x);
} else if (!ECL_BIGNUMP(x)) {
(void)0;
} else if (mpz_fits_ulong_p(x->big.big_num)) {
return (ecl_ulong_long_t)mpz_get_ui(x->big.big_num);
} else {
cl_object copy = _ecl_big_register0();
int i = ECL_LONG_LONG_BITS - FIXNUM_BITS;
mpz_fdiv_q_2exp(copy->bit.big_num, x->big.big_num, i);
if (mpz_fits_ulong_p(copy->big.big_num)) {
volatile ecl_ulong_long_t output;
output = mpz_get_ui(copy->big.big_num);
for (i -= FIXNUM_BITS; i; i-= FIXNUM_BITS) {
output = (output << FIXNUM_BITS);
output += mpz_get_ui(x->big.big_num);
}
return output;
}
}
}
FEwrong_type_argument(cl_list(3,ECL_SYM("INTEGER",437),ecl_make_fixnum(0),
ecl_one_minus(ecl_ash(ecl_make_fixnum(1),
ECL_LONG_LONG_BITS))),
x);
}
void
check_all (mpz_ptr w, mpz_ptr x, mpz_ptr y)
{
int swap, wneg, xneg, yneg;
MPZ_CHECK_FORMAT (w);
MPZ_CHECK_FORMAT (x);
MPZ_CHECK_FORMAT (y);
for (swap = 0; swap < 2; swap++)
{
for (wneg = 0; wneg < 2; wneg++)
{
for (xneg = 0; xneg < 2; xneg++)
{
for (yneg = 0; yneg < 2; yneg++)
{
check_one (w, x, y);
if (mpz_fits_ulong_p (y))
check_one_ui (w, x, mpz_get_ui (y));
mpz_neg (y, y);
}
mpz_neg (x, x);
}
mpz_neg (w, w);
}
mpz_swap (x, y);
}
}
/* Called when s is supposed to be floor(root(u,z)), and r = u - s^z */
static int
rootrem_valid_p (const mpz_t u, const mpz_t s, const mpz_t r, unsigned long z)
{
mpz_t t;
mpz_init (t);
if (mpz_fits_ulong_p (s))
mpz_ui_pow_ui (t, mpz_get_ui (s), z);
else
mpz_pow_ui (t, s, z);
mpz_sub (t, u, t);
if (mpz_sgn (t) != mpz_sgn(u) || mpz_cmp (t, r) != 0)
{
mpz_clear (t);
return 0;
}
if (mpz_sgn (s) > 0)
mpz_add_ui (t, s, 1);
else
mpz_sub_ui (t, s, 1);
mpz_pow_ui (t, t, z);
if (mpz_cmpabs (t, u) <= 0)
{
mpz_clear (t);
return 0;
}
mpz_clear (t);
return 1;
}
void
check_one (mpz_srcptr a, mpz_srcptr d, int want)
{
int got;
if (mpz_fits_ulong_p (d))
{
unsigned long u = mpz_get_ui (d);
got = (mpz_divisible_ui_p (a, u) != 0);
if (want != got)
{
printf ("mpz_divisible_ui_p wrong\n");
printf (" expected %d got %d\n", want, got);
mpz_trace (" a", a);
printf (" d=%lu\n", u);
mp_trace_base = -16;
mpz_trace (" a", a);
printf (" d=0x%lX\n", u);
abort ();
}
}
got = (mpz_divisible_p (a, d) != 0);
if (want != got)
{
printf ("mpz_divisible_p wrong\n");
printf (" expected %d got %d\n", want, got);
mpz_trace (" a", a);
mpz_trace (" d", d);
mp_trace_base = -16;
mpz_trace (" a", a);
mpz_trace (" d", d);
abort ();
}
}
inline unsigned int check_ub32(Value value)
{
#ifdef __x86_64__
if (fixnump(value))
{
long n = xlong(value);
if (n >= 0 && n < 4294967296)
return (unsigned int) n;
}
#else
// 32-bit Lisp
if (fixnump(value))
{
long n = xlong(value);
if (n >= 0)
return (unsigned int) n;
}
else if (bignump(value))
{
Bignum * b = the_bignum(value);
if (mpz_sgn(b->_z) >= 0 && mpz_fits_ulong_p(b->_z))
return mpz_get_ui(b->_z);
}
#endif
signal_type_error(value, UB32_TYPE);
// not reached
return 0;
}
num_t
num_int_one_op(optype_t op_type, num_t a)
{
num_t r;
r = num_new_z(N_TEMP, NULL);
a = num_new_z(N_TEMP, a);
switch (op_type) {
case OP_UINV:
mpz_com(Z(r), Z(a));
break;
case OP_FAC:
if (!mpz_fits_ulong_p(Z(a))) {
yyxerror
("Argument to factorial needs to fit into an unsigned long C datatype");
return NULL;
}
mpz_fac_ui(Z(r), mpz_get_ui(Z(a)));
break;
default:
yyxerror("Unknown op in num_int_one_op");
}
return r;
}
num_t
num_int_two_op(optype_t op_type, num_t a, num_t b)
{
num_t r;
r = num_new_z(N_TEMP, NULL);
a = num_new_z(N_TEMP, a);
b = num_new_z(N_TEMP, b);
switch (op_type) {
case OP_AND:
mpz_and(Z(r), Z(a), Z(b));
break;
case OP_OR:
mpz_ior(Z(r), Z(a), Z(b));
break;
case OP_XOR:
mpz_xor(Z(r), Z(a), Z(b));
break;
case OP_SHR:
if (!mpz_fits_ulong_p(Z(b))) {
yyxerror
("Second argument to shift needs to fit into an unsigned long C datatype");
return NULL;
}
mpz_fdiv_q_2exp(Z(r), Z(a), mpz_get_ui(Z(b)));
break;
case OP_SHL:
if (!mpz_fits_ulong_p(Z(b))) {
yyxerror
("Second argument to shift needs to fit into an unsigned long C datatype");
return NULL;
}
mpz_mul_2exp(Z(r), Z(a), mpz_get_ui(Z(b)));
break;
default:
yyxerror("Unknown op in num_int_two_op");
}
return r;
}
void
check_one (mpz_srcptr a, mpz_srcptr c, mpz_srcptr d, int want)
{
int got;
int swap;
for (swap = 0; swap <= 1; swap++)
{
got = (mpz_congruent_p (a, c, d) != 0);
if (want != got)
{
printf ("mpz_congruent_p wrong\n");
printf (" expected %d got %d\n", want, got);
mpz_trace (" a", a);
mpz_trace (" c", c);
mpz_trace (" d", d);
mp_trace_base = -16;
mpz_trace (" a", a);
mpz_trace (" c", c);
mpz_trace (" d", d);
abort ();
}
if (mpz_fits_ulong_p (c) && mpz_fits_ulong_p (d))
{
unsigned long uc = mpz_get_ui (c);
unsigned long ud = mpz_get_ui (d);
got = (mpz_congruent_ui_p (a, uc, ud) != 0);
if (want != got)
{
printf ("mpz_congruent_ui_p wrong\n");
printf (" expected %d got %d\n", want, got);
mpz_trace (" a", a);
printf (" c=%lu\n", uc);
printf (" d=%lu\n", ud);
mp_trace_base = -16;
mpz_trace (" a", a);
printf (" c=0x%lX\n", uc);
printf (" d=0x%lX\n", ud);
abort ();
}
}
MPZ_SRCPTR_SWAP (a, c);
}
}
void
testmain (int argc, char **argv)
{
unsigned i;
mpz_t a, b, res, ref;
mpz_init (a);
mpz_init (b);
mpz_init_set_ui (res, 5);
mpz_init (ref);
for (i = 0; i < COUNT; i++)
{
mini_random_op3 (OP_MUL, MAXBITS, a, b, ref);
if (i & 1) {
mpz_add (ref, ref, res);
if (mpz_fits_ulong_p (b))
mpz_addmul_ui (res, a, mpz_get_ui (b));
else
mpz_addmul (res, a, b);
} else {
mpz_sub (ref, res, ref);
if (mpz_fits_ulong_p (b))
mpz_submul_ui (res, a, mpz_get_ui (b));
else
mpz_submul (res, a, b);
}
if (mpz_cmp (res, ref))
{
if (i & 1)
fprintf (stderr, "mpz_addmul failed:\n");
else
fprintf (stderr, "mpz_submul failed:\n");
dump ("a", a);
dump ("b", b);
dump ("r", res);
dump ("ref", ref);
abort ();
}
}
mpz_clear (a);
mpz_clear (b);
mpz_clear (res);
mpz_clear (ref);
}
unsigned long to_ulong(obj_t *o) {
mpz_t *x = to_mpz(o);
unsigned int r = 0;
if (mpz_fits_ulong_p(*x)) {
r = mpz_get_ui(*x);
} else {
error("Argument too big.\n");
}
return r;
}
static uint64_t asUnsignedLong(BoxedLong* self) {
assert(self->cls == long_cls);
if (mpz_sgn(self->n) == -1)
raiseExcHelper(OverflowError, "can't convert negative value to unsigned long");
if (!mpz_fits_ulong_p(self->n))
raiseExcHelper(OverflowError, "long int too large to convert");
return mpz_get_ui(self->n);
}
void field_init_fp(field_ptr f, mpz_t modulus) {
if (mpz_fits_ulong_p(modulus)) {
// If this case mattered, I'd have written a F_p implementation specialized
// for moduli that fits into machine words.
field_init_naive_fp(f, modulus);
} else {
if (mpz_odd_p(modulus)) {
option_fpinit(f, modulus);
} else {
// montfp.c only supports odd moduli.
field_init_faster_fp(f, modulus);
}
}
}
void
check_one (mpz_srcptr want, mpz_srcptr base, unsigned long exp)
{
mpz_t got;
mpz_init (got);
MPZ_CHECK_FORMAT (want);
mpz_pow_ui (got, base, exp);
if (mpz_cmp (got, want))
{
printf ("mpz_pow_ui wrong\n");
mpz_trace (" base", base);
printf (" exp = %lu (0x%lX)\n", exp, exp);
mpz_trace (" got ", got);
mpz_trace (" want", want);
abort ();
}
mpz_set (got, base);
mpz_pow_ui (got, got, exp);
if (mpz_cmp (got, want))
{
printf ("mpz_pow_ui wrong\n");
mpz_trace (" base", base);
printf (" exp = %lu (0x%lX)\n", exp, exp);
mpz_trace (" got ", got);
mpz_trace (" want", want);
abort ();
}
if (mpz_fits_ulong_p (base))
{
unsigned long base_u = mpz_get_ui (base);
mpz_ui_pow_ui (got, base_u, exp);
if (mpz_cmp (got, want))
{
printf ("mpz_ui_pow_ui wrong\n");
printf (" base=%lu (0x%lX)\n", base_u, base_u);
printf (" exp = %lu (0x%lX)\n", exp, exp);
mpz_trace (" got ", got);
mpz_trace (" want", want);
abort ();
}
}
mpz_clear (got);
}
void field_init_tiny_fp(field_ptr f, mpz_t prime) {
pbc_mpui *p;
PBC_ASSERT(mpz_fits_ulong_p(prime), "modulus too big");
field_init(f);
f->init = fp_init;
f->clear = fp_clear;
f->set_si = fp_set_si;
f->set_mpz = fp_set_mpz;
f->out_str = fp_out_str;
f->add = fp_add;
f->sub = fp_sub;
f->set = fp_set;
f->mul = fp_mul;
f->mul_si = fp_mul_si;
f->square = fp_square;
f->doub = fp_double;
f->pow_mpz = fp_pow_mpz;
f->neg = fp_neg;
f->cmp = fp_cmp;
f->sign = fp_sgn_odd;
f->invert = fp_invert;
f->random = fp_random;
f->from_hash = fp_from_hash;
f->is1 = fp_is1;
f->is0 = fp_is0;
f->set0 = fp_set0;
f->set1 = fp_set1;
f->is_sqr = fp_is_sqr;
f->sqrt = element_tonelli;
f->field_clear = fp_field_clear;
f->to_bytes = fp_to_bytes;
f->from_bytes = fp_from_bytes;
f->to_mpz = fp_to_mpz;
p = f->data = pbc_malloc(sizeof(pbc_mpui));
*p = mpz_get_ui(prime);
{
pbc_mpui l = 255;
f->fixed_length_in_bytes = 1;
while (l < *p) {
f->fixed_length_in_bytes++;
l <<= 8;
l += 255;
}
}
mpz_set(f->order, prime);
}
cl_index
fixnnint(cl_object x)
{
if (ECL_FIXNUMP(x)) {
cl_fixnum i = ecl_fixnum(x);
if (i >= 0)
return i;
} else if (ECL_BIGNUMP(x)) {
if (mpz_fits_ulong_p(x->big.big_num)) {
return mpz_get_ui(x->big.big_num);
}
}
FEwrong_type_argument(cl_list(3, ECL_SYM("INTEGER",437), ecl_make_fixnum(0),
ecl_make_fixnum(MOST_POSITIVE_FIXNUM)),
x);
}
unsigned long vanilla::int_object_to_unsigned_long(object::ptr const& obj)
{
if(obj->type_id() != OBJECT_ID_INT)
{
BOOST_THROW_EXCEPTION(error::bad_cast_error()
<< error::first_operand(obj)
<< error::cast_target_name("int"));
}
mpz_t& mpz = static_cast<int_object const*>(obj.get())->value().mpz();
if(!mpz_fits_ulong_p(mpz) || mpz_sgn(mpz) == -1)
{
BOOST_THROW_EXCEPTION(error::integer_conversion_overflow_error()
<< error::first_operand(obj)
<< error::integer_conversion_target_type("unsigned long"));
}
return mpz_get_ui(mpz);
}
void field_init_fast_fp(field_ptr f, mpz_t prime) {
PBC_ASSERT(!mpz_fits_ulong_p(prime), "modulus too small");
fp_field_data_ptr p;
field_init(f);
f->init = fp_init;
f->clear = fp_clear;
f->set_si = fp_set_si;
f->set_mpz = fp_set_mpz;
f->out_str = fp_out_str;
f->add = fp_add;
f->sub = fp_sub;
f->set = fp_set;
f->mul = fp_mul;
f->mul_si = fp_mul_si;
f->square = fp_square;
f->doub = fp_double;
f->halve = fp_halve;
f->pow_mpz = fp_pow_mpz;
f->neg = fp_neg;
f->cmp = fp_cmp;
f->sign = mpz_odd_p(prime) ? fp_sgn_odd : fp_sgn_even;
f->invert = fp_invert;
f->random = fp_random;
f->from_hash = fp_from_hash;
f->is1 = fp_is1;
f->is0 = fp_is0;
f->set0 = fp_set0;
f->set1 = fp_set1;
f->is_sqr = fp_is_sqr;
f->sqrt = element_tonelli;
f->field_clear = fp_field_clear;
f->to_bytes = fp_to_bytes;
f->from_bytes = fp_from_bytes;
f->to_mpz = fp_to_mpz;
p = f->data = pbc_malloc(sizeof(fp_field_data_t));
p->limbs = mpz_size(prime);
p->bytes = p->limbs * sizeof(mp_limb_t);
p->primelimbs = pbc_malloc(p->bytes);
mpz_export(p->primelimbs, &p->limbs, -1, sizeof(mp_limb_t), 0, 0, prime);
mpz_set(f->order, prime);
f->fixed_length_in_bytes = (mpz_sizeinbase(prime, 2) + 7) / 8;
}
unsigned long int
mpz_gcd_ui (mpz_ptr w, mpz_srcptr u, unsigned long int v)
{
mp_size_t un;
mp_limb_t res;
#if BITS_PER_ULONG > GMP_NUMB_BITS /* avoid warnings about shift amount */
if (v > GMP_NUMB_MAX)
{
mpz_t vz;
mp_limb_t vlimbs[2];
vlimbs[0] = v & GMP_NUMB_MASK;
vlimbs[1] = v >> GMP_NUMB_BITS;
PTR(vz) = vlimbs;
SIZ(vz) = 2;
mpz_gcd (w, u, vz);
/* because v!=0 we will have w<=v hence fitting a ulong */
ASSERT (mpz_fits_ulong_p (w));
return mpz_get_ui (w);
}
void
check_all_inplace (mpz_ptr w, mpz_ptr y)
{
int wneg, yneg;
MPZ_CHECK_FORMAT (w);
MPZ_CHECK_FORMAT (y);
for (wneg = 0; wneg < 2; wneg++)
{
for (yneg = 0; yneg < 2; yneg++)
{
check_one_inplace (w, y);
if (mpz_fits_ulong_p (y))
check_one_ui_inplace (w, mpz_get_ui (y));
mpz_neg (y, y);
}
mpz_neg (w, w);
}
}
/* read number to factor from 'params' file */
void
read_params (mpz_t N, unsigned long *B, unsigned long *LP, char *params)
{
FILE *fp;
mpz_t lp, bb;
fp = fopen (params, "r");
if (mpz_inp_str (N, fp, 10) == 0)
{
fprintf (stderr, "Error, cannot read number to factor\n");
exit (1);
}
if (fscanf (fp, "%lu", B) == EOF)
{
fprintf (stderr, "Error, cannot read factor base bound\n");
exit (1);
}
mpz_init (lp);
mpz_init (bb);
if (mpz_inp_str (lp, fp, 10) == 0)
{
mpz_set_ui (lp, *B);
mpz_mul_ui (lp, lp, 128);
}
/* LP must fit in a "unsigned long" (so that large primes can be
represented by this type), and be less than B^2 (so that when
a residue is less than LP, it is necessarily prime */
mpz_ui_pow_ui (bb, *B, 2);
if (mpz_fits_ulong_p (lp) == 0 || mpz_cmp (lp, bb) > 0)
{
fprintf (stderr, "Error, large prime bound is too large\n");
exit (1);
}
*LP = mpz_get_ui (lp);
mpz_clear (lp);
mpz_clear (bb);
fclose (fp);
}
void
one_test (mpz_t op1, mpz_t op2, mpz_t ref, int i)
{
/*
printf ("%ld %ld %ld\n", SIZ (op1), SIZ (op2), SIZ (ref));
fflush (stdout);
*/
/*
fprintf (stderr, "op1="); debug_mp (op1, -16);
fprintf (stderr, "op2="); debug_mp (op2, -16);
*/
mpz_gcdext (gcd1, s, NULL, op1, op2);
if (ref && mpz_cmp (ref, gcd1) != 0)
{
fprintf (stderr, "ERROR in test %d\n", i);
fprintf (stderr, "mpz_gcdext returned incorrect result\n");
fprintf (stderr, "op1="); debug_mp (op1, -16);
fprintf (stderr, "op2="); debug_mp (op2, -16);
fprintf (stderr, "expected result:\n"); debug_mp (ref, -16);
fprintf (stderr, "mpz_gcdext returns:\n");debug_mp (gcd1, -16);
abort ();
}
if (!gcdext_valid_p(op1, op2, gcd1, s))
{
fprintf (stderr, "ERROR in test %d\n", i);
fprintf (stderr, "mpz_gcdext returned invalid result\n");
fprintf (stderr, "op1="); debug_mp (op1, -16);
fprintf (stderr, "op2="); debug_mp (op2, -16);
fprintf (stderr, "mpz_gcdext returns:\n");debug_mp (gcd1, -16);
abort ();
}
mpz_gcd (gcd2, op1, op2);
if (mpz_cmp (gcd2, gcd1) != 0)
{
fprintf (stderr, "ERROR in test %d\n", i);
fprintf (stderr, "mpz_gcd returned incorrect result\n");
fprintf (stderr, "op1="); debug_mp (op1, -16);
fprintf (stderr, "op2="); debug_mp (op2, -16);
fprintf (stderr, "expected result:\n"); debug_mp (gcd1, -16);
fprintf (stderr, "mpz_gcd returns:\n"); debug_mp (gcd2, -16);
abort ();
}
/* This should probably move to t-gcd_ui.c */
if (mpz_fits_ulong_p (op1) || mpz_fits_ulong_p (op2))
{
if (mpz_fits_ulong_p (op1))
mpz_gcd_ui (gcd2, op2, mpz_get_ui (op1));
else
mpz_gcd_ui (gcd2, op1, mpz_get_ui (op2));
if (mpz_cmp (gcd2, gcd1))
{
fprintf (stderr, "ERROR in test %d\n", i);
fprintf (stderr, "mpz_gcd_ui returned incorrect result\n");
fprintf (stderr, "op1="); debug_mp (op1, -16);
fprintf (stderr, "op2="); debug_mp (op2, -16);
fprintf (stderr, "expected result:\n"); debug_mp (gcd1, -16);
fprintf (stderr, "mpz_gcd_ui returns:\n"); debug_mp (gcd2, -16);
abort ();
}
}
mpz_gcdext (gcd2, temp1, temp2, op1, op2);
mpz_mul (temp1, temp1, op1);
mpz_mul (temp2, temp2, op2);
mpz_add (temp1, temp1, temp2);
if (mpz_cmp (gcd1, gcd2) != 0
|| mpz_cmp (gcd2, temp1) != 0)
{
fprintf (stderr, "ERROR in test %d\n", i);
fprintf (stderr, "mpz_gcdext returned incorrect result\n");
fprintf (stderr, "op1="); debug_mp (op1, -16);
fprintf (stderr, "op2="); debug_mp (op2, -16);
fprintf (stderr, "expected result:\n"); debug_mp (gcd1, -16);
fprintf (stderr, "mpz_gcdext returns:\n");debug_mp (gcd2, -16);
abort ();
}
}
void field_init_mont_fp(field_ptr f, mpz_t prime) {
PBC_ASSERT(!mpz_fits_ulong_p(prime), "modulus too small");
fptr p;
field_init(f);
f->init = fp_init;
f->clear = fp_clear;
f->set_si = fp_set_si;
f->set_mpz = fp_set_mpz;
f->out_str = fp_out_str;
f->snprint = fp_snprint;
f->set_str = fp_set_str;
f->add = fp_add;
f->sub = fp_sub;
f->set = fp_set;
f->mul = fp_mul;
f->doub = fp_double;
f->halve = fp_halve;
f->pow_mpz = fp_pow_mpz;
f->neg = fp_neg;
f->sign = fp_sgn_odd;
f->cmp = fp_cmp;
f->invert = fp_invert;
f->random = fp_random;
f->from_hash = fp_from_hash;
f->is1 = fp_is1;
f->is0 = fp_is0;
f->set0 = fp_set0;
f->set1 = fp_set1;
f->is_sqr = fp_is_sqr;
f->sqrt = element_tonelli;
f->field_clear = fp_field_clear;
f->to_bytes = fp_to_bytes;
f->from_bytes = fp_from_bytes;
f->to_mpz = fp_to_mpz;
f->out_info = fp_out_info;
// Initialize per-field data specific to this implementation.
f->data = pbc_malloc(sizeof(*p));
p = (fptr)f->data;
p->limbs = mpz_size(prime);
p->bytes = p->limbs * sizeof(mp_limb_t);
p->primelimbs = (mp_limb_t*)pbc_malloc(p->bytes);
mpz_export(p->primelimbs, &p->limbs, -1, sizeof(mp_limb_t), 0, 0, prime);
mpz_set(f->order, prime);
f->fixed_length_in_bytes = (mpz_sizeinbase(prime, 2) + 7) / 8;
// Compute R, R3 and negpinv.
mpz_t z;
mpz_init(z);
p->R = (mp_limb_t*)pbc_malloc(p->bytes);
p->R3 = (mp_limb_t*)pbc_malloc(p->bytes);
mpz_setbit(z, p->bytes * 8);
mpz_mod(z, z, prime);
set_limbs(p->R, z, p->limbs);
mpz_powm_ui(z, z, 3, prime);
set_limbs(p->R3, z, p->limbs);
mpz_set_ui(z, 0);
// Algorithm II.5 in Blake, Seroussi and Smart is better but this suffices
// since we're only doing it once.
mpz_setbit(z, p->bytes * 8);
mpz_invert(z, prime, z);
#ifdef _MSC_VER // for VC++ compatibility
int tmp = mpz_get_ui(z);
p->negpinv = -tmp;
#else
p->negpinv = -mpz_get_ui(z);
#endif
mpz_clear(z);
}
/* This is the custom formatter.
* Note that this deals with grouping unlike the gmp_*printf() calls */
static int ex__usr_mpz_cb(Vstr_base *base, size_t pos, Vstr_fmt_spec *spec,
char fmt, const mpz_t val)
{
unsigned int nb = 10;
int flags = VSTR_FLAG_SC_FMT_CB_BEG_OBJ_NUM; /* it's a number */
size_t len = 0;
int ret = FALSE;
char ui_buf[(sizeof(unsigned long) * CHAR_BIT) + 1];
char *buf = NULL;
char *out_buf = ui_buf;
switch (fmt)
{
case 'd': break;
case 'x': nb = 16; flags |= VSTR_FLAG_SC_FMT_CB_BEG_OBJ_HEXNUM_L; break;
case 'o': nb = 8; flags |= VSTR_FLAG_SC_FMT_CB_BEG_OBJ_OCTNUM; break;
case 'b': nb = 2; flags |= VSTR_FLAG_SC_FMT_CB_BEG_OBJ_BINNUM_L; break;
default: ASSERT(FALSE); break;
}
if (mpz_sgn(val) == -1)
flags |= VSTR_FLAG_SC_FMT_CB_BEG_OBJ_NEG;
if (mpz_fits_ulong_p(val))
len = vstr_sc_conv_num_ulong(ui_buf, sizeof(ui_buf), mpz_get_ui(val),
"0123456789abcdef", nb);
else
{
len = mpz_sizeinbase(val, nb);
out_buf = buf = mpz_get_str(NULL, nb, val); /* dies on malloc error */
if (mpz_sgn(val) == -1) ++out_buf;
if (!out_buf[len - 1]) --len; /* see documentation for mpz_sizeinbase() */
}
ASSERT(strlen(out_buf) == len);
if (!vstr_sc_fmt_cb_beg(base, &pos, spec, &len, flags))
goto mem_fail;
if (spec->fmt_quote) /* add number including grouping */
ret = vstr_sc_add_grpbasenum_buf(base, pos, nb, out_buf, len);
else if (!EX_GMP_NUMS_USE_REFS || !buf) /* just add the number */
ret = vstr_add_buf(base, pos, out_buf, len);
else
{ /* assumes mp_set_memory_functions() hasn't been called */
Vstr_ref *ref = vstr_ref_make_ptr(buf, vstr_ref_cb_free_ptr_ref);
if (!ref)
goto mem_fail;
ret = vstr_add_ref(base, pos, ref, out_buf - buf, len);
buf = NULL; /* memory is free'd when the reference is used up */
/* if !ret then this will free buf */
vstr_ref_del(ref);
}
if (!ret || !vstr_sc_fmt_cb_end(base, pos, spec, len))
goto mem_fail;
free(buf);
return (TRUE);
mem_fail:
free(buf);
return (FALSE);
}
int
main (int argc, char **argv)
{
mpz_t op1, op2, r1, r2;
mp_size_t op1n, op2n;
unsigned long int op2long;
int i;
int reps = 100000;
gmp_randstate_ptr rands;
mpz_t bs;
unsigned long bsi, size_range;
tests_start ();
rands = RANDS;
mpz_init (bs);
if (argc == 2)
reps = atoi (argv[1]);
mpz_init (op1);
mpz_init (op2);
mpz_init (r1);
mpz_init (r2);
for (i = 0; i < reps; i++)
{
mpz_urandomb (bs, rands, 32);
size_range = mpz_get_ui (bs) % 10 + 2;
mpz_urandomb (bs, rands, size_range);
op1n = mpz_get_ui (bs);
mpz_rrandomb (op1, rands, op1n);
mpz_urandomb (bs, rands, size_range);
op2n = mpz_get_ui (bs);
mpz_rrandomb (op2, rands, op2n);
mpz_urandomb (bs, rands, 2);
bsi = mpz_get_ui (bs);
if ((bsi & 1) != 0)
mpz_neg (op1, op1);
if ((bsi & 2) != 0)
mpz_neg (op2, op2);
/* printf ("%ld %ld\n", SIZ (multiplier), SIZ (multiplicand)); */
mpz_add (r1, op1, op2);
mpz_sub (r2, r1, op2);
if (mpz_cmp (r2, op1) != 0)
dump_abort (i, "mpz_add or mpz_sub incorrect", op1, op2);
if (mpz_fits_ulong_p (op2))
{
op2long = mpz_get_ui (op2);
mpz_add_ui (r1, op1, op2long);
mpz_sub_ui (r2, r1, op2long);
if (mpz_cmp (r2, op1) != 0)
dump_abort (i, "mpz_add_ui or mpz_sub_ui incorrect", op1, op2);
mpz_ui_sub (r1, op2long, op1);
mpz_sub_ui (r2, op1, op2long);
mpz_neg (r2, r2);
if (mpz_cmp (r1, r2) != 0)
dump_abort (i, "mpz_add_ui or mpz_ui_sub incorrect", op1, op2);
}
}
mpz_clear (bs);
mpz_clear (op1);
mpz_clear (op2);
mpz_clear (r1);
mpz_clear (r2);
tests_end ();
exit (0);
}
bool RingZZ::get_ui(unsigned int &result, mpz_t n)
{
result = static_cast<unsigned int>(mpz_get_ui(n));
return mpz_fits_ulong_p(n);
}
static int
e_mpq_ulong_p (mpq_srcptr q)
{
return mpz_fits_ulong_p (mpq_numref (q))
&& mpz_cmp_ui (mpq_denref (q), 1L) == 0;
}
static PyObject *
GMPy_Integer_Pow(PyObject *b, PyObject *e, PyObject *m, CTXT_Object *context)
{
MPZ_Object *result = NULL, *tempb = NULL, *tempe = NULL, *tempm = NULL;
int has_mod;
/* Try to parse the modulus value first. */
if (m == Py_None) {
has_mod = 0;
}
else {
has_mod = 1;
if (!IS_INTEGER(m)) {
Py_RETURN_NOTIMPLEMENTED;
}
else {
if (!(tempm = GMPy_MPZ_From_Integer(m, context))) {
goto err;
}
}
}
result = GMPy_MPZ_New(context);
tempb = GMPy_MPZ_From_Integer(b, context);
tempe = GMPy_MPZ_From_Integer(e, context);
if (!tempb || !tempe || !result) {
goto err;
}
if (!has_mod) {
/* When no modulo is present, the exponent must fit in unsigned long.
*/
unsigned long el;
if (mpz_sgn(tempe->z) < 0) {
VALUE_ERROR("pow() exponent cannot be negative");
goto err;
}
if (!mpz_fits_ulong_p(tempe->z)) {
VALUE_ERROR("pow() outrageous exponent");
goto err;
}
el = mpz_get_ui(tempe->z);
mpz_pow_ui(result->z, tempb->z, el);
}
else {
/* Modulo is present. */
int sign;
mpz_t mm, base, exp;
sign = mpz_sgn(tempm->z);
if (sign == 0) {
VALUE_ERROR("pow() 3rd argument cannot be 0");
goto err;
}
mpz_inoc(mm);
mpz_abs(mm, tempm->z);
/* A negative exponent is allowed if inverse exists. */
if (mpz_sgn(tempe->z) < 0) {
mpz_inoc(base);
mpz_inoc(exp);
if (!mpz_invert(base, tempb->z, mm)) {
VALUE_ERROR("pow() base not invertible");
mpz_cloc(base);
mpz_cloc(exp);
mpz_cloc(mm);
goto err;
}
else {
mpz_abs(exp, tempe->z);
}
mpz_powm(result->z, base, exp, mm);
mpz_cloc(base);
mpz_cloc(exp);
}
else {
mpz_powm(result->z, tempb->z, tempe->z, mm);
}
mpz_cloc(mm);
/* Python uses a rather peculiar convention for negative modulos
* If the modulo is negative, result should be in the interval
* m < r <= 0 .
*/
if ((sign < 0) && (mpz_sgn(MPZ(result)) > 0)) {
mpz_add(result->z, result->z, tempm->z);
}
}
Py_XDECREF((PyObject*)tempb);
Py_XDECREF((PyObject*)tempe);
Py_XDECREF((PyObject*)tempm);
return (PyObject*)result;
err:
Py_XDECREF((PyObject*)tempb);
Py_XDECREF((PyObject*)tempe);
Py_XDECREF((PyObject*)tempm);
Py_DECREF((PyObject*)result);
return NULL;
}
void
check_all (mpz_ptr want, mpz_srcptr x_orig, mpz_srcptr y_orig)
{
mpz_t got, x, y;
int negx, negy, swap, inplace;
mpz_init (got);
mpz_init_set (x, x_orig);
mpz_init_set (y, y_orig);
for (swap = 0; swap < 2; swap++)
{
mpz_swap (x, y);
for (negx = 0; negx < 2; negx++)
{
mpz_neg (x, x);
for (negy = 0; negy < 2; negy++)
{
mpz_neg (y, y);
for (inplace = 0; inplace <= 1; inplace++)
{
if (inplace)
{ mpz_set (got, x); mpz_lcm (got, got, y); }
else
mpz_lcm (got, x, y);
MPZ_CHECK_FORMAT (got);
if (mpz_cmp (got, want) != 0)
{
printf ("mpz_lcm wrong, inplace=%d\n", inplace);
fail:
mpz_trace ("x", x);
mpz_trace ("y", y);
mpz_trace ("got", got);
mpz_trace ("want", want);
abort ();
}
if (mpz_fits_ulong_p (y))
{
unsigned long yu = mpz_get_ui (y);
if (inplace)
{ mpz_set (got, x); mpz_lcm_ui (got, got, yu); }
else
mpz_lcm_ui (got, x, yu);
if (mpz_cmp (got, want) != 0)
{
printf ("mpz_lcm_ui wrong, inplace=%d\n", inplace);
printf ("yu=%lu\n", yu);
goto fail;
}
}
}
}
}
}
mpz_clear (got);
mpz_clear (x);
mpz_clear (y);
}
num_t
num_int_part_sel(pseltype_t op_type, num_t hi, num_t lo, num_t a)
{
num_t r, m;
unsigned long mask_shl, lo_ui;
r = num_new_z(N_TEMP, NULL);
m = num_new_z(N_TEMP, NULL);
a = num_new_z(N_TEMP, a);
hi = num_new_z(N_TEMP, hi);
if (lo != NULL)
lo = num_new_z(N_TEMP, lo);
switch (op_type) {
case PSEL_SINGLE:
lo = num_new_z(N_TEMP, hi);
break;
case PSEL_FRANGE:
break;
case PSEL_DRANGE:
if (mpz_cmp_si(Z(lo), 0L) < 0) {
yyxerror("low index of part select operation must be "
"positive");
return NULL;
}
mpz_sub_ui(Z(lo), Z(lo), 1UL);
mpz_sub(Z(lo), Z(hi), Z(lo));
break;
}
if (mpz_cmp_si(Z(hi), 0L) < 0) {
yyxerror("high index of part select operation must be "
"positive");
return NULL;
}
if (mpz_cmp_si(Z(lo), 0L) < 0) {
yyxerror("low index of part select operation must be "
"positive");
return NULL;
}
if (!mpz_fits_ulong_p(Z(hi))) {
yyxerror("high index of part select operation needs to fit "
"into an unsigned long C datatype");
return NULL;
}
if (!mpz_fits_ulong_p(Z(lo))) {
yyxerror("low index of part select operation needs to fit "
"into an unsigned long C datatype");
return NULL;
}
lo_ui = mpz_get_ui(Z(lo));
mask_shl = 1 + (mpz_get_ui(Z(hi)) - lo_ui);
/*
* We do the part sel by:
* (1) shifting right by 'lo'
* (2) anding with ((1 << mask_shl)-1)
*/
mpz_div_2exp(Z(r), Z(a), lo_ui);
mpz_set_ui(Z(m), 1UL);
mpz_mul_2exp(Z(m), Z(m), mask_shl);
mpz_sub_ui(Z(m), Z(m), 1UL);
mpz_and(Z(r), Z(r), Z(m));
return r;
}