int main(void) { int i; mp_size_t j; flint_rand_t state; printf("split/combine_bits...."); fflush(stdout); flint_randinit(state); _flint_rand_init_gmp(state); for (i = 0; i < 10000; i++) { mp_size_t total_limbs = n_randint(state, 1000) + 1; mp_limb_t * in = flint_malloc(total_limbs*sizeof(mp_limb_t)); mp_limb_t * out = flint_calloc(total_limbs, sizeof(mp_limb_t)); mp_bitcnt_t bits = n_randint(state, 200) + 1; mp_size_t limbs = (2*bits - 1)/FLINT_BITS + 1; long length = (total_limbs*FLINT_BITS - 1)/bits + 1; mp_limb_t ** poly; poly = flint_malloc(length*sizeof(mp_limb_t *)); for (j = 0; j < length; j++) poly[j] = flint_malloc((limbs + 1)*sizeof(mp_limb_t)); mpn_urandomb(in, state->gmp_state, total_limbs*FLINT_BITS); fft_split_bits(poly, in, total_limbs, bits, limbs); fft_combine_bits(out, poly, length, bits, limbs, total_limbs); for (j = 0; j < total_limbs; j++) { if (in[j] != out[j]) { printf("FAIL:\n"); printf("Error in limb %ld, %lu != %lu\n", j, in[j], out[j]); abort(); } } flint_free(in); flint_free(out); for (j = 0; j < length; j++) flint_free(poly[j]); flint_free(poly); } flint_randclear(state); printf("PASS\n"); return 0; }
int main(void) { mp_bitcnt_t depth, w; mp_size_t iters, j; double truncation; FLINT_TEST_INIT(state); flint_printf("mul_mfa_truncate_sqrt2...."); fflush(stdout); _flint_rand_init_gmp(state); depth = 13; w = 2; iters = 1; truncation = 0.5; { mp_size_t n = (UWORD(1)<<depth); mp_bitcnt_t bits1 = (n*w - (depth + 1))/2; mp_bitcnt_t bits = 2*n*bits1; mp_size_t int_limbs = ((mp_size_t)(truncation*bits))/FLINT_BITS; mp_size_t j; mp_limb_t * i1, *i2, *r1, *r2; flint_printf("limbs = %wd\n", int_limbs); i1 = flint_malloc(6*int_limbs*sizeof(mp_limb_t)); i2 = i1 + int_limbs; r1 = i2 + int_limbs; r2 = r1 + 2*int_limbs; flint_mpn_urandomb(i1, state->gmp_state, int_limbs*FLINT_BITS); flint_mpn_urandomb(i2, state->gmp_state, int_limbs*FLINT_BITS); for (j = 0; j < iters; j++) mul_mfa_truncate_sqrt2(r1, i1, int_limbs, i2, int_limbs, depth, w); //mpn_mul(r2, i1, int_limbs, i2, int_limbs); flint_free(i1); } flint_randclear(state); flint_printf("done\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; }
int main() { slong iter; flint_rand_t state; flint_printf("atan_taylor_rs...."); fflush(stdout); flint_randinit(state); _flint_rand_init_gmp(state); for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++) { mp_ptr x, y1, y2, t; mp_limb_t err1, err2; ulong N; mp_size_t xn; int alternating, cmp, result; N = n_randint(state, 256); alternating = n_randint(state, 2); xn = 1 + n_randint(state, 20); x = flint_malloc(sizeof(mp_limb_t) * xn); y1 = flint_malloc(sizeof(mp_limb_t) * xn); y2 = flint_malloc(sizeof(mp_limb_t) * xn); t = flint_malloc(sizeof(mp_limb_t) * xn); flint_mpn_rrandom(x, state->gmp_state, xn); x[xn - 1] &= (LIMB_ONES >> 4); _arb_atan_taylor_naive(y1, &err1, x, xn, N, alternating); _arb_atan_taylor_rs(y2, &err2, x, xn, N, alternating); cmp = mpn_cmp(y1, y2, xn); if (cmp == 0) { result = 1; } else if (cmp > 0) { mpn_sub_n(t, y1, y2, xn); result = flint_mpn_zero_p(t + 1, xn - 1) && (t[0] <= err2); } else { mpn_sub_n(t, y2, y1, xn); result = flint_mpn_zero_p(t + 1, xn - 1) && (t[0] <= err2); } if (!result) { flint_printf("FAIL\n"); flint_printf("N = %wd xn = %wd alternating = %d\n", N, xn, alternating); flint_printf("x ="); flint_mpn_debug(x, xn); flint_printf("y1 ="); flint_mpn_debug(y1, xn); flint_printf("y2 ="); flint_mpn_debug(y2, xn); abort(); } flint_free(x); flint_free(y1); flint_free(y2); flint_free(t); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main(void) { mp_bitcnt_t depth, w; flint_rand_t state; printf("fft/ifft_mfa_truncate_sqrt2...."); fflush(stdout); flint_randinit(state); _flint_rand_init_gmp(state); for (depth = 6; depth <= 13; depth++) { for (w = 1; w <= 5; w++) { mp_size_t n = (1UL<<depth); mp_size_t trunc = 2*n + n_randint(state, 2*n) + 1; mp_size_t n1 = (1UL<<(depth/2)); mp_size_t limbs = (n*w)/GMP_LIMB_BITS; mp_size_t size = limbs + 1; mp_size_t i; mp_limb_t * ptr; mp_limb_t ** ii, ** jj, * t1, * t2, * s1; trunc = 2*n1*((trunc + 2*n1 - 1)/(2*n1)); ii = flint_malloc((4*(n + n*size) + 3*size)*sizeof(mp_limb_t)); for (i = 0, ptr = (mp_limb_t *) ii + 4*n; i < 4*n; i++, ptr += size) { ii[i] = ptr; random_fermat(ii[i], state, limbs); } t1 = ptr; t2 = t1 + size; s1 = t2 + size; for (i = 0; i < 4*n; i++) mpn_normmod_2expp1(ii[i], limbs); jj = flint_malloc(4*(n + n*size)*sizeof(mp_limb_t)); for (i = 0, ptr = (mp_limb_t *) jj + 4*n; i < 4*n; i++, ptr += size) { jj[i] = ptr; mpn_copyi(jj[i], ii[i], size); } fft_mfa_truncate_sqrt2(ii, n, w, &t1, &t2, &s1, n1, trunc); ifft_mfa_truncate_sqrt2(ii, n, w, &t1, &t2, &s1, n1, trunc); for (i = 0; i < trunc; i++) { mpn_div_2expmod_2expp1(ii[i], ii[i], limbs, depth + 2); mpn_normmod_2expp1(ii[i], limbs); } for (i = 0; i < trunc; i++) { if (mpn_cmp(ii[i], jj[i], size) != 0) { printf("FAIL:\n"); printf("n = %ld, trunc = %ld\n", n, trunc); printf("Error in entry %ld\n", i); abort(); } } flint_free(ii); flint_free(jj); } } flint_randclear(state); printf("PASS\n"); return 0; }
int main(void) { mp_bitcnt_t depth, w; flint_rand_t state; printf("fft/ifft_radix2...."); fflush(stdout); flint_randinit(state); _flint_rand_init_gmp(state); for (depth = 6; depth <= 12; depth++) { for (w = 1; w <= 5; w++) { mp_size_t n = (1UL<<depth); mp_size_t limbs = (n*w)/GMP_LIMB_BITS; mp_size_t size = limbs + 1; mp_size_t i; mp_limb_t * ptr; mp_limb_t ** ii, ** jj, *t1, *t2; ii = flint_malloc((2*(n + n*size) + 2*size)*sizeof(mp_limb_t)); for (i = 0, ptr = (mp_limb_t *) ii + 2*n; i < 2*n; i++, ptr += size) { ii[i] = ptr; random_fermat(ii[i], state, limbs); } t1 = ptr; t2 = t1 + size; for (i = 0; i < 2*n; i++) mpn_normmod_2expp1(ii[i], limbs); jj = flint_malloc(2*(n + n*size)*sizeof(mp_limb_t)); for (i = 0, ptr = (mp_limb_t *) jj + 2*n; i < 2*n; i++, ptr += size) { jj[i] = ptr; mpn_copyi(jj[i], ii[i], size); } fft_radix2(ii, n, w, &t1, &t2); ifft_radix2(ii, n, w, &t1, &t2); for (i = 0; i < 2*n; i++) { mpn_div_2expmod_2expp1(ii[i], ii[i], limbs, depth + 1); mpn_normmod_2expp1(ii[i], limbs); } for (i = 0; i < 2*n; i++) { if (mpn_cmp(ii[i], jj[i], size) != 0) { printf("FAIL:\n"); printf("Error in entry %ld\n", i); abort(); } } flint_free(ii); flint_free(jj); } } flint_randclear(state); printf("PASS\n"); return 0; }
int main(void) { mp_size_t c, bits, j, k, x, y, n, w, limbs; mpz_t p, ma, mb, m2a, m2b, mn1, mn2; mp_limb_t * nn1, * nn2, * r1, * r2; flint_rand_t state; printf("butterfly_rshB...."); fflush(stdout); flint_randinit(state); _flint_rand_init_gmp(state); mpz_init(p); mpz_init(ma); mpz_init(mb); mpz_init(m2a); mpz_init(m2b); mpz_init(mn1); mpz_init(mn2); for (bits = FLINT_BITS; bits < 20*FLINT_BITS; bits += FLINT_BITS) { for (j = 1; j < 10; j++) { for (k = 1; k <= FLINT_BITS; k <<= 1) { n = bits/k; w = j*k; limbs = (n*w)/FLINT_BITS; for (c = 0; c < limbs; c++) { x = n_randint(state, limbs); y = n_randint(state, limbs); nn1 = flint_malloc((limbs + 1)*sizeof(mp_limb_t)); nn2 = flint_malloc((limbs + 1)*sizeof(mp_limb_t)); r1 = flint_malloc((limbs + 1)*sizeof(mp_limb_t)); r2 = flint_malloc((limbs + 1)*sizeof(mp_limb_t)); mpn_rrandom(nn1, state->gmp_state, limbs); random_fermat(nn1, state, limbs); random_fermat(nn2, state, limbs); fermat_to_mpz(mn1, nn1, limbs); fermat_to_mpz(mn2, nn2, limbs); set_p(p, n, w); butterfly_rshB(r1, r2, nn1, nn2, limbs, x, y); fermat_to_mpz(m2a, r1, limbs); fermat_to_mpz(m2b, r2, limbs); mpz_mod(m2a, m2a, p); mpz_mod(m2b, m2b, p); ref_butterfly_rshB(ma, mb, mn1, mn2, p, x, y); if (mpz_cmp(ma, m2a) != 0) { printf("FAIL:\n"); printf("butterfly_rshB error a\n"); printf("x = %ld, y = %ld, limbs = %ld\n", x, y, limbs); printf("n = %ld, w = %ld, k = %ld, c = %ld\n", n, w, k, c); gmp_printf("want %Zx\n\n", ma); gmp_printf("got %Zx\n", m2a); abort(); } if (mpz_cmp(mb, m2b) != 0) { printf("FAIL:\n"); printf("butterfly_rshB error b\n"); printf("x = %ld, y = %ld, limbs = %ld\n", x, y, limbs); printf("n = %ld, w = %ld, k = %ld, c = %ld\n", n, w, k, c); gmp_printf("want %Zx\n\n", mb); gmp_printf("got %Zx\n", m2b); abort(); } flint_free(nn1); flint_free(nn2); flint_free(r1); flint_free(r2); } } } } mpz_clear(p); mpz_clear(ma); mpz_clear(mb); mpz_clear(m2a); mpz_clear(m2b); mpz_clear(mn1); mpz_clear(mn2); flint_randclear(state); printf("PASS\n"); return 0; }
int main(void) { mp_bitcnt_t bits; mp_size_t j, k, n, w, limbs; mp_limb_t * nn; mpz_t p, m1, m2; FLINT_TEST_INIT(state); flint_printf("normmod_2expp1...."); fflush(stdout); _flint_rand_init_gmp(state); mpz_init(m1); mpz_init(m2); mpz_init(p); /* normalisation mod p = 2^wn + 1 where B divides nw and n is a power of 2 */ for (bits = FLINT_BITS; bits < 32*FLINT_BITS; bits += FLINT_BITS) { for (j = 1; j < 32; j++) { for (k = 1; k <= GMP_NUMB_BITS; k <<= 1) { n = bits/k; w = j*k; limbs = (n*w)/GMP_LIMB_BITS; nn = flint_malloc((limbs + 1)*sizeof(mp_limb_t)); random_fermat(nn, state, limbs); fermat_to_mpz(m1, nn, limbs); set_p(p, n, w); mpn_normmod_2expp1(nn, limbs); fermat_to_mpz(m2, nn, limbs); mpz_mod(m1, m1, p); if (mpz_cmp(m1, m2) != 0) { flint_printf("FAIL:\n"); flint_printf("mpn_normmod_2expp1 error\n"); gmp_printf("want %Zx\n\n", m1); gmp_printf("got %Zx\n", m2); abort(); } flint_free(nn); } } } mpz_clear(m2); mpz_clear(m1); mpz_clear(p); FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { mp_bitcnt_t depth, w; flint_rand_t state; printf("mul_fft_main...."); fflush(stdout); flint_randinit(state); _flint_rand_init_gmp(state); for (depth = 6; depth <= 13; depth++) { for (w = 1; w <= 3 - (depth >= 12); w++) { int iter = 1 + 200*(depth <= 8) + 80*(depth <= 9) + 10*(depth <= 10), i; for (i = 0; i < iter; i++) { mp_size_t n = (1UL<<depth); mp_bitcnt_t bits1 = (n*w - (depth + 1))/2; mp_size_t len1 = 2*n + n_randint(state, 2*n) + 1; mp_size_t len2 = 2*n + 2 - len1 + n_randint(state, 2*n); mp_bitcnt_t b1 = len1*bits1, b2; mp_size_t n1, n2; mp_size_t j; mp_limb_t * i1, *i2, *r1, *r2; if (len2 <= 0) len2 = 2*n + n_randint(state, 2*n) + 1; b2 = len2*bits1; n1 = (b1 - 1)/FLINT_BITS + 1; n2 = (b2 - 1)/FLINT_BITS + 1; if (n1 < n2) /* ensure b1 >= b2 */ { mp_size_t t = n1; mp_bitcnt_t tb = b1; n1 = n2; b1 = b2; n2 = t; b2 = tb; } i1 = flint_malloc(3*(n1 + n2)*sizeof(mp_limb_t)); i2 = i1 + n1; r1 = i2 + n2; r2 = r1 + n1 + n2; mpn_urandomb(i1, state->gmp_state, b1); mpn_urandomb(i2, state->gmp_state, b2); mpn_mul(r2, i1, n1, i2, n2); mpn_mul_fft_main(r1, i1, n1, i2, n2); for (j = 0; j < n1 + n2; j++) { if (r1[j] != r2[j]) { printf("error in limb %ld, %lx != %lx\n", j, r1[j], r2[j]); abort(); } } flint_free(i1); } } } flint_randclear(state); printf("PASS\n"); return 0; }
int main(void) { mp_bitcnt_t depth, w; int iters; flint_rand_t state; printf("mulmod_2expp1...."); fflush(stdout); flint_randinit(state); _flint_rand_init_gmp(state); for (iters = 0; iters < 100; iters++) { for (depth = 6; depth <= 18; depth++) { for (w = 1; w <= 2; w++) { mp_size_t n = (1UL<<depth); mp_bitcnt_t bits = n*w; mp_size_t int_limbs = bits/FLINT_BITS; mp_size_t j; mp_limb_t c, * i1, * i2, * r1, * r2, * tt; i1 = flint_malloc(6*(int_limbs+1)*sizeof(mp_limb_t)); i2 = i1 + int_limbs + 1; r1 = i2 + int_limbs + 1; r2 = r1 + int_limbs + 1; tt = r2 + int_limbs + 1; random_fermat(i1, state, int_limbs); random_fermat(i2, state, int_limbs); mpn_normmod_2expp1(i1, int_limbs); mpn_normmod_2expp1(i2, int_limbs); fft_mulmod_2expp1(r2, i1, i2, n, w, tt); c = i1[int_limbs] + 2*i2[int_limbs]; c = mpn_mulmod_2expp1(r1, i1, i2, c, int_limbs*FLINT_BITS, tt); for (j = 0; j < int_limbs; j++) { if (r1[j] != r2[j]) { printf("error in limb %ld, %lx != %lx\n", j, r1[j], r2[j]); abort(); } } if (c != r2[int_limbs]) { printf("error in limb %ld, %lx != %lx\n", j, c, r2[j]); abort(); } flint_free(i1); } } } /* test squaring */ for (iters = 0; iters < 100; iters++) { for (depth = 6; depth <= 18; depth++) { for (w = 1; w <= 2; w++) { mp_size_t n = (1UL<<depth); mp_bitcnt_t bits = n*w; mp_size_t int_limbs = bits/FLINT_BITS; mp_size_t j; mp_limb_t c, * i1, * r1, * r2, * tt; i1 = flint_malloc(5*(int_limbs+1)*sizeof(mp_limb_t)); r1 = i1 + int_limbs + 1; r2 = r1 + int_limbs + 1; tt = r2 + int_limbs + 1; random_fermat(i1, state, int_limbs); mpn_normmod_2expp1(i1, int_limbs); fft_mulmod_2expp1(r2, i1, i1, n, w, tt); c = i1[int_limbs] + 2*i1[int_limbs]; c = mpn_mulmod_2expp1(r1, i1, i1, c, int_limbs*FLINT_BITS, tt); for (j = 0; j < int_limbs; j++) { if (r1[j] != r2[j]) { printf("error in limb %ld, %lx != %lx\n", j, r1[j], r2[j]); abort(); } } if (c != r2[int_limbs]) { printf("error in limb %ld, %lx != %lx\n", j, c, r2[j]); abort(); } flint_free(i1); } } } flint_randclear(state); printf("PASS\n"); return 0; }