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; }