void test_gcd(rand_t state)
{
ZZ_t a, b, c;
ZZ_t g, s, t;
long i;
cout << "gcd... ";
for (i = 0; i < 10000; i++)
{
do {
randbits(a, state, n_randint(state, 500));
randbits(b, state, n_randint(state, 500));
g = gcd(a, b);
} while (g != 1 && g != -1);
randbits(c, state, -(long)n_randint(state, 500));
a = a * c;
b = b * c;
g = gcd(a, b);
assert(g == c);
}
cout << "PASS" << endl;
}
void test_is_prime(rand_t state)
{
ZZ_t a, b, c;
long i, j;
cout << "is_prime... ";
for (i = 0; i < 100; i++) /* check primes have no small factors */
{
do {
randbits(a, state, n_randint(state, 32));
} while (!is_prime(a));
for (j = 2; j < 100; j++)
assert((a % j) != 0 || a == j);
}
for (i = 0; i < 100; i++) /* check composites don't pass */
{
do {
randbits(a, state, n_randint(state, 32));
} while (!is_prime(a));
do {
randbits(b, state, n_randint(state, 32));
} while (!is_prime(b));
assert(!is_prime(a*b));
}
cout << "PASS" << endl;
}
static PyObject *
func_randbits(PyObject *self, PyObject *args) {
float p1;
int num_bits;
if (!PyArg_ParseTuple(args, "fi", &p1, &num_bits)) {
return NULL;
}
if (p1 < 0.0 || p1 > 1.0) {
printf("p1 must be between 0.0 and 1.0\n");
// return None for now; easier than raising ValueError
Py_INCREF(Py_None);
return Py_None;
}
if (num_bits < 0 || num_bits > 64) {
printf("num_bits must be 64 or less\n");
// return None for now; easier than raising ValueError
Py_INCREF(Py_None);
return Py_None;
}
//printf("p: %f\n", p);
uint64_t r = randbits(p1, num_bits);
return PyLong_FromUnsignedLongLong(r);
}
static int32_t generate_level(SkipList_t *ptrSl) {
int cLevel = 0;
while (randbits(ptrSl->cBits) && cLevel < ptrSl->cMaxLevel-1) {
cLevel++;
}
assert(cLevel < ptrSl->cMaxLevel);
return cLevel;
}
/*
* Generate and munge a 64bit number.
*/
u64 rand64(void)
{
unsigned long r = 0;
if (rand_bool()) {
/* 32-bit ranges. */
r = rand32();
} else {
/* 33:64-bit ranges. */
switch (rand() % 7) {
case 0: r = rand_single_bit(64);
break;
case 1: r = randbits(64);
break;
case 2: r = rand32() | rand32() << 31;
break;
case 3: r = taviso();
break;
case 4: r = rand8x8();
break;
case 5: r = rept8(8);
break;
/* Sometimes pick a not-so-random number. */
case 6: return get_interesting_value();
}
/* limit the size */
switch (rand() % 4) {
case 0: r &= 0x000000ffffffffffULL;
break;
case 1: r &= 0x0000ffffffffffffULL;
break;
case 2: r &= 0x00ffffffffffffffULL;
break;
}
}
/* Sometimes invert the generated number. */
if (rand_bool())
r = ~r;
/* increase distribution in MSB */
if ((rand() % 10)) {
unsigned int i;
unsigned int rounds;
rounds = rand() % 4;
for (i = 0; i < rounds; i++)
r |= (1UL << ((__WORDSIZE - 1) - (rand() % 8)));
}
/* randomly flip sign bit. */
if (rand_bool())
r |= (1UL << (__WORDSIZE - 1));
return r;
}
/*
* Generate and munge a 64bit number.
*/
u64 rand64(void)
{
unsigned long r = 0;
if (RAND_BOOL()) {
/* 32-bit ranges. */
r = rand32();
} else {
/* 33:64-bit ranges. */
switch (rand() % 5) {
case 0: r = rand_single_bit(64);
break;
case 1: r = randbits(64);
break;
case 2: r = RAND_64();
break;
case 3: r = rept_byte();
break;
/* Sometimes pick a not-so-random number. */
case 4: return get_interesting_value();
}
/* limit the size */
switch (rand() % 4) {
case 0: r &= 0x000000ffffffffffULL;
break;
case 1: r &= 0x0000ffffffffffffULL;
break;
case 2: r &= 0x00ffffffffffffffULL;
break;
default: /* no limiting. */
break;
}
}
/* Sometimes invert the generated number. */
if (ONE_IN(25))
r = ~r;
/* increase distribution in MSB */
if (ONE_IN(10)) {
unsigned int i;
unsigned int rounds;
rounds = rand() % 4;
for (i = 0; i < rounds; i++)
r |= (1UL << ((__WORDSIZE - 1) - (rand() % 8)));
}
/* Sometimes flip sign */
if (ONE_IN(25))
r = ~r + 1;
return r;
}
void test_addsub(rand_t state)
{
ZZ_t a, b, c;
long i;
cout << "add/sub... ";
for (i = 0; i < 10000; i++) {
randbits(a, state, -(long)n_randint(state, 1000));
randbits(b, state, -(long)n_randint(state, 1000));
ZZ_t c = a + b;
c = c - b;
assert(a == c);
}
cout << "PASS" << endl;
}
/*
* Generate, and munge a 32bit number.
*/
unsigned int rand32(void)
{
unsigned long r = 0;
switch (rnd() % 7) {
case 0: r = RAND_BYTE();
break;
case 1: r = rand16();
break;
case 2: r = rand_single_bit(32);
break;
case 3: r = randbits(32);
break;
case 4: r = rnd();
break;
case 5: r = rept_byte();
break;
case 6: return get_interesting_value();
}
/* Sometimes deduct it from INT_MAX */
if (ONE_IN(25))
r = INT_MAX - r;
/* Sometimes flip sign */
if (ONE_IN(25))
r = ~r + 1;
/* we might get lucky if something is counting ints/longs etc. */
if (ONE_IN(4)) {
int _div = 1 << RAND_RANGE(1, 4); /* 2,4,8 or 16 */
r /= _div;
}
/* limit the size */
switch (rnd() % 5) {
case 0: r &= 0xff;
break;
case 1: r &= 0xffff;
break;
case 2: r &= PAGE_MASK;
break;
case 3: r &= 0xffffff;
break;
case 4: // do nothing
break;
}
return r;
}
void test_divdivrem(rand_t state)
{
ZZ_t a, b;
long i;
cout << "div/divrem... ";
for (i = 0; i < 10000; i++) {
randbits(a, state, -(long)n_randint(state, 1000));
do {
randbits(b, state, -(long)n_randint(state, 1000));
} while (b == 0L);
ZZ_t q1 = a / b, q2, r2;
divrem(q2, r2, a, b);
assert(q1 == q2);
}
cout << "PASS" << endl;
}
void test_muldiv(rand_t state)
{
ZZ_t a, b;
long i;
cout << "mul/div... ";
for (i = 0; i < 10000; i++) {
randbits(a, state, -(long)n_randint(state, 1000));
do {
randbits(b, state, -(long)n_randint(state, 1000));
} while (b == 0L);
ZZ_t c = a * b;
c /= b;
assert(a == c);
}
cout << "PASS" << endl;
}
void sample_zmod_poly_mul(unsigned long length, unsigned long bits, void* arg, unsigned long count)
{
zmod_poly_t pol1, pol2, res1;
unsigned long modulus = 2;
zmod_poly_init(pol1, modulus);
zmod_poly_init(pol2, modulus);
zmod_poly_init(res1, modulus);
unsigned long r_count; // how often to generate new random data
if (count >= 1000) r_count = 100;
else if (count >= 100) r_count = 10;
else if (count >= 20) r_count = 5;
else if (count >= 8) r_count = 2;
else r_count = 1;
for (unsigned long count2 = 0; count2 < count; count2++)
{
if (count2 % r_count == 0)
{
modulus = randbits(bits);
if (modulus < 2) modulus = 2;
zmod_poly_clear(pol1);
zmod_poly_clear(pol2);
zmod_poly_clear(res1);
zmod_poly_init(pol1, modulus);
zmod_poly_init(pol2, modulus);
zmod_poly_init(res1, modulus);
randpoly(pol1, length, modulus);
randpoly(pol2, length, modulus);
}
#if DEBUG
printf("bits = %ld, length = %ld, modulus = %ld\n", bits, length, modulus);
#endif
prof_start();
zmod_poly_mul(res1, pol1, pol2);
prof_stop();
}
zmod_poly_clear(pol1);
zmod_poly_clear(pol2);
zmod_poly_clear(res1);
}
/*
* Generate, and munge a 16bit number.
*/
unsigned short rand16(void)
{
unsigned short r = 0, r2;
switch (rnd() % 5) {
case 0: r = RAND_BYTE();
break;
case 1: r = rand_single_bit(16);
break;
case 2: r = randbits(16);
break;
case 3: r = rnd();
break;
case 4: r2 = rnd() & 0xff;
r = r2 | r2 << 8;
break;
}
/* Sometimes flip sign */
if (ONE_IN(25))
r = ~r + 1;
if (ONE_IN(4)) {
int _div = 1 << RAND_RANGE(1, 4); /* 2,4,8 or 16 */
r /= _div;
}
/* limit the size */
switch (rnd() % 4) {
case 0: r &= 0xff;
break;
case 1: r &= 0xfff;
break;
case 2: r &= PAGE_MASK;
break;
case 3: // do nothing
break;
}
return r;
}
/*
* "selector" function for 32bit random.
* only called from rand32()
*/
static unsigned int __rand32(void)
{
unsigned long r = 0;
switch (rand() % 7) {
case 0: r = rand_single_bit(32);
break;
case 1: r = randbits(32);
break;
case 2: r = rand();
break;
case 3: r = taviso();
break;
case 4: r = rand8x8();
break;
case 5: r = rept8(4);
break;
case 6: return get_interesting_32bit_value();
}
return r;
}
void test_jacobi(rand_t state)
{
ZZ_t a, b, c, d;
long i;
int j1, j2;
cout << "jacobi... ";
for (i = 0; i < 1000; i++) {
randbits(a, state, n_randint(state, 1000));
do {
randbits(b, state, n_randint(state, 1000));
} while (is_even(b));
randbits(c, state, n_randint(state, 1000));
j1 = jacobi(a, b);
j2 = jacobi(c, b);
a *= c;
assert(jacobi(a, b) == j1*j2);
}
for (i = 0; i < 1000; i++) {
randbits(a, state, n_randint(state, 1000));
do {
randbits(b, state, n_randint(state, 1000));
} while (is_even(b));
do {
randbits(d, state, n_randint(state, 1000));
} while (is_even(d));
j1 = jacobi(a, b);
j2 = jacobi(a, d);
b *= d;
assert(jacobi(a, b) == j1*j2);
}
cout << "PASS" << endl;
}
