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