static void mympz_from_hash(mpz_t x, mpz_t limit, byte_string_t hash)
//let z = number represented in c
//x = z || 1 || z || 2 || z || 3 ...
//until there are enough bits
//should be rewritten more efficiently?
{
mpz_t z;
int countlen;
mpz_t count;
int i = 0, j;
int bits = mpz_sizeinbase(limit, 2);
int zbits;
char *c = hash->data;
int len = hash->len;
mpz_init(z);
mpz_init(count);
mpz_set_ui(count, 1);
mympz_inp_raw(z, c, len);
zbits = mpz_sizeinbase(z, 2);
mpz_set_ui(x, 0);
do {
for (j=0; j<zbits; j++) {
if (mpz_tstbit(z, j)) {
mpz_setbit(x, i);
}
i++;
}
bits -= zbits;
if (bits <= 0) break;
countlen = mpz_sizeinbase(count, 2);
for (j=0; j<countlen; j++) {
if (mpz_tstbit(count, j)) {
mpz_setbit(x, i);
}
i++;
}
bits -= countlen;
mpz_add_ui(count, count, 1);
} while (bits > 0);
/*
printf("hash: ");
mpz_out_str(NULL, 0, x);
printf("\n");
*/
while (mpz_cmp(x, limit) > 0) {
mpz_clrbit(x, mpz_sizeinbase(x, 2) - 1);
}
mpz_clear(z);
mpz_clear(count);
}
void alder_gmp_test()
{
mpz_t integ1, integ2;
mpz_init2 (integ1, 54);
mpz_init2 (integ2, 54);
mpz_set_ui(integ1, 1);
mpz_mul_2exp(integ1, integ1, 65);
mpz_out_str (stdout, 2, integ1);
printf("\n");
// mpz_add_ui(integ1,integ1,1);
mpz_out_str (stdout, 10, integ1); printf("\n");
// mpz_mul_2exp(integ1, integ1, 2);
// mpz_out_str (stdout, 2, integ1); printf("\n");
uint64_t x2[2];
x2[0] = 0; x2[1] = 0;
uint64_t x = 0;
size_t countp = 0;
mpz_export(x2, &countp, -1, 8, 0, 0, integ1);
printf("x[0]: %llu\n", x2[0]);
printf("x[1]: %llu\n", x2[1]);
x = UINT64_MAX;
printf("x: %llu\n", x);
mpz_set_ui(integ1,0);
// mpz_mul_2exp(integ1, integ1, );
// mpz_import(b, 1, 1, sizeof(a), 0, 0, &a);
// mpz_export
mpz_out_str (stdout, 2, integ1); printf("\n");
mpz_out_str (stdout, 2, integ2);
printf("\n");
mpz_swap(integ1, integ2);
mpz_mul_2exp(integ2, integ1, 2);
mpz_setbit(integ2,0);
mpz_setbit(integ2,1);
mpz_out_str (stdout, 2, integ2);
printf("\n");
mpz_clear (integ1);
mpz_clear (integ2);
}
int main(int argc, char **argv) {
mp_bitcnt_t bit_width = 0;
int base = kDefaultBase;
static const struct option long_options[] = {
{ "help", no_argument, NULL, 'h' },
{ "use-random", no_argument, NULL, 'r' },
{ "base", required_argument, NULL, 'b' },
{ "bit-width", required_argument, NULL, 's' },
{ NULL, 0, NULL, 0 }
};
for (;;) {
int opt = getopt_long(argc, argv, "hrb:s:", long_options, NULL);
if (opt == -1)
break;
switch (opt) {
case 'r':
gRNGFilename = "/dev/random";
break;
case 'b':
if (simple_strtoi(&base, optarg, 10) < 0 ||
(base > -2 && base < 2) || base < -36 || base > 62)
fatal("invalid base: '%s'", optarg);
break;
case 's':
if (simple_strtoul(&bit_width, optarg, 10) < 0 || bit_width == 0)
fatal("invalid bit width: '%s'", optarg);
break;
case 'h':
print_usage();
return EXIT_SUCCESS;
default:
return EXIT_FAILURE;
}
}
argv += optind;
argc -= optind;
if (argc > 2 || (bit_width != 0 && argc > 0))
fatal("too many arguments");
mpz_t low, high, result;
mpz_inits(low, high, result, NULL);
if (argc == 2) {
arg_to_mpz(low, argv[0]);
arg_to_mpz(high, argv[1]);
} else if (argc == 1) {
arg_to_mpz(high, argv[0]);
} else if (bit_width != 0) {
mpz_setbit(high, bit_width);
} else {
mpz_set_ui(high, kDefaultUpperBound);
}
get_random_mpz(result, low, high);
mpz_out_str(stdout, base, result);
putchar('\n');
mpz_clears(low, high, result, NULL);
return EXIT_SUCCESS;
}
/* SmallestRangeToHoldValue : Returns the number of bits required to represent
a given value. (-ve result for signed constants)
NB: For an input value of 0, the output type is unsigned, 0 bits.
This allows 0's to be compiled out easily.
*/
SignedBits SmallestRangeToHoldValue (PtrMP_INT value)
{
Bits unsignedLength = mpz_sizeinbase (value, 2);
bool isNegative = mpz_sgn (value) < 0;
SignedBits ret = unsignedLength;
/* Zero */
if (mpz_sgn (value) == 0)
ret = 1;
else if (isNegative)
{
mpz_t negativeLimit;
/* Make negativeLimit equal to -(1 << (unsignedLength-1))
is the most negative number that can be represented
without an extra sign bit */
mpz_init (negativeLimit);
/* for unsigned length XXXXXXXX */
mpz_setbit (negativeLimit, unsignedLength - 1); /* eg 00000000 10000000 */
mpz_neg (negativeLimit, negativeLimit); /* eg 11111111 10000000 */
if (mpz_cmp (value, negativeLimit) < 0)
ret++; /* Add sign bit */
mpz_clear (negativeLimit);
return -ret;
}
return ret;
}
mpz_class computeRandomPrime(gmp_randclass& randomGenerator, unsigned int security)
{
mpz_class prime = randomGenerator.get_z_bits(security - 1);
mpz_setbit(prime.get_mpz_t(), security - 1);
mpz_nextprime(prime.get_mpz_t(), prime.get_mpz_t());
return prime;
}
void test_big_num(){
bj_big_int_t a, b, c, d;
a = 0;
mpz_setbit(a.get_mpz_t(), 6);
mpz_setbit(a.get_mpz_t(), 12);
mpz_setbit(a.get_mpz_t(), 17);
//mpz_setbit(a.get_mpz_t(), 112);
bj_out << "a is " << a << "\n";
ch_string s1 = a.get_str(2);
bj_out << "s1 is " << s1 << bj_eol;
//long cm1 = mpz_cmp(nu1.get_mpz_t(), nu2.get_mpz_t());
}
/* These wrapped because they're in-place whereas MPEXPR_TYPE_BINARY_UI
expects a separate source and destination. Actually the parser will
normally pass w==x anyway. */
static void
e_mpz_setbit (mpz_ptr w, mpz_srcptr x, unsigned long n)
{
if (w != x)
mpz_set (w, x);
mpz_setbit (w, n);
}
void
mpi_set_highbit( MPI a, unsigned n )
{
/* This seems whacky, but what do I know. */
mpz_fdiv_r_2exp(a, a, n+1);
mpz_setbit(a, n);
}
static PyObject *
GMPy_MPZ_bit_set_function(PyObject *self, PyObject *args)
{
mp_bitcnt_t bit_index;
MPZ_Object *result = NULL, *tempx = NULL;
if (PyTuple_GET_SIZE(args) != 2)
goto err;
if (!(result = GMPy_MPZ_New(NULL)))
return NULL;
if (!(tempx = GMPy_MPZ_From_Integer(PyTuple_GET_ITEM(args, 0), NULL)))
goto err;
bit_index = mp_bitcnt_t_From_Integer(PyTuple_GET_ITEM(args, 1));
if (bit_index == (mp_bitcnt_t)(-1) && PyErr_Occurred())
goto err_index;
mpz_set(result->z, tempx->z);
mpz_setbit(result->z, bit_index);
Py_DECREF((PyObject*)tempx);
return (PyObject*)result;
err:
TYPE_ERROR("bit_set() requires 'mpz','int' arguments");
err_index:
Py_XDECREF((PyObject*)result);
Py_XDECREF((PyObject*)tempx);
return NULL;
}
void
fips186_gen::gen_q (bigint *q)
{
bigint u1, u2;
char digest[HASHSIZE];
do {
sha1_hash (digest, seed, seedsize << 3); // seedsize * 8
mpz_set_rawmag_le (&u1, digest, HASHSIZE);
seed[3]++;
sha1_hash (digest, seed, seedsize << 3); // seedsize * 8
mpz_set_rawmag_le (&u2, digest, HASHSIZE);
mpz_xor (q, &u1, &u2);
mpz_setbit (q, (HASHSIZE << 3) - 1); // set high bit
mpz_setbit (q, 0); // set low bit
} while (!q->probab_prime (5));
}
void mpz_fixed_one(mpz_t x, int prec)
{
//mpz_set_ui(x, 1);
//mpz_mul_2exp(x, x, prec);
mpz_set_ui(x, 0);
mpz_setbit(x, prec);
}
static struct error_record *ct_label_type_parse(const struct expr *sym,
struct expr **res)
{
const struct symbolic_constant *s;
const struct datatype *dtype;
uint8_t data[CT_LABEL_BIT_SIZE];
mpz_t value;
for (s = ct_label_tbl->symbols; s->identifier != NULL; s++) {
if (!strcmp(sym->identifier, s->identifier))
break;
}
dtype = sym->dtype;
if (s->identifier == NULL)
return error(&sym->location, "Could not parse %s", dtype->desc);
if (s->value >= CT_LABEL_BIT_SIZE)
return error(&sym->location, "%s: out of range (%u max)",
s->identifier, s->value, CT_LABEL_BIT_SIZE);
mpz_init2(value, dtype->size);
mpz_setbit(value, s->value);
mpz_export_data(data, value, BYTEORDER_HOST_ENDIAN, sizeof(data));
*res = constant_expr_alloc(&sym->location, dtype,
dtype->byteorder, sizeof(data),
data);
mpz_clear(value);
return NULL;
}
/* Calculate r satisfying r*d == 1 mod 2^n. */
void
mpz_invert_2exp (mpz_t r, mpz_t a, unsigned long n)
{
unsigned long i;
mpz_t inv, prod;
//ASSERT (mpz_odd_p (a));
mpz_init_set_ui (inv, 1L);
mpz_init (prod);
for (i = 1; i < n; i++)
{
mpz_mul (prod, inv, a);
if (mpz_tstbit (prod, i) != 0)
mpz_setbit (inv, i);
}
mpz_mul (prod, inv, a);
mpz_tdiv_r_2exp (prod, prod, n);
//ASSERT (mpz_cmp_ui (prod, 1L) == 0);
mpz_set (r, inv);
mpz_clear (inv);
mpz_clear (prod);
}
extern "C" PyObject* _PyLong_FromByteArray(const unsigned char* bytes, size_t n, int little_endian,
int is_signed) noexcept {
if (n == 0)
return PyLong_FromLong(0);
if (!little_endian) {
// TODO: check if the behaviour of mpz_import is right when big endian is specified.
Py_FatalError("unimplemented");
return 0;
}
BoxedLong* rtn = new BoxedLong();
mpz_init(rtn->n);
mpz_import(rtn->n, 1, 1, n, little_endian ? -1 : 1, 0, &bytes[0]);
RELEASE_ASSERT(little_endian, "");
if (is_signed && bytes[n - 1] >= 0x80) { // todo add big endian support
mpz_t t;
mpz_init(t);
mpz_setbit(t, n * 8);
mpz_sub(rtn->n, rtn->n, t);
mpz_clear(t);
}
return rtn;
}
static int twoexpt(void *a, int n)
{
LTC_ARGCHK(a != NULL);
mpz_set_ui(a, 0);
mpz_setbit(a, n);
return CRYPT_OK;
}
void
makeprime( mpz_t out, int bits )
{
mpz_urandomb( out, random_state, bits );
mpz_setbit( out, bits-1 );
mpz_nextprime( out, out );
}
void
check_twobits (void)
{
unsigned long i, j, got, want;
mpz_t x, y;
mpz_init (x);
mpz_init (y);
for (i = 0; i < 5 * GMP_NUMB_BITS; i++)
{
for (j = 0; j < 5 * GMP_NUMB_BITS; j++)
{
mpz_set_ui (x, 0L);
mpz_setbit (x, i);
mpz_set_ui (y, 0L);
mpz_setbit (y, j);
want = 2 * (i != j);
got = mpz_hamdist (x, y);
if (got != want)
{
printf ("mpz_hamdist wrong on 2 bits pos/pos\n");
wrong:
printf (" i %lu\n", i);
printf (" j %lu\n", j);
printf (" got %lu\n", got);
printf (" want %lu\n", want);
mpz_trace (" x ", x);
mpz_trace (" y ", y);
abort();
}
mpz_neg (x, x);
mpz_neg (y, y);
want = ABS ((long) (i-j));
got = mpz_hamdist (x, y);
if (got != want)
{
printf ("mpz_hamdist wrong on 2 bits neg/neg\n");
goto wrong;
}
}
}
mpz_clear (x);
mpz_clear (y);
}
void pbc_mpz_urandomb(mpz_t z, unsigned int bits)
{
mpz_t limit;
mpz_init(limit);
mpz_setbit(limit, bits);
pbc_mpz_random(z, limit);
mpz_clear(limit);
}
/* Missing in current gmp */
static void
mpz_togglebit (mpz_t x, unsigned long int bit)
{
if (mpz_tstbit(x, bit))
mpz_clrbit(x, bit);
else
mpz_setbit(x, bit);
}
void
mpz_flipbit (mpz_ptr r, unsigned long bit)
{
if (mpz_tstbit (r, bit))
mpz_clrbit (r, bit);
else
mpz_setbit (r, bit);
}
void gen_prime(unsigned int b_size, mpz_t res) {
gmp_randstate_t state;
struct timeval r_time;
gettimeofday(&r_time,NULL);
gmp_randinit_default(state);
gmp_randseed_ui(state,(r_time.tv_sec * 1000) + (r_time.tv_usec / 1000));
do {
mpz_urandomb(res,state,b_size);
mpz_setbit(res,0);
mpz_setbit(res,b_size - 1);
mpz_setbit(res,b_size - 2);
} while(rabin_miller(res,20,state) == 0);
gmp_randclear(state);
}
void LNSMul::emulate(TestCase * tc)
{
mpz_class a = tc->getInputValue("nA");
mpz_class b = tc->getInputValue("nB");
bool sr = mpz_tstbit(a.get_mpz_t(), wE+wF) ^ mpz_tstbit(b.get_mpz_t(), wE+wF);
bool xa0 = mpz_tstbit(a.get_mpz_t(), wE+wF+1);
bool xa1 = mpz_tstbit(a.get_mpz_t(), wE+wF+2);
bool xb0 = mpz_tstbit(b.get_mpz_t(), wE+wF+1);
bool xb1 = mpz_tstbit(b.get_mpz_t(), wE+wF+2);
bool xr0,xr1;
bool nan = (xa0 & xa1) | (xb0 & xb1); // 11
bool zero = !(xa0 | xa1) | !(xb0 | xb1); // 00
bool inf = (xa1 & !xa0) | (xb1 & !xb0); // 10
mpz_class r = a + b;
bool ovf = (mpz_sizeinbase(r.get_mpz_t(), 2) > unsigned(wE+wF)) && (sgn(r) > 0);
bool udf = (mpz_sizeinbase(r.get_mpz_t(), 2) > unsigned(wE+wF)) && (sgn(r) < 0);
if(nan | (zero & inf)) {
xr0 = xr1 = 1;
}
else if(zero) {
xr1 = xr0 = 0;
}
else if(inf | ovf) {
xr1 = 1;
xr0 = 0;
}
else if(udf) {
xr1 = xr0 = 0;
}
else {
xr1 = 0;
xr0 = 1;
}
if(sr) mpz_setbit(r.get_mpz_t(), wE+wF); else mpz_clrbit(r.get_mpz_t(), wE+wF);
if(xr0) mpz_setbit(r.get_mpz_t(), wE+wF+1); else mpz_clrbit(r.get_mpz_t(), wE+wF+1);
if(xr1) mpz_setbit(r.get_mpz_t(), wE+wF+2); else mpz_clrbit(r.get_mpz_t(), wE+wF+2);
r &= mpzpow2(wE+wF+3)-1; // Discard overflowing bits
tc->addExpectedOutput("nR", r);
}
void
mpz_nextprime (mpz_ptr p, mpz_srcptr n)
{
mpz_t tmp;
unsigned short *moduli;
unsigned long difference;
int i;
int composite;
/* First handle tiny numbers */
if (mpz_cmp_ui (n, 2) < 0)
{
mpz_set_ui (p, 2);
return;
}
mpz_add_ui (p, n, 1);
mpz_setbit (p, 0);
if (mpz_cmp_ui (p, 7) <= 0)
return;
prime_limit = NUMBER_OF_PRIMES - 1;
if (mpz_cmp_ui (p, primes[prime_limit]) <= 0)
/* Just use first three entries (3,5,7) of table for small numbers */
prime_limit = 3;
if (prime_limit)
{
/* Compute residues modulo small odd primes */
moduli = (unsigned short *) TMP_ALLOC (prime_limit * sizeof moduli[0]);
for (i = 0; i < prime_limit; i++)
moduli[i] = mpz_fdiv_ui (p, primes[i]);
}
for (difference = 0; ; difference += 2)
{
composite = 0;
/* First check residues */
for (i = 0; i < prime_limit; i++)
{
int acc, pr;
composite |= (moduli[i] == 0);
acc = moduli[i] + 2;
pr = primes[i];
moduli[i] = acc >= pr ? acc - pr : acc;
}
if (composite)
continue;
mpz_add_ui (p, p, difference);
difference = 0;
/* Miller-Rabin test */
if (mpz_millerrabin (p, 2))
break;
}
}
void test_big2(){
mpz_t v1;
mpz_t v2;
bj_big_int_t a, b, c, d;
//mpz_setbit(d, 6);
mpz_init_set_ui(v1, 0);
mpz_init_set_ui(v2, 0);
mpz_setbit(v1, 6);
//std::ios_base::showbase = 2;
bj_out << "v1 is " << v1 << "\n";
d = bj_big_int_t(v1);
bj_out << "d is " << d << "\n";
ch_string s_d;
d.set_str(s_d, 2);
bj_out << "s_d is " << d << "\n";
//ch_string s_v1 = mpz_get_str(NULL, 2, v1);
//bj_out << "s_v1 is " << s_v1 << "\n";
ch_string s2_d = mpz_get_str(NULL, 2, d.get_mpz_t());
bj_out << "s2_d is " << s2_d << "\n";
//v2 = d.get_mpz_t();
mpz_clear(v1);
mpz_clear(v2);
/*
a = 1234;
b = "-5678";
c = a+b;
bj_out << "sum is " << c << "\n";
bj_out << "absolute value is " << abs(c) << "\n";
mpq_class a2, b2, c2, d2, e2, f2;
//a2 = 130;
a2 = 23;
b2 = 5;
c2 = a2 / b2;
d2 = b2 / a2;
e2 = c2 * d2;
f2 = c2 + d2;
//d2 = a2 % b2;
bj_out << a2 << " div " << b2 << " is " << c2 << "\n";
bj_out << b2 << " div " << a2 << " is " << d2 << "\n";
bj_out << c2 << " mul " << d2 << " is " << e2 << "\n";
bj_out << c2 << " + " << d2 << " = " << f2 << "\n";
//bj_out << a2 << " mod " << b2 << " is " << d2 << "\n";
*/
}
/* Asignar posiciones iniciales para los adversarios en el bitset de usuarios.
* Las posiciones se asignan aleatoriamente dentro de todo el conjunto */
void asignar_adversarios(mpz_t usuarios, const int &n, const int &k) {
for (int i = 0; i < k; i++) {
while (true) {
int adv_index = rand() % n;
if (!mpz_tstbit(usuarios, adv_index)) {
mpz_setbit(usuarios, adv_index);
break;
}
}
}
}
static PyObject *
GMPy_XMPZ_Method_SubScript(XMPZ_Object* self, PyObject* item)
{
CTXT_Object *context = NULL;
CHECK_CONTEXT(context);
if (PyIndex_Check(item)) {
Py_ssize_t i;
i = PyIntOrLong_AsSsize_t(item);
if (i == -1 && PyErr_Occurred()) {
INDEX_ERROR("argument too large to be converted to an index");
return NULL;
}
if (i < 0) {
i += mpz_sizeinbase(self->z, 2);
}
return PyIntOrLong_FromLong(mpz_tstbit(self->z, i));
}
else if (PySlice_Check(item)) {
Py_ssize_t start, stop, step, slicelength, cur, i;
MPZ_Object *result;
#if PY_VERSION_HEX > 0x030200A4
if (PySlice_GetIndicesEx(item,
#else
if (PySlice_GetIndicesEx((PySliceObject*)item,
#endif
mpz_sizeinbase(self->z, 2),
&start, &stop, &step, &slicelength) < 0) {
return NULL;
}
if ((step < 0 && start < stop) || (step > 0 && start > stop)) {
stop = start;
}
if (!(result = GMPy_MPZ_New(context))) {
return NULL;
}
mpz_set_ui(result->z, 0);
if (slicelength > 0) {
for (cur = start, i = 0; i < slicelength; cur += step, i++) {
if (mpz_tstbit(self->z, cur)) {
mpz_setbit(result->z, i);
}
}
}
return (PyObject*)result;
}
else {
int root(mpz_class& result, const mpz_class arg, const mpz_class prime)
{
mpz_class y, b, t;
unsigned int r, m;
if (arg % prime == 0) {
result = 0;
return 1;
}
if (mpz_legendre(arg.get_mpz_t(), prime.get_mpz_t()) == -1)
return -1;
b = 0;
t = 0;
y = 2;
while(mpz_legendre(y.get_mpz_t(), prime.get_mpz_t()) != -1)
{
y++;
}
result = prime - 1;
r = mpz_scan1(result.get_mpz_t(), 0);
mpz_rshift(result.get_mpz_t(), result.get_mpz_t(), r);
mpz_powm(y.get_mpz_t(), y.get_mpz_t(), result.get_mpz_t(), prime.get_mpz_t());
mpz_rshift(result.get_mpz_t(), result.get_mpz_t(), 1);
mpz_powm(b.get_mpz_t(), arg.get_mpz_t(), result.get_mpz_t(), prime.get_mpz_t());
result = (arg * b) % prime;
b = (result * b) % prime;
while(b != 1) {
t = (b * b) % prime;
for(m = 1; t != 1; m++) {
t = (t * t) % prime;
}
t = 0;
mpz_setbit(t.get_mpz_t(), r - m - 1);
mpz_powm(t.get_mpz_t(), y.get_mpz_t(), t.get_mpz_t(), prime.get_mpz_t());
y = t * t;
r = m;
result = (result * t) % prime;
b = (b * y) % prime;
}
return 1;
}
void Element::multiply(Element& A, Element& B) {
// Emulate hardware implementation.
// Set result to 0
mpz_t result;
mpz_init(result);
// Modulus: x^163 + x^7 + x^6 + x^3 + 1 (wordlength 163)
mpz_t mod;
mpz_init(mod);
mpz_set_str(mod, "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011001001", 2);
//gmp_printf("Mod = %Zx\n", mod);
// Length of modulus in base 2
int mod_len = 163;
//printf("Len = %d\n", mod_len);
int m = 0;
for (long i = (long) mod_len; i > 0; i--) {
if (mpz_tstbit(A.getMP(), i - 1) == 1) {
mpz_xor(result, result, B.getMP());
}
if (m == 1) {
mpz_xor(result, result, mod);
}
// Set m & T for next round
m = mpz_tstbit(result, mod_len - 1);
// Shift T by 1 bit to the left and clear MSB bit
mpz_clrbit(result, mod_len - 1);
mpz_mul_2exp(result, result, 1);
/*printf("[Mult] i = %d - T = ", mod_len - i + 2);
gmp_printf("0x%Zx\n", result);*/
}
// Shift result back 1 place & place m back in front
mpz_tdiv_q_2exp(result, result, 1);
if (m == 1) {
mpz_setbit(result, 162);
}
/*printf("[Mult] i = 0 - T = ");
gmp_printf("0x%Zx\n", result);*/
// Set result
mpz_set(this->a, result);
}
// -----------------------------------------------------------------------------
// Generate a random prime number and store the result in @n.
//
// urfd: a file descriptor opened to a random source
// size: the (approx) size in bits for the resulting prime
// mod8: the prime, mod 8, shall be equal to this
// -----------------------------------------------------------------------------
static void
init_random_prime(mpz_t n, int urfd, unsigned size, unsigned mod8) {
uint8_t buffer[2048];
const unsigned bytes = size >> 3;
if (bytes > sizeof(buffer))
abort();
mpz_init2(n, bytes);
for (;;) {
ssize_t r;
do {
r = read(urfd, buffer, bytes);
} while (r == -1 && errno == EINTR);
if (r != bytes)
abort();
mpz_import(n, bytes, 1, 1, 0, 0, buffer);
mpz_setbit(n, 0);
if (mod8 & 2) {
mpz_setbit(n, 1);
} else {
mpz_clrbit(n, 1);
}
if (mod8 & 4) {
mpz_setbit(n, 2);
} else {
mpz_clrbit(n, 2);
}
if (mpz_probab_prime_p(n, 10))
break;
}
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("setbit....");
fflush(stdout);
flint_randinit(state);
for (i = 0; i < 100000; i++)
{
ulong j;
fmpz_t a, c;
mpz_t b;
fmpz_init(a);
fmpz_init(c);
mpz_init(b);
fmpz_randtest(a, state, 2 * FLINT_BITS);
fmpz_get_mpz(b, a);
j = n_randint(state, 3 * FLINT_BITS);
fmpz_setbit(a, j);
mpz_setbit(b, j);
fmpz_set_mpz(c, b);
result = (fmpz_equal(a, c));
if (!result)
{
printf("FAIL:\n");
printf("a = "), fmpz_print(a), printf("\n");
gmp_printf("b = %Zd\n", b);
printf("c = "), fmpz_print(c), printf("\n");
printf("j = %ld\n", j);
abort();
}
fmpz_clear(a);
fmpz_clear(c);
mpz_clear(b);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
