int test_F_mpn_mul_precache()
{
mp_limb_t * int1, * int2, * product, * product2;
F_mpn_precache_t precache;
mp_limb_t msl;
int result = 1;
unsigned long count;
for (count = 0; (count < 30) && (result == 1); count++)
{
unsigned long limbs2 = randint(2*FLINT_FFT_LIMBS_CROSSOVER)+1;
unsigned long limbs1 = randint(2*FLINT_FFT_LIMBS_CROSSOVER)+1;
int1 = (mp_limb_t *) malloc(sizeof(mp_limb_t)*limbs1);
mpn_random2(int1, limbs1);
F_mpn_mul_precache_init(precache, int1, limbs1, limbs2);
unsigned long count2;
for (count2 = 0; (count2 < 30) && (result == 1); count2++)
{
#if DEBUG
printf("%ld, %ld\n",limbs1, limbs2);
#endif
unsigned long limbs3 = randint(limbs2)+1;
int2 = (mp_limb_t *) malloc(sizeof(mp_limb_t)*limbs3);
product = (mp_limb_t *) malloc(sizeof(mp_limb_t)*(limbs1+limbs2));
product2 = (mp_limb_t *) malloc(sizeof(mp_limb_t)*(limbs1+limbs2));
F_mpn_clear(int2, limbs3);
mpn_random2(int2, limbs3);
F_mpn_mul_precache(product, int2, limbs3, precache);
if (limbs1 > limbs3) msl = mpn_mul(product2, int1, limbs1, int2, limbs3);
else msl = mpn_mul(product2, int2, limbs3, int1, limbs1);
unsigned long j;
for (j = 0; j < limbs1+limbs3 - (msl == 0); j++)
{
if (product[j] != product2[j]) result = 0;
}
free(product2);
free(product);
free(int2);
}
F_mpn_mul_precache_clear(precache);
free(int1);
}
return result;
}
int
main (int argc, char **argv)
{
mp_size_t alloc_size, max_size, size, i, cumul_size;
mp_ptr s1, s2, dx, dy;
int s1_align, s2_align, d_align;
long pass, n_passes;
mp_limb_t cx, cy;
max_size = SIZE;
n_passes = 1000000;
argc--; argv++;
if (argc)
{
max_size = atol (*argv);
argc--; argv++;
}
alloc_size = max_size + 32;
s1 = malloc (alloc_size * BYTES_PER_MP_LIMB);
s2 = malloc (alloc_size * BYTES_PER_MP_LIMB);
dx = malloc (alloc_size * BYTES_PER_MP_LIMB);
dy = malloc (alloc_size * BYTES_PER_MP_LIMB);
cumul_size = 0;
for (pass = 0; pass < n_passes; pass++)
{
size = random () % max_size + 1;
cumul_size += size;
if (cumul_size >= 1000000)
{
cumul_size -= 1000000;
printf ("\r%ld", pass); fflush (stdout);
}
s1_align = random () % 32;
s2_align = random () % 32;
d_align = random () % 32;
mpn_random2 (s1 + s1_align, size);
mpn_random2 (s2 + s2_align, size);
for (i = 0; i < alloc_size; i++)
dx[i] = dy[i] = i + 0x9876500;
cx = TESTCALL (dx + d_align, s1 + s1_align, s2 + s2_align, size);
cy = REFCALL (dy + d_align, s1 + s1_align, s2 + s2_align, size);
if (cx != cy || mpn_cmp (dx, dy, alloc_size) != 0)
abort ();
}
printf ("%ld passes OK\n", n_passes);
exit (0);
}
int
main ()
{
mp_limb_t nptr[2 * SIZE];
mp_limb_t dptr[2 * SIZE];
mp_limb_t qptr[2 * SIZE];
mp_limb_t pptr[2 * SIZE + 1];
mp_limb_t rptr[2 * SIZE];
mp_size_t nsize, dsize, qsize, rsize, psize;
int test;
mp_limb_t qlimb;
for (test = 0; ; test++)
{
printf ("%d\n", test);
#ifdef RANDOM
nsize = random () % (2 * SIZE) + 1;
dsize = random () % nsize + 1;
#else
nsize = 2 * SIZE;
dsize = SIZE;
#endif
mpn_random2 (nptr, nsize);
mpn_random2 (dptr, dsize);
dptr[dsize - 1] |= (mp_limb_t) 1 << (GMP_LIMB_BITS - 1);
MPN_COPY (rptr, nptr, nsize);
qlimb = mpn_divrem (qptr, (mp_size_t) 0, rptr, nsize, dptr, dsize);
rsize = dsize;
qsize = nsize - dsize;
qptr[qsize] = qlimb;
qsize += qlimb;
if (qsize == 0 || qsize > 2 * SIZE)
{
continue; /* bogus */
}
else
{
mp_limb_t cy;
if (qsize > dsize)
mpn_mul (pptr, qptr, qsize, dptr, dsize);
else
mpn_mul (pptr, dptr, dsize, qptr, qsize);
psize = qsize + dsize;
psize -= pptr[psize - 1] == 0;
cy = mpn_add (pptr, pptr, psize, rptr, rsize);
pptr[psize] = cy;
psize += cy;
}
if (nsize != psize || mpn_cmp (nptr, pptr, nsize) != 0)
abort ();
}
}
int
main (int argc, char **argv)
{
mp_ptr ap, bp, rp, refp;
gmp_randstate_ptr rands;
int test;
TMP_DECL;
TMP_MARK;
tests_start ();
rands = RANDS;
ap = TMP_ALLOC_LIMBS (MAX_N);
bp = TMP_ALLOC_LIMBS (MAX_N);
rp = TMP_ALLOC_LIMBS (MAX_N + 2);
refp = TMP_ALLOC_LIMBS (MAX_N + 2);
for (test = 0; test < COUNT; test++)
{
mp_size_t an, bn, rn;
unsigned size_log;
size_log = 1 + gmp_urandomm_ui (rands, SIZE_LOG);
an = 1 + gmp_urandomm_ui(rands, 1L << size_log);
size_log = 1 + gmp_urandomm_ui (rands, SIZE_LOG);
bn = 1 + gmp_urandomm_ui(rands, 1L << size_log);
/* Make sure an >= bn */
if (an < bn)
MP_SIZE_T_SWAP (an, bn);
mpn_random2 (ap, an);
mpn_random2 (bp, bn);
refmpn_mulmid (refp, ap, an, bp, bn);
mpn_mulmid (rp, ap, an, bp, bn);
rn = an + 3 - bn;
if (mpn_cmp (refp, rp, rn))
{
printf ("ERROR in test %d, an = %d, bn = %d, rn = %d\n",
test, (int) an, (int) bn, (int) rn);
printf("a: "); mpn_dump (ap, an);
printf("b: "); mpn_dump (bp, bn);
printf("r: "); mpn_dump (rp, rn);
printf("ref: "); mpn_dump (refp, rn);
abort();
}
}
TMP_FREE;
tests_end ();
return 0;
}
int test_F_mpn_mul()
{
mp_limb_t * int1, * int2, * product, * product2;
mp_limb_t msl, msl2;
int result = 1;
unsigned long count;
for (count = 0; (count < 30) && (result == 1); count++)
{
unsigned long limbs2 = randint(2*FLINT_FFT_LIMBS_CROSSOVER)+1;
unsigned long limbs1 = limbs2 + randint(1000);
int1 = (mp_limb_t *) malloc(sizeof(mp_limb_t)*limbs1);
mpn_random2(int1, limbs1);
unsigned long count2;
for (count2 = 0; (count2 < 30) && (result == 1); count2++)
{
#if DEBUG
printf("%ld, %ld\n",limbs1, limbs2);
#endif
int2 = (mp_limb_t *) malloc(sizeof(mp_limb_t)*limbs2);
product = (mp_limb_t *) malloc(sizeof(mp_limb_t)*(limbs1+limbs2));
product2 = (mp_limb_t *) malloc(sizeof(mp_limb_t)*(limbs1+limbs2));
F_mpn_clear(int2, limbs2);
mpn_random2(int2, randint(limbs2-1)+1);
msl = F_mpn_mul(product, int1, limbs1, int2, limbs2);
msl2 = mpn_mul(product2, int1, limbs1, int2, limbs2);
unsigned long j;
for (j = 0; j < limbs1+limbs2 - (msl == 0); j++)
{
if (product[j] != product2[j]) result = 0;
}
result &= (msl == msl2);
free(product2);
free(product);
free(int2);
}
free(int1);
}
return result;
}
void
data_fill (mp_ptr ptr, mp_size_t size)
{
switch (option_data) {
case DATA_RANDOM:
mpn_random (ptr, size);
break;
case DATA_RANDOM2:
mpn_random2 (ptr, size);
break;
case DATA_ZEROS:
MPN_ZERO (ptr, size);
break;
case DATA_AAS:
MPN_FILL (ptr, size, GMP_NUMB_0xAA);
break;
case DATA_FFS:
MPN_FILL (ptr, size, GMP_NUMB_MAX);
break;
case DATA_2FD:
MPN_FILL (ptr, size, GMP_NUMB_MAX);
ptr[0] -= 2;
break;
default:
abort();
/*NOTREACHED*/
}
}
void
mpfr_random2 (mpfr_ptr x, mp_size_t size, mp_exp_t exp)
{
mp_size_t xn;
unsigned long cnt;
mp_ptr xp = MPFR_MANT(x), yp[1];
mp_size_t prec = (MPFR_PREC(x) - 1)/BITS_PER_MP_LIMB;
MPFR_CLEAR_FLAGS(x);
xn = ABS (size);
if (xn != 0)
{
if (xn > prec + 1)
xn = prec + 1;
mpn_random2 (xp, xn);
}
if (exp != 0) {
/* use mpn_random instead of random since that function is not
available on all platforms (for example HPUX, DEC OSF, ...) */
mpn_random ((mp_limb_t*) yp, 1);
exp = (mp_exp_t) yp[0] % (2 * exp) - exp;
}
count_leading_zeros(cnt, xp[xn - 1]);
if (cnt) mpn_lshift(xp, xp, xn, cnt);
MPFR_EXP(x) = exp-cnt;
cnt = xn*BITS_PER_MP_LIMB - prec;
/* cnt is the number of non significant bits in the low limb */
xp[0] &= ~((MP_LIMB_T_ONE << cnt) - MP_LIMB_T_ONE);
}
void
check_random (int argc, char **argv)
{
double d, d2, nd, dd;
mpq_t q;
mp_limb_t rp[LIMBS_PER_DOUBLE + 1];
int test, reps = 100000;
int i;
if (argc == 2)
reps = 100 * atoi (argv[1]);
mpq_init (q);
for (test = 0; test < reps; test++)
{
mpn_random2 (rp, LIMBS_PER_DOUBLE + 1);
d = 0.0;
for (i = LIMBS_PER_DOUBLE - 1; i >= 0; i--)
d = d * MP_BASE_AS_DOUBLE + rp[i];
d = my_ldexp (d, (int) (rp[LIMBS_PER_DOUBLE] % (2 * MAXEXP)) - MAXEXP);
mpq_set_d (q, d);
nd = mpz_get_d (mpq_numref (q));
dd = mpz_get_d (mpq_denref (q));
d2 = nd / dd;
if (d != d2)
{
printf ("ERROR (check_random test %d): bad mpq_set_d results\n", test);
printf ("%.16g\n", d);
printf ("%.16g\n", d2);
abort ();
}
}
mpq_clear (q);
}
void
mpf_random2 (mpf_ptr x, mp_size_t xs, mp_exp_t exp)
{
mp_size_t xn;
mp_size_t prec;
mp_limb_t elimb;
xn = ABS (xs);
prec = PREC(x);
if (xn == 0)
{
EXP(x) = 0;
SIZ(x) = 0;
return;
}
if (xn > prec + 1)
xn = prec + 1;
/* General random mantissa. */
mpn_random2 (PTR(x), xn);
/* Generate random exponent. */
_gmp_rand (&elimb, RANDS, GMP_NUMB_BITS);
exp = ABS (exp);
exp = elimb % (2 * exp + 1) - exp;
EXP(x) = exp;
SIZ(x) = xs < 0 ? -xn : xn;
}
void fmpz_random_limbs2(fmpz_t x, unsigned long n)
{
if (n == 0)
{
x[0] = 0L;
return;
}
mpn_random2(x + 1, n);
x[0] = n;
}
int test_F_mpn_splitcombine_bits()
{
mp_limb_t * int1, * int2;
ZmodF_poly_t poly;
int result = 1;
unsigned long count;
for (count = 0; (count < 30000) && (result == 1); count++)
{
unsigned long limbs = randint(300)+1;
unsigned long bits = randint(500)+1;
unsigned long coeff_limbs = randint(100) + (bits-1)/FLINT_BITS + 1;
unsigned long length = (FLINT_BITS*limbs - 1)/bits + 1;
unsigned long log_length = 0;
while ((1L << log_length) < length) log_length++;
#if DEBUG
printf("limbs = %ld, bits = %ld, coeff_limbs = %ld\n", limbs, bits, coeff_limbs);
#endif
int1 = (mp_limb_t *) malloc(sizeof(mp_limb_t)*limbs);
int2 = (mp_limb_t *) malloc(sizeof(mp_limb_t)*limbs);
ZmodF_poly_init(poly, log_length, coeff_limbs, 0);
mpn_random2(int1, limbs);
F_mpn_FFT_split_bits(poly, int1, limbs, bits, coeff_limbs);
F_mpn_clear(int2, limbs);
F_mpn_FFT_combine_bits(int2, poly, bits, coeff_limbs, limbs);
#if DEBUG
F_mpn_printx(int1, limbs); printf("\n\n");
unsigned long i;
for (i = 0; i < length; i++) { F_mpn_printx(poly->coeffs[i], coeff_limbs); printf("\n");}
printf("\n");
F_mpn_printx(int2, limbs); printf("\n\n");
#endif
unsigned long j;
for (j = 0; j < limbs; j++)
{
if (int1[j] != int2[j]) result = 0;
}
ZmodF_poly_clear(poly);
free(int2);
free(int1);
}
return result;
}
void
mpz_random2 (mpz_ptr x, mp_size_t size)
{
mp_size_t abs_size;
abs_size = ABS (size);
if (abs_size != 0)
{
if (x->_mp_alloc < abs_size)
_mpz_realloc (x, abs_size);
mpn_random2 (x->_mp_d, abs_size);
}
x->_mp_size = size;
}
/* See that mpz_tstbit matches a twos complement calculated explicitly, for
various low zeros. */
void
check_tstbit (void)
{
#define MAX_ZEROS 3
#define NUM_LIMBS 3
mp_limb_t pos[1+NUM_LIMBS+MAX_ZEROS];
mp_limb_t neg[1+NUM_LIMBS+MAX_ZEROS];
mpz_t z;
unsigned long i;
int zeros, low1;
int got, want;
mpz_init (z);
for (zeros = 0; zeros <= MAX_ZEROS; zeros++)
{
MPN_ZERO (pos, numberof(pos));
mpn_random2 (pos+zeros, NUM_LIMBS);
for (low1 = 0; low1 <= 1; low1++)
{
if (low1)
pos[0] |= 1;
refmpn_neg_n (neg, pos, numberof(neg));
mpz_set_n (z, neg, numberof(neg));
mpz_neg (z, z);
for (i = 0; i < numberof(pos)*GMP_NUMB_BITS; i++)
{
got = mpz_tstbit (z, i);
want = refmpn_tstbit (pos, i);
if (got != want)
{
printf ("wrong at bit %lu, with %d zeros\n", i, zeros);
printf ("z neg "); debug_mp (z, -16);
mpz_set_n (z, pos, numberof(pos));
printf ("pos "); debug_mp (z, -16);
mpz_set_n (z, neg, numberof(neg));
printf ("neg "); debug_mp (z, -16);
exit (1);
}
}
}
}
mpz_clear (z);
}
void
mpf_random2 (mpf_ptr x, mp_size_t size, mp_exp_t exp)
{
mp_size_t asize;
mp_size_t prec = x->_mp_prec;
mp_limb_t elimb;
asize = ABS (size);
if (asize != 0)
{
if (asize > prec + 1)
asize = prec + 1;
mpn_random2 (x->_mp_d, asize);
}
if (exp != 0)
{
_gmp_rand (&elimb, RANDS, GMP_NUMB_BITS);
exp = elimb % (2 * exp) - exp;
}
x->_mp_exp = asize == 0 ? 0 : exp;
x->_mp_size = size < 0 ? -asize : asize;
}
int
main (int argc, char **argv)
{
mp_ptr ip, dp, scratch;
int count = COUNT;
int test;
gmp_randstate_ptr rands;
TMP_DECL;
TMP_MARK;
if (argc > 1)
{
char *end;
count = strtol (argv[1], &end, 0);
if (*end || count <= 0)
{
fprintf (stderr, "Invalid test count: %s.\n", argv[1]);
return 1;
}
}
tests_start ();
rands = RANDS;
dp = TMP_ALLOC_LIMBS (MAX_N);
ip = 1+TMP_ALLOC_LIMBS (MAX_N + 2);
scratch
= 1+TMP_ALLOC_LIMBS (mpn_invert_itch (MAX_N) + 2);
for (test = 0; test < count; test++)
{
unsigned size_min;
unsigned size_range;
mp_size_t n;
mp_size_t itch;
mp_limb_t i_before, i_after, s_before, s_after;
for (size_min = 1; (1L << size_min) < MIN_N; size_min++)
;
/* We generate an in the MIN_N <= n <= (1 << size_range). */
size_range = size_min
+ gmp_urandomm_ui (rands, SIZE_LOG + 1 - size_min);
n = MIN_N
+ gmp_urandomm_ui (rands, (1L << size_range) + 1 - MIN_N);
mpn_random2 (dp, n);
mpn_random2 (ip-1, n + 2);
i_before = ip[-1];
i_after = ip[n];
itch = mpn_invert_itch (n);
ASSERT_ALWAYS (itch <= mpn_invert_itch (MAX_N));
mpn_random2 (scratch-1, itch+2);
s_before = scratch[-1];
s_after = scratch[itch];
dp[n-1] |= GMP_NUMB_HIGHBIT;
mpn_invert (ip, dp, n, scratch);
if (ip[-1] != i_before || ip[n] != i_after
|| scratch[-1] != s_before || scratch[itch] != s_after
|| ! invert_valid(ip, dp, n))
{
printf ("ERROR in test %d, n = %d\n",
test, (int) n);
if (ip[-1] != i_before)
{
printf ("before ip:"); mpn_dump (ip -1, 1);
printf ("keep: "); mpn_dump (&i_before, 1);
}
if (ip[n] != i_after)
{
printf ("after ip:"); mpn_dump (ip + n, 1);
printf ("keep: "); mpn_dump (&i_after, 1);
}
if (scratch[-1] != s_before)
{
printf ("before scratch:"); mpn_dump (scratch-1, 1);
printf ("keep: "); mpn_dump (&s_before, 1);
}
if (scratch[itch] != s_after)
{
printf ("after scratch:"); mpn_dump (scratch + itch, 1);
printf ("keep: "); mpn_dump (&s_after, 1);
}
mpn_dump (dp, n);
mpn_dump (ip, n);
abort();
}
}
TMP_FREE;
tests_end ();
return 0;
}
void mpfq_p_127_735_random2(mpfq_p_127_735_src_field k, mpfq_p_127_735_dst_elt r) {
mpn_random2(r, 2);
mpfq_p_127_735_normalize(k, r);
}
int
main (int argc, char **argv)
{
gmp_randstate_ptr rands;
mp_ptr ap, rp, pp, scratch;
int count = COUNT;
unsigned i;
TMP_DECL;
TMP_MARK;
if (argc > 1)
{
char *end;
count = strtol (argv[1], &end, 0);
if (*end || count <= 0)
{
fprintf (stderr, "Invalid test count: %s.\n", argv[1]);
return 1;
}
}
tests_start ();
rands = RANDS;
ap = TMP_ALLOC_LIMBS (MAX_LIMBS);
rp = TMP_ALLOC_LIMBS (MAX_LIMBS);
pp = TMP_ALLOC_LIMBS (MAX_LIMBS);
scratch = TMP_ALLOC_LIMBS (3*MAX_LIMBS); /* For mpn_powlo */
for (i = 0; i < count; i++)
{
mp_size_t n;
mp_limb_t k;
int c;
n = 1 + gmp_urandomm_ui (rands, MAX_LIMBS);
if (i & 1)
mpn_random2 (ap, n);
else
mpn_random (ap, n);
ap[0] |= 1;
if (i < 100)
k = 3 + 2*i;
else
{
mpn_random (&k, 1);
if (k < 3)
k = 3;
else
k |= 1;
}
mpn_broot (rp, ap, n, k);
mpn_powlo (pp, rp, &k, 1, n, scratch);
MPN_CMP (c, ap, pp, n);
if (c != 0)
{
gmp_fprintf (stderr,
"mpn_broot returned bad result: %u limbs\n",
(unsigned) n);
gmp_fprintf (stderr, "k = %Mx\n", k);
gmp_fprintf (stderr, "a = %Nx\n", ap, n);
gmp_fprintf (stderr, "r = %Nx\n", rp, n);
gmp_fprintf (stderr, "r^n = %Nx\n", pp, n);
abort ();
}
}
TMP_FREE;
tests_end ();
return 0;
}
int
main (int argc, char **argv)
{
mp_ptr ap, bp, rp, refp;
mp_size_t max_n, n;
gmp_randstate_ptr rands;
long test, reps = 1000;
TMP_SDECL;
TMP_SMARK;
tests_start ();
TESTS_REPS (reps, argv, argc);
rands = RANDS;
max_n = 32;
ap = TMP_SALLOC_LIMBS (max_n);
bp = TMP_SALLOC_LIMBS (max_n);
rp = TMP_SALLOC_LIMBS (max_n);
refp = TMP_SALLOC_LIMBS (max_n);
for (test = 0; test < reps; test++)
{
for (n = 1; n <= max_n; n++)
{
mpn_random2 (ap, n);
mpn_random2 (bp, n);
refmpn_and_n (refp, ap, bp, n);
mpn_and_n (rp, ap, bp, n);
check_one (refp, rp, ap, bp, n, "and_n");
refmpn_ior_n (refp, ap, bp, n);
mpn_ior_n (rp, ap, bp, n);
check_one (refp, rp, ap, bp, n, "ior_n");
refmpn_xor_n (refp, ap, bp, n);
mpn_xor_n (rp, ap, bp, n);
check_one (refp, rp, ap, bp, n, "xor_n");
refmpn_andn_n (refp, ap, bp, n);
mpn_andn_n (rp, ap, bp, n);
check_one (refp, rp, ap, bp, n, "andn_n");
refmpn_iorn_n (refp, ap, bp, n);
mpn_iorn_n (rp, ap, bp, n);
check_one (refp, rp, ap, bp, n, "iorn_n");
refmpn_nand_n (refp, ap, bp, n);
mpn_nand_n (rp, ap, bp, n);
check_one (refp, rp, ap, bp, n, "nand_n");
refmpn_nior_n (refp, ap, bp, n);
mpn_nior_n (rp, ap, bp, n);
check_one (refp, rp, ap, bp, n, "nior_n");
refmpn_xnor_n (refp, ap, bp, n);
mpn_xnor_n (rp, ap, bp, n);
check_one (refp, rp, ap, bp, n, "xnor_n");
refmpn_com (refp, ap, n);
mpn_com (rp, ap, n);
check_one (refp, rp, ap, bp, n, "com");
}
}
TMP_SFREE;
tests_end ();
return 0;
}
int
main (int argc, char **argv)
{
mp_ptr ap, bp, refp, pp, scratch;
int count = COUNT;
int test;
gmp_randstate_ptr rands;
TMP_DECL;
TMP_MARK;
if (argc > 1)
{
char *end;
count = strtol (argv[1], &end, 0);
if (*end || count <= 0)
{
fprintf (stderr, "Invalid test count: %s.\n", argv[1]);
return 1;
}
}
tests_start ();
rands = RANDS;
#define mpn_mullo_itch(n) (0)
ap = TMP_ALLOC_LIMBS (MAX_N);
bp = TMP_ALLOC_LIMBS (MAX_N);
refp = TMP_ALLOC_LIMBS (MAX_N * 2);
pp = 1+TMP_ALLOC_LIMBS (MAX_N + 2);
scratch
= 1+TMP_ALLOC_LIMBS (mpn_mullo_itch (MAX_N) + 2);
for (test = 0; test < count; test++)
{
unsigned size_min;
unsigned size_range;
mp_size_t n;
mp_size_t itch;
mp_limb_t p_before, p_after, s_before, s_after;
for (size_min = 1; (1L << size_min) < MIN_N; size_min++)
;
/* We generate an in the MIN_N <= n <= (1 << size_range). */
size_range = size_min
+ gmp_urandomm_ui (rands, SIZE_LOG + 1 - size_min);
n = MIN_N
+ gmp_urandomm_ui (rands, (1L << size_range) + 1 - MIN_N);
mpn_random2 (ap, n);
mpn_random2 (bp, n);
mpn_random2 (pp-1, n + 2);
p_before = pp[-1];
p_after = pp[n];
itch = mpn_mullo_itch (n);
ASSERT_ALWAYS (itch <= mpn_mullo_itch (MAX_N));
mpn_random2 (scratch-1, itch+2);
s_before = scratch[-1];
s_after = scratch[itch];
mpn_mullo_n (pp, ap, bp, n);
mpn_mul_n (refp, ap, bp, n);
if (pp[-1] != p_before || pp[n] != p_after
|| scratch[-1] != s_before || scratch[itch] != s_after
|| mpn_cmp (refp, pp, n) != 0)
{
printf ("ERROR in test %d, n = %d",
test, (int) n);
if (pp[-1] != p_before)
{
printf ("before pp:"); mpn_dump (pp -1, 1);
printf ("keep: "); mpn_dump (&p_before, 1);
}
if (pp[n] != p_after)
{
printf ("after pp:"); mpn_dump (pp + n, 1);
printf ("keep: "); mpn_dump (&p_after, 1);
}
if (scratch[-1] != s_before)
{
printf ("before scratch:"); mpn_dump (scratch-1, 1);
printf ("keep: "); mpn_dump (&s_before, 1);
}
if (scratch[itch] != s_after)
{
printf ("after scratch:"); mpn_dump (scratch + itch, 1);
printf ("keep: "); mpn_dump (&s_after, 1);
}
mpn_dump (ap, n);
mpn_dump (bp, n);
mpn_dump (pp, n);
mpn_dump (refp, n);
abort();
}
}
TMP_FREE;
tests_end ();
return 0;
}
int test_F_mpn_mul_precache_trunc()
{
mp_limb_t * int1, * int2, * product, * product2;
F_mpn_precache_t precache;
mp_limb_t msl;
int result = 1;
unsigned long count;
for (count = 0; (count < 30) && (result == 1); count++)
{
unsigned long limbs2 = randint(2*FLINT_FFT_LIMBS_CROSSOVER)+1;
unsigned long limbs1 = randint(2*FLINT_FFT_LIMBS_CROSSOVER)+1;
int1 = (mp_limb_t *) malloc(sizeof(mp_limb_t)*limbs1);
mpn_random2(int1, limbs1);
F_mpn_mul_precache_init(precache, int1, limbs1, limbs2);
unsigned long count2;
for (count2 = 0; (count2 < 30) && (result == 1); count2++)
{
unsigned long limbs3 = randint(limbs2)+1;
unsigned long trunc = randint(2*(limbs1+limbs3));
#if DEBUG
printf("limbs1 = %ld, limbs3 = %ld, trunc = %ld\n", limbs1, limbs3, trunc);
#endif
int2 = (mp_limb_t *) malloc(sizeof(mp_limb_t)*limbs3);
product = (mp_limb_t *) malloc(sizeof(mp_limb_t)*(limbs1+limbs2));
product2 = (mp_limb_t *) malloc(sizeof(mp_limb_t)*(limbs1+limbs2));
F_mpn_clear(int2, limbs3);
mpn_random2(int2, limbs3);
if (limbs1 > limbs3) F_mpn_mul_trunc(product2, int1, limbs1, int2, limbs3, trunc);
else F_mpn_mul_trunc(product2, int2, limbs3, int1, limbs1, trunc);
F_mpn_mul_precache_trunc(product, int2, limbs3, precache, trunc);
unsigned long j;
for (j = 0; j < FLINT_MIN(trunc, limbs1+limbs3); j++)
{
if (product[j] != product2[j])
{
printf("Failure at %ld\n", j);
result = 0;
}
}
free(product2);
free(product);
free(int2);
}
F_mpn_mul_precache_clear(precache);
free(int1);
}
return result;
}
