int
main(int argc, char * argv[])
{
mp_limb_t n = 10142789312725007;
n = n_nextprime(1000000000,0)*n_nextprime(1200000000,0);
qseive(n);
}
int main()
{
#define VOL (1<<18)
#define BIG_P 0xFFFFFFFFFFFFFFc5
#define BENCHMARK nmod_mat_multiplication_test_benchmark
mp_limb_t bits_63=n_nextprime(UWORD(1)<<63,0);
mp_limb_t bits_32=n_nextprime(UWORD(1)<<32,0);
flint_randinit(st);
BENCHMARK( 4,4,100, 3, VOL );
BENCHMARK( 100,4,4, 3, VOL );
BENCHMARK( 4,4,100, 5, VOL );
BENCHMARK( 100,4,4, 5, VOL );
BENCHMARK( 4,4,100, BIG_P, VOL );
BENCHMARK( 100,4,4, BIG_P, VOL );
BENCHMARK( 4,4,100, bits_32, VOL );
BENCHMARK( 4,4,100, bits_63, VOL );
BENCHMARK( 4,4,4, bits_63, VOL*25 );
BENCHMARK( 4,4,4, 3, VOL*25 );
BENCHMARK( 4,4,4, BIG_P, VOL*25 );
return 0;
}
void
bell_number_multi_mod(fmpz_t res, ulong n)
{
fmpz_comb_temp_t temp;
fmpz_comb_t comb;
nmod_t mod;
mp_ptr primes, residues;
long k, size, prime_bits, num_primes;
size = bell_number_size(n);
prime_bits = FLINT_BITS - 1;
num_primes = (size + prime_bits - 1) / prime_bits;
primes = flint_malloc(num_primes * sizeof(mp_limb_t));
residues = flint_malloc(num_primes * sizeof(mp_limb_t));
primes[0] = n_nextprime(1UL << prime_bits, 0);
for (k = 1; k < num_primes; k++)
primes[k] = n_nextprime(primes[k-1], 0);
for (k = 0; k < num_primes; k++)
{
nmod_init(&mod, primes[k]);
residues[k] = bell_number_nmod(n, mod);
}
fmpz_comb_init(comb, primes, num_primes);
fmpz_comb_temp_init(temp, comb);
fmpz_multi_CRT_ui(res, residues, comb, temp, 0);
fmpz_comb_clear(comb);
fmpz_comb_temp_clear(temp);
flint_free(primes);
flint_free(residues);
}
int
main(void)
{
int i;
FLINT_TEST_INIT(state);
flint_printf("multi_CRT_ui....");
fflush(stdout);
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
slong bits, prime_bits, rows, cols, num_primes, j;
fmpz_t mod;
fmpz_mat_t A, B, C;
nmod_mat_t Amod[1000];
mp_limb_t primes[1000];
bits = n_randint(state, 500) + 1;
rows = n_randint(state, 10);
cols = n_randint(state, 10);
prime_bits = 1 + n_randint(state, FLINT_BITS - 1);
fmpz_mat_init(A, rows, cols);
fmpz_mat_init(B, rows, cols);
fmpz_mat_init(C, rows, cols);
fmpz_mat_randtest(A, state, bits);
fmpz_init(mod);
num_primes = 0;
primes[0] = n_nextprime(UWORD(1) << prime_bits, 0);
fmpz_set_ui(mod, primes[0]);
/* + 1 for sign */
while (fmpz_bits(mod) <= bits + 1)
{
primes[num_primes + 1] = n_nextprime(primes[num_primes], 0);
fmpz_mul_ui(mod, mod, primes[num_primes + 1]);
num_primes++;
}
num_primes++;
for (j = 0; j < num_primes; j++)
nmod_mat_init(Amod[j], rows, cols, primes[j]);
fmpz_mat_multi_mod_ui(Amod, num_primes, A);
fmpz_mat_multi_CRT_ui(B, Amod, num_primes, 1);
if (!fmpz_mat_equal(B, A))
{
flint_printf("FAIL!\n");
flint_printf("primes: ");
for (j = 0; j < num_primes; j++)
flint_printf("%wu ", primes[j]);
flint_printf("\nA: \n");
fmpz_mat_print_pretty(A);
flint_printf("\nB: \n");
fmpz_mat_print_pretty(B);
flint_printf("\n");
abort();
}
for (j = 0; j < num_primes; j++)
nmod_mat_clear(Amod[j]);
fmpz_mat_clear(A);
fmpz_mat_clear(B);
fmpz_mat_clear(C);
fmpz_clear(mod);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int main(void)
{
slong n;
FLINT_TEST_INIT(state);
flint_printf("primes....");
fflush(stdout);
_flint_rand_init_gmp(state);
/* compare with n_nextprime */
{
n_primes_t iter;
slong i;
mp_limb_t p, q;
n_primes_init(iter);
q = 0;
for (i = 0; i < 200000; i++)
{
p = n_primes_next(iter);
q = n_nextprime(q, 0);
if (p != q)
{
flint_printf("FAIL\n");
flint_printf("i = %wu, p = %wu, q = %wu\n", i, p, q);
abort();
}
}
n_primes_clear(iter);
}
/* count primes */
for (n = 0; n < 10; n++)
{
n_primes_t iter;
mp_limb_t s, p, r;
const unsigned int primepi[10] = {
0, 4, 25, 168, 1229, 9592, 78498, 664579, 5761455, 50847534
};
r = n_pow(10, n);
n_primes_init(iter);
s = 0;
while ((p = n_primes_next(iter)) <= r)
s++;
if (s != primepi[n])
{
flint_printf("FAIL\n");
flint_printf("pi(10^%wd) = %u, computed = %wu\n", n, primepi[n], s);
abort();
}
n_primes_clear(iter);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
void eis_series(fmpz_poly_t *eis, ulong k, ulong prec)
{
ulong i, p, ee, p_pow, ind;
fmpz_t last, last_m1, mult, fp, t_coeff, term, term_m1;
long bern_fac[15] = {0, 0, 0, 0, 240, 0, -504, 0, 480, 0, -264, 0, 0, 0, -24};
// Now, we compute the eisenstein series
// First, compute primes by sieving.
// allocate memory for the array.
/*
char *primes;
primes = calloc(prec + 1, sizeof(char));
for(i = 0; i <= prec; i++) {
primes[i] = 1;
}
primes[0] = 0;
primes[1] = 0;
p = 2;
while(p*p <= prec) {
j = p*p;
while(j <= prec) {
primes[j] = 0;
j += p;
}
p += 1;
while(primes[p] != 1)
p += 1;
}
*/
// Now, create the eisenstein series.
// We build up each coefficient using the multiplicative properties of the
// divisor sum function.
fmpz_poly_set_coeff_si(*eis, 0, 1);
for(i = 1; i <= prec; i++)
fmpz_poly_set_coeff_si(*eis, i, bern_fac[k]);
fmpz_init(last);
fmpz_init(last_m1);
fmpz_init(mult);
fmpz_init(fp);
fmpz_init(t_coeff);
fmpz_init(term);
fmpz_init(term_m1);
ee = k - 1;
p = 2;
while(p <= prec) {
p_pow = p;
fmpz_set_ui(fp, p);
fmpz_pow_ui(mult, fp, ee);
fmpz_pow_ui(term, mult, 2);
fmpz_set(last, mult);
while(p_pow <= prec) {
ind = p_pow;
fmpz_sub_ui(term_m1, term, 1);
fmpz_sub_ui(last_m1, last, 1);
while(ind <= prec) {
fmpz_poly_get_coeff_fmpz(t_coeff, *eis, ind);
fmpz_mul(t_coeff, t_coeff, term_m1);
fmpz_divexact(t_coeff, t_coeff, last_m1);
fmpz_poly_set_coeff_fmpz(*eis, ind, t_coeff);
ind += p_pow;
}
p_pow *= p;
fmpz_set(last, term);
fmpz_mul(term, term, mult);
}
p = n_nextprime(p, 1);
}
fmpz_clear(last);
fmpz_clear(last_m1);
fmpz_clear(mult);
fmpz_clear(fp);
fmpz_clear(t_coeff);
fmpz_clear(term);
fmpz_clear(term_m1);
}
int main(int argc, char *argv[])
{
ulong r, s, p, prec, s_prec;
ulong i, m, lambda, char1, char2;
fmpz_poly_t eis, eta, eta_r;
fmpz_t p1, c1, c2, ss1, ss, pp, ppl, pplc;
// input r, s, and the precision desired
if (argc == 4) {
r = atol(argv[1]);
s = atol(argv[2]);
prec = atol(argv[3]);
prec = n_nextprime(prec, 1) - 1;
}
if (argc != 4) {
printf("usage: shimura_coeffs r s n\n");
return EXIT_FAILURE;
}
// Compute the weight of the form f_r_s
lambda = r / 2 + s;
//printf("%d\n", lambda);
// This is the necessary precision of the input
s_prec = (prec + r) * prec * r / 24;
//printf("Necessary precision: %d terms\n", s_prec);
// First compute eta
//printf("Computing eta\n");
fmpz_poly_init(eta);
eta_series(&eta, s_prec);
// Next compute eta^r
//printf("Computing eta^%d\n", r);
fmpz_poly_init(eta_r);
fmpz_poly_pow_trunc(eta_r, eta, r, s_prec);
fmpz_poly_clear(eta);
// Next compute E_s
//printf("Computing E_%d\n", s);
fmpz_poly_init(eis);
if(s != 0) {
eis_series(&eis, s, s_prec);
}
//printf("Computing coefficients\n");
// Instead of computing the product, we will compute each coefficient as
// needed. This is potentially slower, but saves memory.
//
fmpz_init(p1);
fmpz_init(c1);
fmpz_init(c2);
fmpz_init(ss);
fmpz_init(ss1);
// compute alpha(p^2*r)
p = 2;
m = r*p*p;
while(p <= prec) {
fmpz_set_ui(ss1, 0);
if(s != 0) {
for(i = r; i <= m; i += 24) {
if((m - i) % 24 == 0) {
fmpz_poly_get_coeff_fmpz(c1, eta_r, (i - r) / 24);
fmpz_poly_get_coeff_fmpz(c2, eis, (m - i) / 24);
fmpz_addmul(ss1, c1, c2);
}
}
}
else {
if((m - r) % 24 == 0)
fmpz_poly_get_coeff_fmpz(ss1, eta_r, (m - r) / 24);
}
/*
if(p == 199) {
fmpz_print(ss1);
printf("\n");
}
*/
// compute character X12(p)
char1 = n_jacobi(12, p);
// compute character ((-1)^(lambda) * n | p)
if(lambda % 2 == 0) {
char2 = n_jacobi(r, p);
}
else {
char2 = n_jacobi(-r, p);
}
// compute p^(lambda - 1)
fmpz_set_ui(pp, p);
fmpz_pow_ui(ppl, pp, lambda - 1);
fmpz_mul_si(pplc, ppl, char1*char2);
fmpz_add(ss, ss1, pplc);
printf("%d:\t", p);
fmpz_print(ss);
printf("\n");
p = n_nextprime(p, 1);
m = r*p*p;
}
fmpz_clear(p1);
fmpz_clear(c1);
fmpz_clear(c2);
fmpz_clear(ss);
fmpz_clear(ss1);
return EXIT_SUCCESS;
}
int main()
{
flint_rand_t state;
slong nmax, n, bound, count;
mp_limb_t p, pinv, m1, m2;
nmod_poly_t A;
flint_printf("rev....");
fflush(stdout);
flint_randinit(state);
bound = 100000;
p = n_nextprime(UWORD(1) << (FLINT_BITS - 1), 0);
pinv = n_preinvert_limb(p);
nmod_poly_init(A, p);
nmod_poly_set_coeff_ui(A, 1, 1);
nmod_poly_exp_series(A, A, bound);
nmod_poly_shift_right(A, A, 1);
nmod_poly_inv_series(A, A, bound);
m1 = 1;
for (n = 0; n < A->length; n++)
{
A->coeffs[n] = n_mulmod2_preinv(A->coeffs[n], m1, p, pinv);
m1 = n_mulmod2_preinv(m1, n + 1, p, pinv);
}
for (nmax = 0; nmax < bound; nmax = 1.5 * nmax + 2)
{
fmpz_t numer, denom;
bernoulli_rev_t iter;
fmpz_init(numer);
fmpz_init(denom);
nmax += (nmax % 2);
bernoulli_rev_init(iter, nmax);
if (nmax < 8000)
count = 4000;
else
count = 100;
/* flint_printf("nmax = %wd, count = %wd\n", nmax, count); */
for (n = nmax; n >= 0 && count > 0; n -= 2, count--)
{
bernoulli_rev_next(numer, denom, iter);
m1 = fmpz_fdiv_ui(numer, p);
m2 = fmpz_fdiv_ui(denom, p);
m2 = n_invmod(m2, p);
m1 = n_mulmod2_preinv(m1, m2, p, pinv);
m2 = nmod_poly_get_coeff_ui(A, n);
if (m1 != m2)
{
flint_printf("FAIL:\n");
flint_printf("nmax = %wd, n = %wd\n", nmax, n);
flint_printf("m1 = %wu mod %wu\n", m1, p);
flint_printf("m2 = %wu mod %wu\n", m2, p);
abort();
}
}
bernoulli_rev_clear(iter);
fmpz_clear(numer);
fmpz_clear(denom);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("sqrtmod....");
fflush(stdout);
for (i = 0; i < 100 * flint_test_multiplier(); i++) /* Test random integers */
{
int ans;
fmpz_t a, b, c, p;
mp_limb_t prime;
prime = n_randint(state, UWORD(1) << (FLINT_BITS - 1));
prime = n_nextprime(prime, 1);
fmpz_init(a);
fmpz_init(b);
fmpz_init(c);
fmpz_init(p);
fmpz_set_ui(p, prime);
fmpz_randm(a, state, p);
ans = fmpz_sqrtmod(b, a, p);
fmpz_mul(c, b, b);
fmpz_mod(c, c, p);
result = (ans == 0 || fmpz_equal(a, c));
if (!result)
{
flint_printf("FAIL (random):\n");
flint_printf("p = "), fmpz_print(p), flint_printf("\n");
flint_printf("a = "), fmpz_print(a), flint_printf("\n");
flint_printf("b = "), fmpz_print(b), flint_printf("\n");
flint_printf("c = "), fmpz_print(c), flint_printf("\n");
abort();
}
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(c);
fmpz_clear(p);
}
for (i = 0; i < 100 * flint_test_multiplier(); i++) /* Test random squares */
{
int ans;
fmpz_t a, b, c, d, p;
mp_limb_t prime;
prime = n_randint(state, UWORD(1) << (FLINT_BITS - 1));
prime = n_nextprime(prime, 1);
fmpz_init(a);
fmpz_init(b);
fmpz_init(c);
fmpz_init(d);
fmpz_init(p);
fmpz_set_ui(p, prime);
do
fmpz_randm(b, state, p);
while (fmpz_is_zero(b));
fmpz_mul(a, b, b);
fmpz_mod(a, a, p);
/* check a special case */
if (i == 0)
{
fmpz_set_str(p, "15951355998396157", 10);
fmpz_set_str(a, "7009303413761286", 10);
}
ans = fmpz_sqrtmod(c, a, p);
fmpz_mul(d, c, c);
fmpz_mod(d, d, p);
result = (ans && fmpz_equal(a, d));
if (!result)
{
flint_printf("FAIL (squares):\n");
flint_printf("p = "), fmpz_print(p), flint_printf("\n");
flint_printf("a (= b^2) = "), fmpz_print(a), flint_printf("\n");
flint_printf("b = "), fmpz_print(b), flint_printf("\n");
flint_printf("c (= sqrt(a) = "), fmpz_print(c), flint_printf("\n");
flint_printf("d (= c^2) = "), fmpz_print(d), flint_printf("\n");
flint_printf("ans = %d\n", ans);
abort();
}
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(c);
fmpz_clear(d);
fmpz_clear(p);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i;
flint_rand_t state;
printf("CRT_ui_unsigned....");
fflush(stdout);
flint_randinit(state);
for (i = 0; i < 10000; i++)
{
long bits, prime_bits, length, num_primes, j;
fmpz_t mod;
fmpz_poly_t A, B, C;
nmod_poly_t Amod;
mp_limb_t primes[1000];
bits = n_randint(state, 500) + 1;
length = n_randint(state, 30) + 1;
prime_bits = 1 + n_randint(state, FLINT_BITS - 1);
fmpz_poly_init(A);
fmpz_poly_init(B);
fmpz_poly_init(C);
fmpz_poly_randtest_unsigned(A, state, length, bits);
fmpz_init(mod);
num_primes = 0;
primes[0] = n_nextprime(1UL << prime_bits, 0);
fmpz_set_ui(mod, primes[0]);
while (fmpz_bits(mod) <= bits)
{
primes[num_primes + 1] = n_nextprime(primes[num_primes], 0);
fmpz_mul_ui(mod, mod, primes[num_primes + 1]);
num_primes++;
}
num_primes++;
nmod_poly_init(Amod, primes[0]);
fmpz_poly_get_nmod_poly(Amod, A);
fmpz_poly_set_nmod_poly_unsigned(B, Amod);
fmpz_set_ui(mod, primes[0]);
for (j = 1; j < num_primes; j++)
{
nmod_poly_clear(Amod);
nmod_poly_init(Amod, primes[j]);
fmpz_poly_get_nmod_poly(Amod, A);
fmpz_poly_CRT_ui(B, B, mod, Amod, 0);
fmpz_mul_ui(mod, mod, primes[j]);
}
if (!fmpz_poly_equal(B, A))
{
printf("FAIL!\n");
printf("primes: ");
for (j = 0; j < num_primes; j++)
printf("%lu ", primes[j]);
printf("\nA: \n");
fmpz_poly_print(A);
printf("\nB: \n");
fmpz_poly_print(B);
printf("\n");
abort();
}
nmod_poly_clear(Amod);
fmpz_poly_clear(A);
fmpz_poly_clear(B);
fmpz_poly_clear(C);
fmpz_clear(mod);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
