void sample(void * arg, ulong count)
{
mp_limb_t n, d, dinv, r = 0, norm;
double dpre;
info_t * info = (info_t *) arg;
mp_bitcnt_t bits = info->bits;
ulong type = info->type;
ulong i;
flint_rand_t state;
flint_randinit(state);
mp_ptr arr = (mp_ptr) malloc(1024*sizeof(mp_limb_t));
mp_ptr arr2 = (mp_ptr) malloc(1024*sizeof(mp_limb_t));
for (i = 0; i < count; i++)
{
int j;
d = n_randbits(state, bits);
if (d == 0UL) d++;
dinv = n_preinvert_limb(d);
for (j = 0; j < 1024; j++)
{
arr[j] = n_randbits(state, FLINT_BITS);
arr2[j] = n_randint(state, n);
}
switch (type)
{
case 1:
prof_start();
for (mp_size_t j = 0; j < 10000UL; j++)
{
r += n_lll_mod_preinv(arr2[j&1023], arr[j&1023], arr[(j+1)&1023], d, dinv);
}
prof_stop();
break;
}
}
if (r == 9879875897UL) abort();
flint_randclear(state);
free(arr);
free(arr2);
}
void sample(void * arg, ulong count)
{
mp_limb_t n;
nmod_t mod;
info_t * info = (info_t *) arg;
mp_bitcnt_t bits = info->bits;
mp_ptr vec = _nmod_vec_init(1000);
mp_ptr vec2 = _nmod_vec_init(1000);
mp_size_t j;
long i;
flint_rand_t state;
flint_randinit(state);
for (j = 0; j < 1000; j++)
vec[j] = n_randlimb(state);
prof_start();
for (i = 0; i < count; i++)
{
n = n_randbits(state, bits);
if (n == 0UL) n++;
nmod_init(&mod, n);
_nmod_vec_reduce(vec2, vec, 1000, mod);
}
prof_stop();
flint_randclear(state);
_nmod_vec_clear(vec);
_nmod_vec_clear(vec2);
}
int main(void)
{
int i, result;
flint_rand_t state;
printf("xgcd....");
fflush(stdout);
flint_randinit(state);
for (i = 0; i < 100000; i++)
{
mp_limb_t a, b, c, g, bits1, bits2, bits3, ph, pl, qh, ql;
mp_limb_t s, t;
bits1 = n_randint(state, FLINT_BITS-1) + 1;
bits2 = n_randint(state, bits1) + 1;
bits3 = n_randint(state, FLINT_BITS - bits1) + 1;
do
{
a = n_randbits(state, bits1);
b = n_randbits(state, bits2);
} while ((n_gcd(a, b) != 1UL) || (b > a));
c = n_randbits(state, bits3);
g = n_xgcd(&s, &t, a*c, b*c);
umul_ppmm(ph, pl, a*c, s);
umul_ppmm(qh, ql, b*c, t);
sub_ddmmss(ph, pl, ph, pl, qh, ql);
result = ((g == c) && (ph == 0UL) && (pl == c));
if (!result)
{
printf("FAIL:\n");
printf("a = %lu, b = %lu, c = %lu, g = %lu, s = %lu, t = %lu\n", a, b, c, g, s, t);
abort();
}
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
int main(void)
{
int i, result;
ulong count = 0UL;
flint_rand_t state;
flint_randinit(state);
printf("factor_SQUFOF....");
fflush(stdout);
for (i = 0; i < 3000; i++) /* Test random numbers */
{
mp_limb_t n1, n2;
do
{
n1 = n_randbits(state, n_randint(state, FLINT_BITS) + 1);
} while (n_is_prime(n1) || (n1 < 2UL));
#if FLINT64
n2 = n_factor_SQUFOF(n1, 10000);
#else
n2 = n_factor_SQUFOF(n1, 2000);
#endif
if (n2)
{
count++;
result = ((n1%n2) == 0UL);
if (!result)
{
printf("FAIL:\n");
printf("n1 = %lu, n2 = %lu\n", n1, n2);
abort();
}
}
}
if (count < 2800)
{
printf("FAIL:\n");
printf("Only %lu of 10000 numbers factored\n", count);
abort();
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
void fill_array(ulong * ret, mp_bitcnt_t bits, flint_rand_t state)
{
ulong n;
n_factor_t factors;
ulong i, primes = (1<<(bits/3))/10 + 1;
for (i = 0; i < 1024; i++)
{
do
{
n_factor_init(&factors);
n = n_randbits(state, bits);
} while (n_is_probabprime(n) || (n_factor_trial(&factors, n, primes) != n));
ret[i] = n;
}
}
int main(void)
{
int i, result;
flint_rand_t state;
printf("mod_precomp....");
fflush(stdout);
flint_randinit(state);
for (i = 0; i < 1000000; i++)
{
mp_limb_t bits, d, n, r1, r2;
double dpre;
bits = n_randint(state, FLINT_D_BITS) + 1;
d = n_randbits(state, bits);
if (bits <= (FLINT_BITS/2)) n = n_randint(state, d*d);
else n = n_randtest(state);
dpre = n_precompute_inverse(d);
r1 = n_mod_precomp(n, d, dpre);
r2 = n%d;
result = (r1 == r2);
if (!result)
{
printf("FAIL:\n");
printf("n = %lu, d = %lu, dinv = %f\n", n, d, dpre);
printf("r1 = %lu, r2 = %lu\n", r1, r2);
abort();
}
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
int main(void)
{
int i, j, result;
ulong count = UWORD(0);
gmp_randstate_t st;
FLINT_TEST_INIT(state);
gmp_randinit_default(st);
flint_printf("factor_pp1....");
fflush(stdout);
for (i = 0; i < 50 * flint_test_multiplier(); i++) /* Test random numbers */
{
mp_bitcnt_t bits;
mpz_t m, n;
fmpz_t n1, n2, r;
mpz_init(n);
mpz_init(m);
fmpz_init(n1);
fmpz_init(n2);
fmpz_init(r);
do {
mpz_urandomb(n, st, n_randint(state, 128) + 2);
} while (flint_mpz_cmp_ui(n, 2) < 0);
do {
mpz_urandomb(m, st, n_randint(state, 50) + 2);
} while (!mpz_probab_prime_p(m, 20));
mpz_mul(n, n, m);
fmpz_set_mpz(n1, n);
bits = FLINT_MIN(fmpz_bits(n1), FLINT_BITS);
for (j = 0; j < 20; j++)
{
fmpz_factor_pp1(n2, n1, 10000, 10000, n_randbits(state, bits - 2) + 3);
if (fmpz_cmp_ui(n2, 1) > 0) break;
}
if (fmpz_cmp_ui(n2, 1) > 0)
{
count++;
fmpz_mod(r, n1, n2);
result = (fmpz_is_zero(r));
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("n1 = ");
fmpz_print(n1);
flint_printf(", n2 = ");
fmpz_print(n2);
flint_printf("\n");
fmpz_print(r); flint_printf("\n");
abort();
}
}
fmpz_clear(n1);
fmpz_clear(n2);
fmpz_clear(r);
mpz_clear(m);
mpz_clear(n);
}
if (count < 49 * flint_test_multiplier())
{
flint_printf("FAIL:\n");
flint_printf("Only %wu numbers factored\n", count);
abort();
}
gmp_randclear(st);
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("scalar_submul_fmpz....");
fflush(stdout);
flint_randinit(state);
/* Compare with fmpz_vec_scalar_submul_si */
for (i = 0; i < 10000; i++)
{
fmpz *a, *b, *c;
long len, n;
fmpz_t n1;
len = n_randint(state, 100);
n = (long) n_randbits(state, FLINT_BITS - 1);
if (n_randint(state, 2))
n = -n;
fmpz_init(n1);
fmpz_set_si(n1, n);
a = _fmpz_vec_init(len);
b = _fmpz_vec_init(len);
c = _fmpz_vec_init(len);
_fmpz_vec_randtest(a, state, len, 200);
_fmpz_vec_randtest(b, state, len, 200);
_fmpz_vec_set(c, b, len);
_fmpz_vec_scalar_submul_fmpz(b, a, len, n1);
_fmpz_vec_scalar_submul_si(c, a, len, n);
result = (_fmpz_vec_equal(c, b, len));
if (!result)
{
printf("FAIL:\n");
_fmpz_vec_print(c, len), printf("\n\n");
_fmpz_vec_print(b, len), printf("\n\n");
abort();
}
fmpz_clear(n1);
_fmpz_vec_clear(a, len);
_fmpz_vec_clear(b, len);
_fmpz_vec_clear(c, len);
}
/* Compute a different way */
for (i = 0; i < 10000; i++)
{
fmpz *a, *b, *c, *d;
long len = n_randint(state, 100);
fmpz_t n1;
fmpz_init(n1);
fmpz_randtest(n1, state, 200);
a = _fmpz_vec_init(len);
b = _fmpz_vec_init(len);
c = _fmpz_vec_init(len);
d = _fmpz_vec_init(len);
_fmpz_vec_randtest(a, state, len, 200);
_fmpz_vec_randtest(b, state, len, 200);
_fmpz_vec_set(c, b, len);
_fmpz_vec_scalar_submul_fmpz(b, a, len, n1);
_fmpz_vec_scalar_mul_fmpz(d, a, len, n1);
_fmpz_vec_sub(c, c, d, len);
result = (_fmpz_vec_equal(c, b, len));
if (!result)
{
printf("FAIL:\n");
_fmpz_vec_print(c, len), printf("\n\n");
_fmpz_vec_print(b, len), printf("\n\n");
abort();
}
fmpz_clear(n1);
_fmpz_vec_clear(a, len);
_fmpz_vec_clear(b, len);
_fmpz_vec_clear(c, len);
_fmpz_vec_clear(d, len);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
long i;
flint_rand_t state;
flint_randinit(state);
printf("mul....");
fflush(stdout);
for (i = 0; i < 10000; i++)
{
nmod_mat_t A, B, C, D;
mp_limb_t mod;
long m, k, n;
m = n_randint(state, 50);
k = n_randint(state, 50);
n = n_randint(state, 50);
/* We want to generate matrices with many entries close to half
or full limbs with high probability, to stress overflow handling */
switch (n_randint(state, 3))
{
case 0:
mod = n_randtest_not_zero(state);
break;
case 1:
mod = ULONG_MAX/2 + 1 - n_randbits(state, 4);
break;
case 2:
default:
mod = ULONG_MAX - n_randbits(state, 4);
break;
}
nmod_mat_init(A, m, n, mod);
nmod_mat_init(B, n, k, mod);
nmod_mat_init(C, m, k, mod);
nmod_mat_init(D, m, k, mod);
if (n_randint(state, 2))
nmod_mat_randtest(A, state);
else
nmod_mat_randfull(A, state);
if (n_randint(state, 2))
nmod_mat_randtest(B, state);
else
nmod_mat_randfull(B, state);
nmod_mat_randtest(C, state); /* make sure noise in the output is ok */
nmod_mat_mul(C, A, B);
nmod_mat_mul_check(D, A, B);
if (!nmod_mat_equal(C, D))
{
printf("FAIL: results not equal\n");
nmod_mat_print_pretty(A);
nmod_mat_print_pretty(B);
nmod_mat_print_pretty(C);
nmod_mat_print_pretty(D);
abort();
}
nmod_mat_clear(A);
nmod_mat_clear(B);
nmod_mat_clear(C);
nmod_mat_clear(D);
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
int main(void)
{
int i, result;
flint_rand_t state;
printf("powmod_precomp....");
fflush(stdout);
flint_randinit(state);
for (i = 0; i < 100000; i++)
{
mp_limb_t a, d, r1, r2, bits;
mpz_t a_m, d_m, r2_m;
mp_limb_signed_t exp;
double dpre;
mpz_init(a_m);
mpz_init(d_m);
mpz_init(r2_m);
bits = n_randint(state, FLINT_D_BITS) + 1;
d = n_randbits(state, bits);
do
{
a = n_randint(state, d);
} while (n_gcd(d, a) != 1UL);
exp = n_randtest(state);
dpre = n_precompute_inverse(d);
r1 = n_powmod_precomp(a, exp, d, dpre);
mpz_set_ui(a_m, a);
mpz_set_ui(d_m, d);
if (exp < 0L)
{
mpz_powm_ui(r2_m, a_m, -exp, d_m);
mpz_invert(r2_m, r2_m, d_m);
} else
mpz_powm_ui(r2_m, a_m, exp, d_m);
r2 = mpz_get_ui(r2_m);
result = (r1 == r2);
if (!result)
{
printf("FAIL:\n");
printf("a = %lu, exp = %ld, d = %lu\n", a, exp, d);
printf("r1 = %lu, r2 = %lu\n", r1, r2);
abort();
}
mpz_clear(a_m);
mpz_clear(d_m);
mpz_clear(r2_m);
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
ulong cflags = 0UL;
printf("scalar_div_ui....");
fflush(stdout);
flint_randinit(state);
/* Check aliasing of a and b */
for (i = 0; i < 10000; i++)
{
fmpq_poly_t a, b;
ulong n = n_randtest_not_zero(state);
fmpq_poly_init(a);
fmpq_poly_init(b);
fmpq_poly_randtest(a, state, n_randint(state, 100), 200);
fmpq_poly_scalar_div_ui(b, a, n);
fmpq_poly_scalar_div_ui(a, a, n);
cflags |= fmpq_poly_is_canonical(a) ? 0 : 1;
cflags |= fmpq_poly_is_canonical(b) ? 0 : 2;
result = (fmpq_poly_equal(a, b) && !cflags);
if (!result)
{
printf("FAIL:\n");
fmpq_poly_debug(a), printf("\n\n");
fmpq_poly_debug(b), printf("\n\n");
printf("cflags = %lu\n\n", cflags);
abort();
}
fmpq_poly_clear(a);
fmpq_poly_clear(b);
}
/* Check (a / n1) / n2 = a / (n1 * n2) */
for (i = 0; i < 10000; i++)
{
fmpq_poly_t a, b, c;
ulong n1 = n_randbits(state, FLINT_BITS / 2);
ulong n2 = n_randbits(state, FLINT_BITS / 2);
if (n1 == 0UL)
n1 = 1UL;
if (n2 == 0UL)
n2 = 1UL;
fmpq_poly_init(a);
fmpq_poly_init(b);
fmpq_poly_init(c);
fmpq_poly_randtest(a, state, n_randint(state, 100), 200);
fmpq_poly_scalar_div_ui(b, a, n1);
fmpq_poly_scalar_div_ui(c, b, n2);
fmpq_poly_scalar_div_ui(b, a, n1 * n2);
cflags |= fmpq_poly_is_canonical(b) ? 0 : 1;
cflags |= fmpq_poly_is_canonical(c) ? 0 : 2;
result = (fmpq_poly_equal(b, c) && !cflags);
if (!result)
{
printf("FAIL:\n");
printf(" n1 = %lu, n2 = %lu:\n\n", n1, n2);
fmpq_poly_debug(a), printf("\n\n");
fmpq_poly_debug(b), printf("\n\n");
fmpq_poly_debug(c), printf("\n\n");
printf("cflags = %lu\n\n", cflags);
abort();
}
fmpq_poly_clear(a);
fmpq_poly_clear(b);
fmpq_poly_clear(c);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
