int
main(void)
{
int i, result;
flint_rand_t state;
printf("is_zero....");
fflush(stdout);
flint_randinit(state);
/* Check zero vector */
for (i = 0; i < 10000; i++)
{
fmpz *a;
long len = n_randint(state, 100);
a = _fmpz_vec_init(len);
_fmpz_vec_randtest(a, state, len, 200);
_fmpz_vec_zero(a, len);
result = (_fmpz_vec_is_zero(a, len));
if (!result)
{
printf("FAIL1:\n");
_fmpz_vec_print(a, len), printf("\n\n");
abort();
}
_fmpz_vec_clear(a, len);
}
/* Check non-zero vector */
for (i = 0; i < 10000; i++)
{
fmpz *a;
long len = n_randint(state, 100) + 1;
a = _fmpz_vec_init(len);
_fmpz_vec_randtest(a, state, len, 200);
fmpz_set_ui(a + (len - 1), 1UL);
result = (!_fmpz_vec_is_zero(a, len));
if (!result)
{
printf("FAIL2:\n");
_fmpz_vec_print(a, len), printf("\n\n");
abort();
}
_fmpz_vec_clear(a, len);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("scalar_submul_si_2exp....");
fflush(stdout);
/* Compare with alternative method of computation */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpz *a, *b, *c, *d;
slong len = n_randint(state, 100), x;
mp_bitcnt_t exp;
a = _fmpz_vec_init(len);
b = _fmpz_vec_init(len);
c = _fmpz_vec_init(len);
d = _fmpz_vec_init(len);
_fmpz_vec_randtest(a, state, len, 200);
_fmpz_vec_randtest(b, state, len, 200);
_fmpz_vec_set(c, b, len);
x = z_randtest(state);
exp = n_randint(state, 200);
_fmpz_vec_scalar_submul_si_2exp(b, a, len, x, exp);
_fmpz_vec_scalar_mul_2exp(d, a, len, exp);
_fmpz_vec_scalar_submul_si(c, d, len, x);
result = (_fmpz_vec_equal(b, c, len));
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("x = %wd, exp = %wu\n", x, exp);
_fmpz_vec_print(b, len), flint_printf("\n\n");
_fmpz_vec_print(c, len), flint_printf("\n\n");
abort();
}
_fmpz_vec_clear(a, len);
_fmpz_vec_clear(b, len);
_fmpz_vec_clear(c, len);
_fmpz_vec_clear(d, len);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("prod....");
fflush(stdout);
flint_randinit(state);
for (i = 0; i < 10000; i++)
{
fmpz *a, *b;
fmpz_t x, y, z;
long len1 = n_randint(state, 100);
long len2 = n_randint(state, 100);
a = _fmpz_vec_init(len1 + len2);
b = a + len1;
_fmpz_vec_randtest(a, state, len1 + len2, 200);
fmpz_init(x);
fmpz_init(y);
fmpz_init(z);
_fmpz_vec_prod(x, a, len1);
_fmpz_vec_prod(y, b, len2);
fmpz_mul(x, x, y);
_fmpz_vec_prod(z, a, len1 + len2);
result = (fmpz_equal(x, z));
if (!result)
{
printf("FAIL:\n");
_fmpz_vec_print(a, len1), printf("\n\n");
_fmpz_vec_print(b, len2), printf("\n\n");
abort();
}
_fmpz_vec_clear(a, len1 + len2);
fmpz_clear(x);
fmpz_clear(y);
fmpz_clear(z);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("content....");
fflush(stdout);
/* Check that content(a f) = abs(a) content(f) */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpz_t a, c, d;
fmpz *f;
slong len = n_randint(state, 100);
fmpz_init(a);
fmpz_init(c);
fmpz_init(d);
f = _fmpz_vec_init(len);
_fmpz_vec_randtest(f, state, len, 200);
fmpz_randtest(a, state, 100);
_fmpz_vec_content(c, f, len);
_fmpz_vec_scalar_mul_fmpz(f, f, len, a);
fmpz_abs(a, a);
fmpz_mul(c, a, c);
_fmpz_vec_content(d, f, len);
result = (fmpz_equal(c, d));
if (!result)
{
flint_printf("FAIL:\n");
fmpz_print(c), flint_printf("\n\n");
fmpz_print(d), flint_printf("\n\n");
abort();
}
fmpz_clear(a);
fmpz_clear(c);
fmpz_clear(d);
_fmpz_vec_clear(f, len);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
void fmpq_poly_randtest(fmpq_poly_t poly, flint_rand_t state,
long len, mp_bitcnt_t bits)
{
ulong m;
m = n_randlimb(NULL);
fmpq_poly_fit_length(poly, len);
_fmpq_poly_set_length(poly, len);
if (m & 1UL)
{
_fmpz_vec_randtest(poly->coeffs, state, len, bits);
}
else
{
fmpz_t x;
fmpz_init(x);
fmpz_randtest(x, state, bits / 2);
_fmpz_vec_randtest(poly->coeffs, state, len, (bits + 1) / 2);
_fmpz_vec_scalar_mul_fmpz(poly->coeffs, poly->coeffs, len, x);
fmpz_clear(x);
}
if (m & 2UL)
{
fmpz_randtest_not_zero(poly->den, state, FLINT_MAX(bits, 1));
fmpz_abs(poly->den, poly->den);
fmpq_poly_canonicalise(poly);
}
else
{
fmpz_set_ui(poly->den, 1);
_fmpq_poly_normalise(poly);
}
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("height....");
fflush(stdout);
flint_randinit(state);
for (i = 0; i < 10000; i++)
{
fmpz *a;
fmpz_t h;
long len, bits, bits2;
fmpz_init(h);
len = n_randint(state, 100);
a = _fmpz_vec_init(len);
bits = n_randint(state, 200);
_fmpz_vec_randtest(a, state, len, bits);
bits2 = _fmpz_vec_max_bits(a, len);
_fmpz_vec_height(h, a, len);
result = (fmpz_bits(h) == FLINT_ABS(bits2)) && (fmpz_sgn(h) >= 0);
if (!result)
{
printf("FAIL:\n");
printf("bits = %ld, bits2 = %ld\n", bits, bits2);
printf("Computed height:\n");
fmpz_print(h);
printf("\n");
abort();
}
fmpz_clear(h);
_fmpz_vec_clear(a, len);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("max_bits....");
fflush(stdout);
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpz *a;
slong len, bits, bits2, bits3;
len = n_randint(state, 100);
a = _fmpz_vec_init(len);
bits = n_randint(state, 200);
_fmpz_vec_randtest(a, state, len, bits);
bits2 = _fmpz_vec_max_bits(a, len);
bits3 = _fmpz_vec_max_bits_ref(a, len);
result = (bits >= FLINT_ABS(bits2) && bits2 == bits3);
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("bits = %wd, bits2 = %wd bits3 = %wd\n", bits, bits2, bits3);
abort();
}
_fmpz_vec_clear(a, len);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("get/set_fft....");
fflush(stdout);
flint_randinit(state);
/* convert back and forth and compare */
for (i = 0; i < 10000; i++)
{
fmpz * a, * b;
mp_bitcnt_t bits;
long len, limbs;
mp_limb_t ** ii, * ptr;
long i, bt;
bits = n_randint(state, 300) + 1;
len = n_randint(state, 300) + 1;
limbs = 2*((bits - 1)/FLINT_BITS + 1);
ii = flint_malloc((len + len*(limbs + 1))*sizeof(mp_limb_t));
ptr = (mp_limb_t *) ii + len;
for (i = 0; i < len; i++, ptr += (limbs + 1))
ii[i] = ptr;
a = _fmpz_vec_init(len);
b = _fmpz_vec_init(len);
_fmpz_vec_randtest(a, state, len, bits);
bt = _fmpz_vec_get_fft(ii, a, limbs, len);
for (i = 0; i < len; i++)
mpn_normmod_2expp1(ii[i], limbs);
_fmpz_vec_set_fft(b, len, ii, limbs, bt < 0);
result = (_fmpz_vec_equal(a, b, len));
if (!result)
{
printf("FAIL:\n");
_fmpz_vec_print(a, len), printf("\n\n");
_fmpz_vec_print(b, len), printf("\n\n");
abort();
}
_fmpz_vec_clear(a, len);
_fmpz_vec_clear(b, len);
}
/* convert back and forth unsigned and compare */
for (i = 0; i < 10000; i++)
{
fmpz * a, * b;
mp_bitcnt_t bits;
long len, limbs;
mp_limb_t ** ii, * ptr;
long i, bt;
bits = n_randint(state, 300) + 1;
len = n_randint(state, 300) + 1;
limbs = 2*((bits - 1)/FLINT_BITS + 1);
ii = flint_malloc((len + len*(limbs + 1))*sizeof(mp_limb_t));
ptr = (mp_limb_t *) ii + len;
for (i = 0; i < len; i++, ptr += (limbs + 1))
ii[i] = ptr;
a = _fmpz_vec_init(len);
b = _fmpz_vec_init(len);
_fmpz_vec_randtest_unsigned(a, state, len, bits);
bt = _fmpz_vec_get_fft(ii, a, limbs, len);
_fmpz_vec_set_fft(b, len, ii, limbs, bt < 0);
result = (_fmpz_vec_equal(a, b, len));
if (!result)
{
printf("FAIL:\n");
_fmpz_vec_print(a, len), printf("\n\n");
_fmpz_vec_print(b, len), printf("\n\n");
abort();
}
_fmpz_vec_clear(a, len);
_fmpz_vec_clear(b, len);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("scalar_divexact_ui....");
fflush(stdout);
/* Check aliasing of a and b */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpz *a, *b;
ulong n = n_randtest_not_zero(state);
slong len = n_randint(state, 100);
a = _fmpz_vec_init(len);
b = _fmpz_vec_init(len);
_fmpz_vec_randtest(a, state, len, 200);
_fmpz_vec_scalar_mul_ui(a, a, len, n);
_fmpz_vec_scalar_divexact_ui(b, a, len, n);
_fmpz_vec_scalar_divexact_ui(a, a, len, n);
result = (_fmpz_vec_equal(a, b, len));
if (!result)
{
flint_printf("FAIL:\n");
_fmpz_vec_print(a, len), flint_printf("\n\n");
_fmpz_vec_print(b, len), flint_printf("\n\n");
abort();
}
_fmpz_vec_clear(a, len);
_fmpz_vec_clear(b, len);
}
/* Check that a * n / n == a */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpz *a, *b;
ulong n = n_randtest_not_zero(state);
slong len = n_randint(state, 100);
a = _fmpz_vec_init(len);
b = _fmpz_vec_init(len);
_fmpz_vec_randtest(a, state, len, 200);
_fmpz_vec_set(b, a, len);
_fmpz_vec_scalar_mul_ui(a, a, len, n);
_fmpz_vec_scalar_divexact_ui(a, a, len, n);
result = (_fmpz_vec_equal(a, b, len));
if (!result)
{
flint_printf("FAIL:\n");
_fmpz_vec_print(a, len), flint_printf("\n\n");
_fmpz_vec_print(b, len), flint_printf("\n\n");
abort();
}
_fmpz_vec_clear(a, len);
_fmpz_vec_clear(b, len);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("scalar_submul_fmpz....");
fflush(stdout);
flint_randinit(state);
/* Compare with fmpz_vec_scalar_submul_si */
for (i = 0; i < 10000; i++)
{
fmpz *a, *b, *c;
long len, n;
fmpz_t n1;
len = n_randint(state, 100);
n = (long) n_randbits(state, FLINT_BITS - 1);
if (n_randint(state, 2))
n = -n;
fmpz_init(n1);
fmpz_set_si(n1, n);
a = _fmpz_vec_init(len);
b = _fmpz_vec_init(len);
c = _fmpz_vec_init(len);
_fmpz_vec_randtest(a, state, len, 200);
_fmpz_vec_randtest(b, state, len, 200);
_fmpz_vec_set(c, b, len);
_fmpz_vec_scalar_submul_fmpz(b, a, len, n1);
_fmpz_vec_scalar_submul_si(c, a, len, n);
result = (_fmpz_vec_equal(c, b, len));
if (!result)
{
printf("FAIL:\n");
_fmpz_vec_print(c, len), printf("\n\n");
_fmpz_vec_print(b, len), printf("\n\n");
abort();
}
fmpz_clear(n1);
_fmpz_vec_clear(a, len);
_fmpz_vec_clear(b, len);
_fmpz_vec_clear(c, len);
}
/* Compute a different way */
for (i = 0; i < 10000; i++)
{
fmpz *a, *b, *c, *d;
long len = n_randint(state, 100);
fmpz_t n1;
fmpz_init(n1);
fmpz_randtest(n1, state, 200);
a = _fmpz_vec_init(len);
b = _fmpz_vec_init(len);
c = _fmpz_vec_init(len);
d = _fmpz_vec_init(len);
_fmpz_vec_randtest(a, state, len, 200);
_fmpz_vec_randtest(b, state, len, 200);
_fmpz_vec_set(c, b, len);
_fmpz_vec_scalar_submul_fmpz(b, a, len, n1);
_fmpz_vec_scalar_mul_fmpz(d, a, len, n1);
_fmpz_vec_sub(c, c, d, len);
result = (_fmpz_vec_equal(c, b, len));
if (!result)
{
printf("FAIL:\n");
_fmpz_vec_print(c, len), printf("\n\n");
_fmpz_vec_print(b, len), printf("\n\n");
abort();
}
fmpz_clear(n1);
_fmpz_vec_clear(a, len);
_fmpz_vec_clear(b, len);
_fmpz_vec_clear(c, len);
_fmpz_vec_clear(d, len);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("scalar_mul_2exp....");
fflush(stdout);
flint_randinit(state);
/* Check aliasing of a and b */
for (i = 0; i < 10000; i++)
{
fmpz *a, *b;
long len = n_randint(state, 100);
ulong exp = n_randint(state, 200);
a = _fmpz_vec_init(len);
b = _fmpz_vec_init(len);
_fmpz_vec_randtest(a, state, len, 200);
_fmpz_vec_scalar_mul_2exp(b, a, len, exp);
_fmpz_vec_scalar_mul_2exp(a, a, len, exp);
result = (_fmpz_vec_equal(a, b, len));
if (!result)
{
printf("FAIL:\n");
printf("exp = %lu\n", exp);
_fmpz_vec_print(a, len), printf("\n\n");
_fmpz_vec_print(b, len), printf("\n\n");
abort();
}
_fmpz_vec_clear(a, len);
_fmpz_vec_clear(b, len);
}
/* Check aliasing of (a*2^e1)*2^e2 equals a*2^(e1+e2) */
for (i = 0; i < 10000; i++)
{
fmpz *a, *b;
long len = n_randint(state, 100);
ulong e1 = n_randint(state, 200);
ulong e2 = n_randint(state, 200);
a = _fmpz_vec_init(len);
b = _fmpz_vec_init(len);
_fmpz_vec_randtest(a, state, len, 200);
_fmpz_vec_scalar_mul_2exp(b, a, len, e1);
_fmpz_vec_scalar_mul_2exp(b, b, len, e2);
_fmpz_vec_scalar_mul_2exp(a, a, len, e1 + e2);
result = (_fmpz_vec_equal(a, b, len));
if (!result)
{
printf("FAIL:\n");
printf("e1 = %lu, e2 = %lu\n", e1, e2);
_fmpz_vec_print(a, len), printf("\n\n");
_fmpz_vec_print(b, len), printf("\n\n");
abort();
}
_fmpz_vec_clear(a, len);
_fmpz_vec_clear(b, len);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("scalar_fdiv_q_fmpz....");
fflush(stdout);
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpz *a, *b, *c;
fmpz_t n;
mpz_t d, e, f, m;
slong i;
slong len = n_randint(state, 100);
fmpz_init(n);
fmpz_randtest_not_zero(n, state, 100);
if (n_randint(state, 2))
fmpz_neg(n, n);
a = _fmpz_vec_init(len);
b = _fmpz_vec_init(len);
c = _fmpz_vec_init(len);
_fmpz_vec_randtest(a, state, len, 200);
_fmpz_vec_set(b, a, len);
_fmpz_vec_scalar_fdiv_q_fmpz(c, a, len, n);
mpz_init(d);
mpz_init(e);
mpz_init(f);
mpz_init(m);
for (i = 0; i < len; i++)
{
fmpz_get_mpz(m, n);
fmpz_get_mpz(d, b + i);
mpz_fdiv_q(e, d, m);
fmpz_get_mpz(f, c + i);
result = (mpz_cmp(f, e) == 0);
if (!result)
{
flint_printf("FAIL:\n");
gmp_printf("d = %Zd, m = %Zd, e = %Zd, f = %Zd\n", d, m, e, f);
abort();
}
}
_fmpz_vec_clear(a, len);
_fmpz_vec_clear(b, len);
_fmpz_vec_clear(c, len);
fmpz_clear(n);
mpz_clear(d);
mpz_clear(e);
mpz_clear(f);
mpz_clear(m);
}
/* Test aliasing of a and c */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpz *a, *b;
fmpz_t n;
mpz_t d, e, f, m;
slong i;
slong len = n_randint(state, 100);
fmpz_init(n);
fmpz_randtest_not_zero(n, state, 100);
if (n_randint(state, 2))
fmpz_neg(n, n);
a = _fmpz_vec_init(len);
b = _fmpz_vec_init(len);
_fmpz_vec_randtest(a, state, len, 200);
_fmpz_vec_set(b, a, len);
_fmpz_vec_scalar_fdiv_q_fmpz(a, a, len, n);
mpz_init(d);
mpz_init(e);
mpz_init(f);
mpz_init(m);
for (i = 0; i < len; i++)
{
fmpz_get_mpz(m, n);
fmpz_get_mpz(d, b + i);
mpz_fdiv_q(e, d, m);
fmpz_get_mpz(f, a + i);
result = (mpz_cmp(f, e) == 0);
if (!result)
{
flint_printf("FAIL:\n");
gmp_printf("d = %Zd, m = %Zd, e = %Zd, f = %Zd\n", d, m, e, f);
abort();
}
}
_fmpz_vec_clear(a, len);
_fmpz_vec_clear(b, len);
fmpz_clear(n);
mpz_clear(d);
mpz_clear(e);
mpz_clear(f);
mpz_clear(m);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
