int
main(void)
{
int iter;
FLINT_TEST_INIT(state);
flint_printf("inflate....");
fflush(stdout);
for (iter = 0; iter < 100 * flint_test_multiplier(); iter++)
{
nmod_poly_t poly1, poly2, poly3, xp;
mp_limb_t modulus;
ulong inflation;
modulus = n_randtest_prime(state, 0);
nmod_poly_init(poly1, modulus);
nmod_poly_init(poly2, modulus);
nmod_poly_init(poly3, modulus);
nmod_poly_init(xp, modulus);
nmod_poly_randtest(poly1, state, n_randint(state, 20));
inflation = n_randint(state, 10);
nmod_poly_inflate(poly2, poly1, inflation);
nmod_poly_set_coeff_ui(xp, inflation, 1);
nmod_poly_compose(poly3, poly1, xp);
if (!nmod_poly_equal(poly2, poly3))
{
flint_printf("FAIL: not equal to compose (inflation = %wu)\n", inflation);
flint_printf("poly1:\n"); nmod_poly_print(poly1); flint_printf("\n\n");
flint_printf("poly2:\n"); nmod_poly_print(poly2); flint_printf("\n\n");
flint_printf("poly3:\n"); nmod_poly_print(poly3); flint_printf("\n\n");
abort();
}
nmod_poly_inflate(poly1, poly1, inflation);
if (!nmod_poly_equal(poly1, poly2))
{
flint_printf("FAIL: aliasing (inflation = %wu)\n", inflation);
flint_printf("poly1:\n"); nmod_poly_print(poly1); flint_printf("\n\n");
flint_printf("poly2:\n"); nmod_poly_print(poly2); flint_printf("\n\n");
abort();
}
nmod_poly_clear(poly1);
nmod_poly_clear(poly2);
nmod_poly_clear(poly3);
nmod_poly_clear(xp);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int main(void)
{
mp_limb_t n;
int j;
FLINT_TEST_INIT(state);
flint_printf("factorial_mod2_preinv....");
fflush(stdout);
for (n = 0; n < 100 * flint_test_multiplier(); n++)
{
mp_limb_t p, pinv, x, y;
for (j = 0; j < 10; j++)
{
p = n_randtest_not_zero(state);
pinv = n_preinvert_limb(p);
x = n_factorial_mod2_preinv(n, p, pinv);
y = n_factorial_mod2_foolproof(n, p, pinv);
if (x != y)
{
flint_printf("FAIL:\n");
flint_printf("n = %wu\np = %wu\nx = %wu\ny = %wu\n", n, p, x, y);
abort();
}
}
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i;
FLINT_TEST_INIT(state);
flint_printf("init/clear....");
fflush(stdout);
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpq_mat_t a;
slong j, k;
slong rows = n_randint(state, 100);
slong cols = n_randint(state, 100);
fmpq_mat_init(a, rows, cols);
for (j = 0; j < rows; j++)
for (k = 0; k < cols; k++)
fmpq_zero(fmpq_mat_entry(a, j, k));
fmpq_mat_clear(a);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i;
FLINT_TEST_INIT(state);
flint_printf("is_square....");
fflush(stdout);
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpz_mat_t A;
slong rows = n_randint(state, 10);
slong cols = n_randint(state, 10);
fmpz_mat_init(A, rows, cols);
if (fmpz_mat_is_square(A) != (rows == cols))
{
flint_printf("FAIL!\n");
abort();
}
fmpz_mat_clear(A);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int main(void)
{
slong i;
FLINT_TEST_INIT(state);
flint_printf("pow....");
fflush(stdout);
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
fmpz_mat_t A, B, C;
slong i, n;
ulong e;
n = n_randint(state, 10);
e = n_randint(state, 20);
fmpz_mat_init(A, n, n);
fmpz_mat_init(B, n, n);
fmpz_mat_init(C, n, n);
fmpz_mat_randtest(A, state, n_randint(state, 200) + 1);
fmpz_mat_randtest(B, state, n_randint(state, 200) + 1);
/* Make sure noise in the output is ok */
fmpz_mat_randtest(B, state, n_randint(state, 200) + 1);
fmpz_mat_pow(B, A, e);
fmpz_mat_one(C);
for (i = 0; i < e; i++)
fmpz_mat_mul(C, C, A);
if (!fmpz_mat_equal(C, B))
{
flint_printf("FAIL: results not equal\n");
abort();
}
fmpz_mat_pow(A, A, e);
if (!fmpz_mat_equal(A, B))
{
flint_printf("FAIL: aliasing failed\n");
abort();
}
fmpz_mat_clear(A);
fmpz_mat_clear(B);
fmpz_mat_clear(C);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("one....");
fflush(stdout);
/* 1 * A == A * 1 == A */
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
fmpq_mat_t A, B, C, I;
slong n, bits;
n = n_randint(state, 10);
bits = 1 + n_randint(state, 100);
fmpq_mat_init(A, n, n);
fmpq_mat_init(B, n, n);
fmpq_mat_init(C, n, n);
fmpq_mat_init(I, n, n);
fmpq_mat_randtest(A, state, bits);
fmpq_mat_one(I);
fmpq_mat_mul(B, I, A);
fmpq_mat_mul(C, A, I);
result = fmpq_mat_equal(A, B) && fmpq_mat_equal(A, C);
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("A:\n");
fmpq_mat_print(A);
flint_printf("B:\n");
fmpq_mat_print(B);
flint_printf("C:\n");
fmpq_mat_print(C);
flint_printf("I:\n");
fmpq_mat_print(I);
abort();
}
fmpq_mat_clear(A);
fmpq_mat_clear(B);
fmpq_mat_clear(C);
fmpq_mat_clear(I);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("mullow_classical... ");
fflush(stdout);
/* Compare with truncated product of a and b */
for (i = 0; i < 2000; i++)
{
TEMPLATE(T, ctx_t) ctx;
TEMPLATE(T, poly_t) a, b, c, d;
slong n;
TEMPLATE(T, ctx_randtest) (ctx, state);
TEMPLATE(T, poly_init) (a, ctx);
TEMPLATE(T, poly_init) (b, ctx);
TEMPLATE(T, poly_init) (c, ctx);
TEMPLATE(T, poly_init) (d, ctx);
TEMPLATE(T, poly_randtest) (a, state, n_randint(state, 50), ctx);
TEMPLATE(T, poly_randtest) (b, state, n_randint(state, 50), ctx);
n = n_randint(state, 50);
TEMPLATE(T, poly_mullow_classical) (c, a, b, n, ctx);
TEMPLATE(T, poly_mul) (d, a, b, ctx);
TEMPLATE(T, poly_truncate) (d, n, ctx);
result = (TEMPLATE(T, poly_equal) (c, d, ctx));
if (!result)
{
flint_printf("FAIL:\n\n");
flint_printf("a = "), TEMPLATE(T, poly_print_pretty) (a, "X", ctx),
flint_printf("\n");
flint_printf("b = "), TEMPLATE(T, poly_print_pretty) (b, "X", ctx),
flint_printf("\n");
flint_printf("c = "), TEMPLATE(T, poly_print_pretty) (c, "X", ctx),
flint_printf("\n");
flint_printf("d = "), TEMPLATE(T, poly_print_pretty) (d, "X", ctx),
flint_printf("\n");
abort();
}
TEMPLATE(T, poly_clear) (a, ctx);
TEMPLATE(T, poly_clear) (b, ctx);
TEMPLATE(T, poly_clear) (c, ctx);
TEMPLATE(T, poly_clear) (d, ctx);
TEMPLATE(T, ctx_clear) (ctx);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main(void)
{
fmpz_mat_t A, B, C, D;
slong i;
FLINT_TEST_INIT(state);
flint_printf("mul....");
fflush(stdout);
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
slong m, n, k;
m = n_randint(state, 50);
n = n_randint(state, 50);
k = n_randint(state, 50);
fmpz_mat_init(A, m, n);
fmpz_mat_init(B, n, k);
fmpz_mat_init(C, m, k);
fmpz_mat_init(D, m, k);
fmpz_mat_randtest(A, state, n_randint(state, 200) + 1);
fmpz_mat_randtest(B, state, n_randint(state, 200) + 1);
/* Make sure noise in the output is ok */
fmpz_mat_randtest(C, state, n_randint(state, 200) + 1);
fmpz_mat_mul(C, A, B);
fmpz_mat_mul_classical_inline(D, A, B);
if (!fmpz_mat_equal(C, D))
{
flint_printf("FAIL: results not equal\n");
abort();
}
fmpz_mat_mul(A, A, B);
if (!fmpz_mat_equal(A, C))
{
flint_printf("FAIL: aliasing failed\n");
abort();
}
fmpz_mat_clear(A);
fmpz_mat_clear(B);
fmpz_mat_clear(C);
fmpz_mat_clear(D);
}
FLINT_TEST_CLEANUP(state);
flint_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++)
{
fmpq_poly_t f, g;
fmpq_t a, b, c;
fmpq_poly_init(f);
fmpq_poly_init(g);
fmpq_init(a);
fmpq_init(b);
fmpq_init(c);
fmpq_poly_randtest_not_zero(f, state, n_randint(state, 100) + 1, 100);
fmpq_randtest_not_zero(a, state, 100);
fmpq_poly_scalar_mul_fmpq(g, f, a);
fmpq_poly_content(b, g);
fmpq_poly_content(c, f);
fmpq_mul(c, a, c);
fmpq_abs(c, c);
result = (fmpq_equal(b, c));
if (!result)
{
flint_printf("FAIL:\n");
fmpq_poly_print(f), flint_printf("\n\n");
fmpq_poly_print(g), flint_printf("\n\n");
fmpq_print(a), flint_printf("\n\n");
fmpq_print(b), flint_printf("\n\n");
fmpq_print(c), flint_printf("\n\n");
abort();
}
fmpq_poly_clear(f);
fmpq_poly_clear(g);
fmpq_clear(a);
fmpq_clear(b);
fmpq_clear(c);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result = 1;
FLINT_TEST_INIT(state);
flint_printf("exp_series_monomial_ui....");
fflush(stdout);
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
nmod_poly_t A, expA, res;
slong n;
mp_limb_t mod;
ulong power;
mp_limb_t coeff;
mod = n_randtest_prime(state, 0);
n = n_randtest(state) % 100;
n = FLINT_MIN(n, mod);
nmod_poly_init(A, mod);
nmod_poly_init(expA, mod);
nmod_poly_init(res, mod);
coeff = n_randlimb(state) % mod;
power = 1 + n_randint(state, 2*n + 1);
nmod_poly_set_coeff_ui(A, power, coeff);
nmod_poly_exp_series(expA, A, n);
nmod_poly_exp_series_monomial_ui(res, coeff, power, n);
result = nmod_poly_equal(expA, res);
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("n = %wd, mod = %wu\n", n, mod);
flint_printf("power = %wu, coeff = %wu\n", power, coeff);
flint_printf("A: "); nmod_poly_print(A), flint_printf("\n\n");
flint_printf("exp(A): "); nmod_poly_print(expA), flint_printf("\n\n");
flint_printf("res: "); nmod_poly_print(res), flint_printf("\n\n");
abort();
}
nmod_poly_clear(A);
nmod_poly_clear(expA);
nmod_poly_clear(res);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result = 1;
FLINT_TEST_INIT(state);
flint_printf("interpolate_nmod_vec_fast....");
fflush(stdout);
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
nmod_poly_t P, Q;
mp_ptr x, y;
mp_limb_t mod;
slong j, n, npoints;
mod = n_randtest_prime(state, 0);
npoints = n_randint(state, FLINT_MIN(100, mod));
n = n_randint(state, npoints + 1);
nmod_poly_init(P, mod);
nmod_poly_init(Q, mod);
x = _nmod_vec_init(npoints);
y = _nmod_vec_init(npoints);
nmod_poly_randtest(P, state, n);
for (j = 0; j < npoints; j++)
x[j] = j;
nmod_poly_evaluate_nmod_vec_fast(y, P, x, npoints);
nmod_poly_interpolate_nmod_vec_fast(Q, x, y, npoints);
result = nmod_poly_equal(P, Q);
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("mod=%wu, n=%wd, npoints=%wd\n\n", mod, n, npoints);
nmod_poly_print(P), flint_printf("\n\n");
nmod_poly_print(Q), flint_printf("\n\n");
abort();
}
nmod_poly_clear(P);
nmod_poly_clear(Q);
_nmod_vec_clear(x);
_nmod_vec_clear(y);
}
FLINT_TEST_CLEANUP(state);
flint_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 iter;
FLINT_TEST_INIT(state);
flint_printf("sgn_eval_at_half....");
fflush(stdout);
/* Check aliasing */
for (iter = 0; iter < 1000 * flint_test_multiplier(); iter++)
{
fmpz_t a;
fmpz_poly_t f, g;
long i, d;
int s1, s2;
fmpz_init(a);
fmpz_poly_init(f);
fmpz_poly_init(g);
fmpz_poly_randtest(f, state, n_randint(state, 100), 200);
s1 = fmpz_poly_sgn_eval_at_half(f);
fmpz_poly_set(g, f);
d = fmpz_poly_degree(g);
for (i = 0; i <= d; i++)
{
fmpz_mul_2exp(fmpz_poly_get_coeff_ptr(g, i),
fmpz_poly_get_coeff_ptr(g, i), d - i);
}
fmpz_one(a);
fmpz_poly_evaluate_fmpz(a, g, a);
s2 = fmpz_sgn(a);
if (s1 != s2)
{
flint_printf("FAIL:\n");
fmpz_poly_print(f); printf("\n\n");
printf("s1 = %d, s2 = %d\n\n", s1, s2);
abort();
}
fmpz_clear(a);
fmpz_poly_clear(f);
fmpz_poly_clear(g);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int main(void)
{
int i;
FLINT_TEST_INIT(state);
flint_printf("parity....");
fflush(stdout);
/* check inv(inv(a)) == a */
for (i = 0; i < 10000; i++)
{
slong n, *a, *b, *c;
int ap, bp, cp, ap2, bp2, cp2;
n = n_randint(state, 100);
a = _perm_init(n);
b = _perm_init(n);
c = _perm_init(n);
ap = _perm_randtest(a, n, state);
bp = _perm_randtest(b, n, state);
_perm_compose(c, a, b, n);
cp = ap ^ bp;
ap2 = _perm_parity(a, n);
bp2 = _perm_parity(b, n);
cp2 = _perm_parity(c, n);
if (ap != ap2 || bp != bp2 || cp != cp2)
{
flint_printf("FAIL:\n");
flint_printf("a: "); _perm_print(a, n); flint_printf("\n\n");
flint_printf("b: "); _perm_print(b, n); flint_printf("\n\n");
flint_printf("c: "); _perm_print(c, n); flint_printf("\n\n");
flint_printf("ap = %d\n", ap);
flint_printf("bp = %d\n", bp);
flint_printf("cp = %d\n", cp);
flint_printf("ap2 = %d\n", ap2);
flint_printf("bp2 = %d\n", bp2);
flint_printf("cp2 = %d\n", cp2);
abort();
}
_perm_clear(a);
_perm_clear(b);
_perm_clear(c);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int main(void)
{
fmpz_t p;
fmpz * v;
slong i;
FLINT_TEST_INIT(state);
flint_printf("number_of_partitions....");
fflush(stdout);
fmpz_init(p);
v = _fmpz_vec_init(3000);
arith_number_of_partitions_vec(v, 3000);
for (i = 0; i < 3000; i++)
{
arith_number_of_partitions(p, i);
if (!fmpz_equal(p, v + i))
{
flint_printf("FAIL:\n");
flint_printf("p(%wd) does not agree with power series\n", i);
flint_printf("Computed p(%wd): ", i); fmpz_print(p); flint_printf("\n");
flint_printf("Expected: "); fmpz_print(v + i); flint_printf("\n");
abort();
}
}
_fmpz_vec_clear(v, 3000);
for (i = 0; testdata[i][0] != 0; i++)
{
arith_number_of_partitions(p, testdata[i][0]);
if (fmpz_fdiv_ui(p, 1000000000) != testdata[i][1])
{
flint_printf("FAIL:\n");
flint_printf("p(%wd) does not agree with known value mod 10^9\n",
testdata[i][0]);
flint_printf("Computed: %wu\n", fmpz_fdiv_ui(p, 1000000000));
flint_printf("Expected: %wu\n", testdata[i][1]);
abort();
}
}
fmpz_clear(p);
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i;
FLINT_TEST_INIT(state);
flint_printf("cfrac_bound....");
fflush(stdout);
for (i = 0; i < 10000; i++)
{
fmpq_t x, r;
fmpz * c;
slong n, bound;
fmpq_init(x);
fmpq_init(r);
/* Test worst case (quotient of Fibonacci numbers) */
if (n_randint(state, 50) == 1)
{
slong v = 1 + n_randint(state, 1000);
fmpz_fib_ui(fmpq_numref(x), v + 1);
fmpz_fib_ui(fmpq_denref(x), v);
}
else
{
fmpq_randtest(x, state, 1 + n_randint(state, 1000));
}
bound = fmpq_cfrac_bound(x);
c = _fmpz_vec_init(bound + 10);
n = fmpq_get_cfrac(c, r, x, bound);
if (n > bound)
{
flint_printf("FAIL: length=%wd > bound=%wd\n", n, bound);
abort();
}
_fmpz_vec_clear(c, bound + 10);
fmpq_clear(x);
fmpq_clear(r);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int main()
{
fmpq_poly_t P, Q;
mpz_t t;
slong k, n;
FLINT_TEST_INIT(state);
flint_printf("bernoulli_polynomial....");
fflush(stdout);
for (n = 0; n <= 100; n++)
{
fmpq_poly_init(P);
fmpq_poly_init(Q);
mpz_init(t);
for (k = 0; k <= n; k++)
{
arith_bernoulli_polynomial(P, k);
flint_mpz_bin_uiui(t, n+1, k);
fmpq_poly_scalar_mul_mpz(P, P, t);
fmpq_poly_add(Q, Q, P);
}
fmpq_poly_scalar_div_ui(Q, Q, n+1);
mpz_clear(t);
fmpq_poly_zero(P);
fmpq_poly_set_coeff_ui(P, n, UWORD(1));
if (!fmpq_poly_equal(P, Q))
{
flint_printf("ERROR: sum up to n = %wd did not add to x^n\n", n);
flint_printf("Sum: ");
fmpq_poly_print_pretty(Q, "x");
flint_printf("\nExpected: ");
fmpq_poly_print_pretty(P, "x");
flint_printf("\n");
abort();
}
fmpq_poly_clear(P);
fmpq_poly_clear(Q);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i;
FLINT_TEST_INIT(state);
flint_printf("set_si....");
fflush(stdout);
for (i = 0; i < 10000; i++)
{
fmpq_t x, y;
fmpz_t p, q;
slong P, Q;
fmpq_init(x);
fmpq_init(y);
fmpz_init(p);
fmpz_init(q);
P = z_randtest(state);
Q = n_randtest_not_zero(state);
fmpz_set_si(p, P);
fmpz_set_ui(q, Q);
fmpq_set_fmpz_frac(x, p, q);
fmpq_set_si(y, P, Q);
if (!fmpq_is_canonical(y) || !fmpq_equal(x, y))
{
flint_printf("FAIL");
flint_printf("p: "); fmpz_print(p); flint_printf("\n");
flint_printf("q: "); fmpz_print(q); flint_printf("\n");
flint_printf("x: "); fmpq_print(x); flint_printf("\n");
flint_printf("y: "); fmpq_print(y); flint_printf("\n");
abort();
}
fmpq_clear(x);
fmpq_clear(y);
fmpz_clear(p);
fmpz_clear(q);
}
FLINT_TEST_CLEANUP(state);
flint_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;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("swap....");
fflush(stdout);
for (i = 0; i < 10000; i++)
{
fmpz_t p;
fmpz_mod_poly_t a, b, c;
fmpz_init(p);
fmpz_randtest_unsigned(p, state, 2 * FLINT_BITS);
fmpz_add_ui(p, p, 2);
fmpz_mod_poly_init(a, p);
fmpz_mod_poly_init(b, p);
fmpz_mod_poly_init(c, p);
fmpz_mod_poly_randtest(a, state, n_randint(state, 100));
fmpz_mod_poly_randtest(b, state, n_randint(state, 100));
fmpz_mod_poly_set(c, b);
fmpz_mod_poly_swap(a, b);
result = (fmpz_mod_poly_equal(a, c));
if (!result)
{
flint_printf("FAIL:\n");
fmpz_mod_poly_print(a), flint_printf("\n\n");
fmpz_mod_poly_print(b), flint_printf("\n\n");
fmpz_mod_poly_print(c), flint_printf("\n\n");
abort();
}
fmpz_mod_poly_clear(a);
fmpz_mod_poly_clear(b);
fmpz_mod_poly_clear(c);
fmpz_clear(p);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i;
FLINT_TEST_INIT(state);
flint_printf("dot_bound_limbs....");
fflush(stdout);
for (i = 0; i < 1000000; i++)
{
slong len;
nmod_t mod;
mp_limb_t m;
int limbs1, limbs2;
mpz_t t;
len = n_randint(state, 10000) + 1;
m = n_randtest_not_zero(state);
nmod_init(&mod, m);
limbs1 = _nmod_vec_dot_bound_limbs(len, mod);
mpz_init2(t, 4*FLINT_BITS);
flint_mpz_set_ui(t, m-1);
mpz_mul(t, t, t);
flint_mpz_mul_ui(t, t, len);
limbs2 = mpz_size(t);
if (limbs1 != limbs2)
{
flint_printf("FAIL:\n");
flint_printf("m = %wu\n", m);
flint_printf("len = %wd\n", len);
flint_printf("limbs1 = %d\n", limbs1);
flint_printf("limbs2 = %d\n", limbs2);
gmp_printf("bound: %Zd\n", t);
abort();
}
mpz_clear(t);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int main()
{
int iter;
FLINT_TEST_INIT(state);
test_field1(state);
test_field2(state);
for (iter = 0; iter < 100; iter++)
{
renf_t nf;
renf_elem_t a;
fmpz_t f;
arb_t e;
fmpz_init(f);
arb_init(e);
renf_randtest(nf, state,
2 + n_randint(state, 20), /* length */
8 + n_randint(state, 2408), /* prec */
10 + n_randint(state, 10) /* bits */
);
renf_elem_init(a, nf);
renf_elem_randtest(a, state, 30 + n_randint(state, 10), nf);
renf_elem_ceil(f, a, nf);
arb_sub_fmpz(e, a->emb, f, 1024);
if (arb_is_positive(e))
{
printf("FAIL:\n");
abort();
}
arb_add_ui(e, e, 1, 1024);
if (arb_is_negative(e))
{
printf("FAIL:\n");
abort();
}
renf_elem_clear(a, nf);
renf_clear(nf);
fmpz_clear(f);
arb_clear(e);
}
FLINT_TEST_CLEANUP(state);
return 0;
}
int
main(void)
{
int i;
FLINT_TEST_INIT(state);
flint_printf("set_ui_smod....");
fflush(stdout);
for (i = 0; i < 10000 * flint_test_multiplier(); i++)
{
fmpz_t a, b, mz;
mp_limb_t m, r;
fmpz_init(a);
fmpz_init(b);
fmpz_init(mz);
do { m = n_randtest(state); } while (m < 2);
fmpz_set_ui(mz, m);
fmpz_randtest_mod_signed(a, state, mz);
r = fmpz_fdiv_ui(a, m);
fmpz_set_ui_smod(b, r, m);
if (!fmpz_equal(a, b))
{
flint_printf("FAIL:\n");
flint_printf("a: "); fmpz_print(a); flint_printf("\n");
flint_printf("m: %wu\n", m);
flint_printf("r: %wu\n", m);
flint_printf("b: "); fmpz_print(b); flint_printf("\n");
abort();
}
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(mz);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("is_square....");
fflush(stdout);
for (i = 0; i < 10000 * flint_test_multiplier(); i++)
{
fmpz_t a;
mpz_t b;
int r1, r2;
fmpz_init(a);
mpz_init(b);
fmpz_randtest(a, state, 200);
if (n_randint(state, 2) == 0)
fmpz_mul(a, a, a);
fmpz_get_mpz(b, a);
r1 = fmpz_is_square(a);
r2 = mpz_perfect_square_p(b);
result = (r1 == r2);
if (!result)
{
flint_printf("FAIL:\n");
gmp_printf("b = %Zd\n", b);
abort();
}
fmpz_clear(a);
mpz_clear(b);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
slong m, n, rep;
FLINT_TEST_INIT(state);
flint_printf("add/sub/neg....");
fflush(stdout);
for (rep = 0; rep < 1000 * flint_test_multiplier(); rep++)
{
fmpz_mat_t A;
fmpz_mat_t B;
fmpz_mat_t C;
m = n_randint(state, 20);
n = n_randint(state, 20);
fmpz_mat_init(A, m, n);
fmpz_mat_init(B, m, n);
fmpz_mat_init(C, m, n);
fmpz_mat_randtest(A, state, 100);
fmpz_mat_randtest(B, state, 100);
fmpz_mat_neg(C, A);
fmpz_mat_add(A, A, B);
fmpz_mat_sub(A, A, B);
fmpz_mat_neg(A, A);
if (!fmpz_mat_equal(A, C))
{
flint_printf("FAIL: matrices not equal!\n");
abort();
}
fmpz_mat_clear(A);
fmpz_mat_clear(B);
fmpz_mat_clear(C);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("mullow....");
fflush(stdout);
/* Compare with truncated product of a and b */
for (i = 0; i < 200 * flint_test_multiplier(); i++)
{
nmod_poly_t a, b, c;
slong trunc;
mp_limb_t n = n_randtest_not_zero(state);
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_init(c, n);
trunc = n_randint(state, 50);
nmod_poly_randtest(b, state, trunc);
nmod_poly_randtest(c, state, trunc);
nmod_poly_mullow(a, b, c, trunc);
nmod_poly_mul(b, b, c);
nmod_poly_truncate(b, trunc);
result = (nmod_poly_equal(a, b));
if (!result)
{
flint_printf(":\n");
nmod_poly_print(a), flint_printf("\n\n");
nmod_poly_print(b), flint_printf("\n\n");
abort();
}
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(c);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, j, result;
FLINT_TEST_INIT(state);
flint_printf("get/set_coeff_si....");
fflush(stdout);
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
fmpz_poly_t a;
slong coeff, len;
slong n1, n2;
fmpz_poly_init(a);
len = n_randint(state, 100) + 1;
for (j = 0; j < 1000; j++)
{
n1 = z_randtest(state);
coeff = n_randint(state, len);
fmpz_poly_set_coeff_si(a, coeff, n1);
n2 = fmpz_poly_get_coeff_si(a, coeff);
result = (n1 == n2);
if (!result)
{
flint_printf("FAIL: n1 = %wd, n2 = %wd, coeff = %wd, length = %wd\n",
n1, n2, coeff, len);
abort();
}
}
fmpz_poly_clear(a);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("swap....");
fflush(stdout);
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpz_poly_t a, b, c;
fmpz_poly_init(a);
fmpz_poly_init(b);
fmpz_poly_init(c);
fmpz_poly_randtest(a, state, n_randint(state, 100), 200);
fmpz_poly_randtest(b, state, n_randint(state, 100), 200);
fmpz_poly_set(c, b);
fmpz_poly_swap(a, b);
result = (fmpz_poly_equal(a, c));
if (!result)
{
flint_printf("FAIL:\n");
fmpz_poly_print(a), flint_printf("\n\n");
fmpz_poly_print(b), flint_printf("\n\n");
fmpz_poly_print(c), flint_printf("\n\n");
abort();
}
fmpz_poly_clear(a);
fmpz_poly_clear(b);
fmpz_poly_clear(c);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("get_coeff_ptr....");
fflush(stdout);
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
fmpz_poly_t A;
fmpz_t a;
slong n = n_randint(state, 100);
fmpz_poly_init(A);
fmpz_poly_randtest(A, state, n_randint(state, 100), 100);
fmpz_init(a);
fmpz_poly_get_coeff_fmpz(a, A, n);
result = n < fmpz_poly_length(A) ?
fmpz_equal(a, fmpz_poly_get_coeff_ptr(A, n)) :
fmpz_poly_get_coeff_ptr(A, n) == NULL;
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("A = "), fmpz_poly_print(A), flint_printf("\n\n");
flint_printf("a = "), fmpz_print(a), flint_printf("\n\n");
flint_printf("n = %wd\n\n", n);
abort();
}
fmpz_poly_clear(A);
fmpz_clear(a);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("sizeinbase....");
fflush(stdout);
for (i = 0; i < 100000; i++)
{
slong a;
mpz_t b;
int base;
size_t r1, r2;
a = z_randtest(state);
flint_mpz_init_set_si(b, a);
base = (int) (n_randint(state, 61) + 2);
r1 = z_sizeinbase(a, base);
r2 = mpz_sizeinbase(b, base);
result = (r1 == r2 || r1 + 1 == r2);
if (!result)
{
flint_printf("FAIL:\n");
gmp_printf("b = %Zd\n", b);
flint_printf("base = %d\n", base);
flint_printf("r1 = %wu\n, r2 = %wu\n", (ulong) r1, (ulong) r2);
abort();
}
mpz_clear(b);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
