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