int
main(void)
{
int i, result;
flint_rand_t state;
printf("fmpz....");
fflush(stdout);
for (i = 0; i < 100000; i++)
{
fmpz_t a, b;
*a = 0L;
fmpz_randtest(a, state, FLINT_BITS - 2);
*b = *a;
_fmpz_promote_val(a);
_fmpz_demote_val(a);
result = (*b == *a);
if (!result)
{
printf("FAIL\n");
abort();
}
}
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("init_set....");
fflush(stdout);
flint_randinit(state);
/* Small integers */
for (i = 0; i < 100000; i++)
{
fmpz_t a, b;
fmpz_init(a);
fmpz_randtest(a, state, FLINT_BITS - 2);
fmpz_init_set(b, a);
result = fmpz_equal(a, b);
if (!result)
{
printf("FAIL:\n\n");
printf("a = "), fmpz_print(a), printf("\n");
printf("b = "), fmpz_print(b), printf("\n");
abort();
}
fmpz_clear(a);
fmpz_clear(b);
}
/* Large integers */
for (i = 0; i < 100000; i++)
{
fmpz_t a, b;
fmpz_init(a);
fmpz_randtest(a, state, 2 * FLINT_BITS);
fmpz_init_set(b, a);
result = fmpz_equal(a, b);
if (!result)
{
printf("FAIL:\n\n");
printf("a = "), fmpz_print(a), printf("\n");
printf("b = "), fmpz_print(b), printf("\n");
abort();
}
fmpz_clear(a);
fmpz_clear(b);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
flint_rand_t state;
int iter;
printf("one/is_one....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000; iter++)
{
nmod_poly_mat_t A;
long m, n;
mp_limb_t mod;
mod = n_randtest_prime(state, 0);
m = n_randint(state, 10);
n = n_randint(state, 10);
nmod_poly_mat_init(A, m, n, mod);
nmod_poly_mat_randtest(A, state, n_randint(state, 5));
nmod_poly_mat_one(A);
if (!nmod_poly_mat_is_one(A))
{
printf("FAIL: expected matrix to be one\n");
abort();
}
if (m > 0 && n > 0)
{
m = n_randint(state, m);
n = n_randint(state, n);
if (m != n)
nmod_poly_randtest_not_zero(nmod_poly_mat_entry(A, m, n),
state, 5);
else
do { nmod_poly_randtest_not_zero(nmod_poly_mat_entry(A, m, n),
state, 5); }
while (nmod_poly_is_one(nmod_poly_mat_entry(A, m, n)));
if (nmod_poly_mat_is_one(A))
{
printf("FAIL: expected matrix not to be one\n");
abort();
}
}
nmod_poly_mat_clear(A);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
int i;
flint_rand_t state;
printf("init/ clear... ");
fflush(stdout);
_randinit(state);
/* Unmanaged element type (long) */
for (i = 0; i < 100; i++)
{
long m, n;
double d;
ctx_t ctx;
mat_coo_t A;
m = n_randint(state, 100) + 1;
n = n_randint(state, 100) + 1;
d = (double) n_randint(state, 101) / (double) 100;
ctx_init_long(ctx);
mat_coo_init(A, m, n, ctx);
mat_coo_randtest(A, state, d, ctx);
mat_coo_clear(A, 1, ctx);
ctx_clear(ctx);
}
/* Managed element type (mpq_t) */
for (i = 0; i < 100; i++)
{
long m, n;
double d;
ctx_t ctx;
mat_coo_t A;
m = n_randint(state, 100) + 1;
n = n_randint(state, 100) + 1;
d = (double) n_randint(state, 101) / (double) 100;
ctx_init_mpq(ctx);
mat_coo_init(A, m, n, ctx);
mat_coo_randtest(A, state, d, ctx);
mat_coo_clear(A, 1, ctx);
ctx_clear(ctx);
}
_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
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_rand_t state;
printf("get_str... ");
fflush(stdout);
flint_randinit(state);
for (i = 0; i < 10000; i++)
{
fmpz_t p;
long N;
padic_ctx_t ctx;
padic_t x;
fmpq_t y;
char *s, *t;
fmpz_init(p);
fmpz_set_ui(p, n_randprime(state, 5, 1));
N = z_randint(state, 50) + 1;
padic_ctx_init(ctx, p, N, PADIC_TERSE);
padic_init(x, ctx);
fmpq_init(y);
padic_randtest(x, state, ctx);
_padic_get_fmpq(y, x, ctx);
s = _padic_get_str(NULL, x, ctx);
t = fmpq_get_str(NULL, 10, y);
result = strcmp(s, t) == 0;
if (!result)
{
printf("FAIL:\n\n");
printf("x = "), _padic_print(x, ctx), printf("\n");
printf("y = "), fmpq_clear(y), printf("\n");
abort();
}
free(s);
free(t);
_padic_clear(x);
fmpq_clear(y);
padic_ctx_clear(ctx);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int main(void)
{
flint_rand_t state;
fmpz_t p;
fmpz * v;
long i;
printf("number_of_partitions....");
fflush(stdout);
flint_randinit(state);
fmpz_init(p);
v = _fmpz_vec_init(3000);
number_of_partitions_vec(v, 3000);
for (i = 0; i < 3000; i++)
{
number_of_partitions(p, i);
if (!fmpz_equal(p, v + i))
{
printf("FAIL:\n");
printf("p(%ld) does not agree with power series\n", i);
printf("Computed p(%ld): ", i); fmpz_print(p); printf("\n");
printf("Expected: "); fmpz_print(v + i); printf("\n");
abort();
}
}
_fmpz_vec_clear(v, 3000);
for (i = 0; testdata[i][0] != 0; i++)
{
number_of_partitions(p, testdata[i][0]);
if (fmpz_fdiv_ui(p, 1000000000) != testdata[i][1])
{
printf("FAIL:\n");
printf("p(%ld) does not agree with known value mod 10^9\n",
testdata[i][0]);
printf("Computed: %lu\n", fmpz_fdiv_ui(p, 1000000000));
printf("Expected: %lu\n", testdata[i][1]);
abort();
}
}
fmpz_clear(p);
flint_randclear(state);
mpfr_free_cache();
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
_randinit(state);
{
const char *str =
"3 [5 0 0] [0 5 0] [0 0 5] (2 0 1)[1 1 3]";
const long n = atoi(str) - 1;
mpoly_t P;
ctx_t ctxFracQt;
qadic_ctx_t Qq;
fmpz_t p = {3L};
long d = 40;
qadic_t t1;
prec_t prec, prec_in;
/*
prec_in.N0 = 9;
prec_in.N1 = 9;
prec_in.N2 = 9;
prec_in.N3 = 13;
prec_in.N3i = 14;
prec_in.N3w = 23;
prec_in.N3iw = 22;
prec_in.N4 = 18;
prec_in.m = 29;
prec_in.K = 178;
prec_in.r = 0;
prec_in.s = 0;
*/
ctx_init_fmpz_poly_q(ctxFracQt);
qadic_ctx_init_conway(Qq, p, d, 1, 1, "X", PADIC_SERIES);
qadic_init2(t1, 1);
qadic_gen(t1, Qq);
mpoly_init(P, n + 1, ctxFracQt);
mpoly_set_str(P, str, ctxFracQt);
frob(P, ctxFracQt, t1, Qq, &prec, NULL, 1);
qadic_clear(t1);
mpoly_clear(P, ctxFracQt);
ctx_clear(ctxFracQt);
qadic_ctx_clear(Qq);
}
_randclear(state);
_fmpz_cleanup();
return EXIT_SUCCESS;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("content....");
fflush(stdout);
flint_randinit(state);
/* Check that content(a f) = abs(a) content(f) */
for (i = 0; i < 10000; 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)
{
printf("FAIL:\n");
fmpq_poly_print(f), printf("\n\n");
fmpq_poly_print(g), printf("\n\n");
fmpq_print(a), printf("\n\n");
fmpq_print(b), printf("\n\n");
fmpq_print(c), printf("\n\n");
abort();
}
fmpq_poly_clear(f);
fmpq_poly_clear(g);
fmpq_clear(a);
fmpq_clear(b);
fmpq_clear(c);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
ctx_t ctx;
printf("degree... ");
fflush(stdout);
_randinit(state);
ctx_init_mpq(ctx);
/* Check deg(a) + deg(b) == deg(ab) for a, b != 0 */
for (i = 0; i < 1000; i++)
{
mpoly_t a, b, c;
long n, d, N;
n = n_randint(state, MON_MAX_VARS) + 1;
d = n_randint(state, 50) + 1;
N = n_randint(state, 50) + 1;
mpoly_init(a, n, ctx);
mpoly_init(b, n, ctx);
mpoly_init(c, n, ctx);
mpoly_randtest_not_zero(a, state, d, N, ctx);
mpoly_randtest_not_zero(b, state, d, N, ctx);
mpoly_mul(c, a, b, ctx);
result = (mpoly_degree(c, -1, ctx) == mpoly_degree(a, -1, ctx) + mpoly_degree(b, -1, ctx));
if (!result)
{
printf("FAIL:\n");
printf("n d N = %ld %ld %ld\n", n, d, N);
printf("a = "), mpoly_print(a, ctx), printf("\n");
printf("b = "), mpoly_print(b, ctx), printf("\n");
printf("c = "), mpoly_print(c, ctx), printf("\n");
printf("deg(a) = %ld\n", mpoly_degree(a, -1, ctx));
printf("deg(b) = %ld\n", mpoly_degree(b, -1, ctx));
printf("deg(c) = %ld\n", mpoly_degree(c, -1, ctx));
abort();
}
mpoly_clear(a, ctx);
mpoly_clear(b, ctx);
mpoly_clear(c, ctx);
}
_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("dlog....");
fflush(stdout);
flint_randinit(state);
for (i = 0; i < 10000; i++)
{
fmpz_t x;
mpz_t z;
mpfr_t r;
double y, w;
fmpz_init(x);
mpz_init(z);
mpfr_init2(r, 53);
fmpz_randtest_not_zero(x, state, 10000);
fmpz_abs(x, x);
y = fmpz_dlog(x);
fmpz_get_mpz(z, x);
mpfr_set_z(r, z, MPFR_RNDN);
mpfr_log(r, r, MPFR_RNDN);
w = mpfr_get_d(r, MPFR_RNDN);
result = (FLINT_ABS(y - w) <= w * 1e-13);
if (!result)
{
printf("FAIL:\n");
printf("x = "), fmpz_print(x), printf("\n");
printf("y = %.20g\n", y);
printf("w = %.20g\n", w);
abort();
}
fmpz_clear(x);
mpz_clear(z);
mpfr_clear(r);
}
mpfr_free_cache();
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
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)
{
long i;
fmpz_t x;
printf("fits_si....");
fflush(stdout);
fmpz_init(x);
fmpz_set_si(x, COEFF_MIN);
check(x, 1);
fmpz_set_si(x, COEFF_MAX);
check(x, 1);
fmpz_set_si(x, LONG_MAX);
check(x, 1);
fmpz_set_si(x, LONG_MIN);
check(x, 1);
fmpz_set_ui(x, ULONG_MAX);
check(x, 0);
fmpz_set_ui(x, ULONG_MAX);
fmpz_neg(x, x);
check(x, 0);
fmpz_set_si(x, LONG_MAX);
fmpz_add_ui(x, x, 1);
check(x, 0);
fmpz_set_si(x, LONG_MIN);
fmpz_sub_ui(x, x, 1);
check(x, 0);
for (i = 0; i < 1000; i++)
{
fmpz_set_ui(x, 1);
fmpz_mul_2exp(x, x, i);
check(x, i < FLINT_BITS - 1);
fmpz_neg(x, x);
check(x, i < FLINT_BITS); /* LONG_MIN fits */
}
fmpz_clear(x);
_fmpz_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("evaluate_mod....");
fflush(stdout);
flint_randinit(state);
/* Compare with evaluation over the integers */
for (i = 0; i < 10000; i++)
{
fmpz_t b, s;
fmpz_poly_t f;
mp_limb_t a, n, r;
fmpz_poly_init(f);
fmpz_poly_randtest(f, state, n_randint(state, 10), 20);
n = n_randtest_not_zero(state);
a = n_randint(state, n);
fmpz_init(b);
fmpz_init(s);
fmpz_set_ui(b, a);
r = fmpz_poly_evaluate_mod(f, a, n);
fmpz_poly_evaluate_fmpz(s, f, b);
result = (r == fmpz_mod_ui(s, s, n));
if (!result)
{
printf("FAIL:\n");
fmpz_poly_print(f), printf("\n\n");
gmp_printf("a = %Mu\n\n", a);
gmp_printf("n = %Mu\n\n", n);
gmp_printf("r = %Mu\n\n", r);
printf("s = "), fmpz_print(s), printf("\n\n");
abort();
}
fmpz_poly_clear(f);
fmpz_clear(b);
fmpz_clear(s);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
int i, result;
flint_rand_t state;
_randinit(state);
/*
A generic sextic curve.
*/
{
const char *str =
"3 [6 0 0] [0 6 0] [0 0 6] "
"(2 0 -1)[5 1 0] (2 0 7)[5 0 1] (2 0 2)[1 5 0] (2 0 1)[0 5 1] (2 0 2)[1 0 5] (2 0 1)[0 1 5] "
"(2 0 2)[4 2 0] (2 0 2)[4 0 2] (2 0 3)[2 4 0] (2 0 1)[0 4 2] (2 0 3)[2 0 4] (2 0 1)[0 2 4] "
"(2 0 3)[4 1 1] (2 0 3)[1 4 1] (2 0 1)[1 1 4] "
"(2 0 -1)[3 3 0] (2 0 -2)[3 0 3] (2 0 4)[0 3 3] "
"(2 0 2)[3 2 1] (2 0 1)[3 1 2] (2 0 -1)[2 3 1] (2 0 1)[1 3 2] (2 0 2)[2 1 3] (2 0 1)[1 2 3] "
"(2 0 1)[2 2 2]";
const long n = atoi(str) - 1;
mpoly_t P;
ctx_t ctxFracQt;
qadic_ctx_t Qq;
fmpz_t p = {5L};
long d = 1;
qadic_t t1;
prec_t prec, prec_in;
ctx_init_fmpz_poly_q(ctxFracQt);
qadic_ctx_init_conway(Qq, p, d, 1, 1, "X", PADIC_SERIES);
qadic_init2(t1, 1);
qadic_set_ui(t1, 2, Qq);
mpoly_init(P, n + 1, ctxFracQt);
mpoly_set_str(P, str, ctxFracQt);
frob(P, ctxFracQt, t1, Qq, &prec, NULL, 1);
qadic_clear(t1);
mpoly_clear(P, ctxFracQt);
ctx_clear(ctxFracQt);
qadic_ctx_clear(Qq);
}
_randclear(state);
_fmpz_cleanup();
return EXIT_SUCCESS;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("setbit....");
fflush(stdout);
flint_randinit(state);
for (i = 0; i < 100000; i++)
{
ulong j;
fmpz_t a, c;
mpz_t b;
fmpz_init(a);
fmpz_init(c);
mpz_init(b);
fmpz_randtest(a, state, 2 * FLINT_BITS);
fmpz_get_mpz(b, a);
j = n_randint(state, 3 * FLINT_BITS);
fmpz_setbit(a, j);
mpz_setbit(b, j);
fmpz_set_mpz(c, b);
result = (fmpz_equal(a, c));
if (!result)
{
printf("FAIL:\n");
printf("a = "), fmpz_print(a), printf("\n");
gmp_printf("b = %Zd\n", b);
printf("c = "), fmpz_print(c), printf("\n");
printf("j = %ld\n", j);
abort();
}
fmpz_clear(a);
fmpz_clear(c);
mpz_clear(b);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int main()
{
fmpz * num1;
fmpz * den1;
fmpz_t num2;
fmpz_t den2;
long n, N;
printf("bernoulli_number....");
fflush(stdout);
N = 4000;
num1 = _fmpz_vec_init(N);
den1 = _fmpz_vec_init(N);
fmpz_init(num2);
fmpz_init(den2);
_bernoulli_number_vec_multi_mod(num1, den1, N);
for (n = 0; n < N; n++)
{
bernoulli_number(num2, den2, n);
if (!fmpz_equal(num1 + n, num2))
{
printf("FAIL: n = %ld, numerator\n", n);
printf("vec: "); fmpz_print(num1 + n); printf("\n");
printf("single: "); fmpz_print(num2); printf("\n");
abort();
}
if (!fmpz_equal(den1 + n, den2))
{
printf("FAIL: n = %ld, denominator\n", n);
printf("vec: "); fmpz_print(den1 + n); printf("\n");
printf("single: "); fmpz_print(den2); printf("\n");
abort();
}
}
_fmpz_vec_clear(num1, N);
_fmpz_vec_clear(den1, N);
fmpz_clear(num2);
fmpz_clear(den2);
mpfr_free_cache();
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
_randinit(state);
/*
A quartic surface from Example 4.2.1 in [AKR].
TODO: This currently still fails!
*/
{
const char *str =
"4 (2 2 -1)[4 0 0 0] [0 4 0 0] [0 0 4 0] [0 0 0 4] "
"(2 0 -1)[0 1 3 0] (2 0 1)[1 1 2 0] (2 0 1)[1 1 1 1] "
"(2 0 1)[2 1 1 0] (2 0 -1)[2 1 0 1] (2 0 1)[1 0 3 0] (2 0 -1)[1 0 2 1]";
const long n = atoi(str) - 1;
mpoly_t P;
ctx_t ctxFracQt;
qadic_ctx_t Qq;
fmpz_t p = {3L};
long d = 2;
qadic_t t1;
prec_t prec, prec_in;
ctx_init_fmpz_poly_q(ctxFracQt);
qadic_ctx_init_conway(Qq, p, d, 1, 1, "X", PADIC_SERIES);
qadic_init2(t1, 1);
qadic_gen(t1, Qq);
mpoly_init(P, n + 1, ctxFracQt);
mpoly_set_str(P, str, ctxFracQt);
frob(P, ctxFracQt, t1, Qq, &prec, NULL, 1);
qadic_clear(t1);
mpoly_clear(P, ctxFracQt);
ctx_clear(ctxFracQt);
qadic_ctx_clear(Qq);
}
_randclear(state);
_fmpz_cleanup();
return EXIT_SUCCESS;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("neg....");
fflush(stdout);
flint_randinit(state);
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_neg(b, a);
fmpz_mod_poly_neg(c, b);
result = (fmpz_mod_poly_equal(a, c));
if (!result)
{
printf("FAIL:\n");
fmpz_mod_poly_print(a), printf("\n\n");
fmpz_mod_poly_print(b), printf("\n\n");
fmpz_mod_poly_print(c), printf("\n\n");
abort();
}
fmpz_mod_poly_clear(a);
fmpz_mod_poly_clear(b);
fmpz_mod_poly_clear(c);
fmpz_clear(p);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
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;
flint_rand_t state;
flint_randinit(state);
printf("set_cfrac....");
fflush(stdout);
for (i = 0; i < 10000; i++)
{
fmpq_t x, y, r;
fmpz * c;
long n, bound;
fmpq_init(x);
fmpq_init(y);
fmpq_init(r);
fmpq_randtest(x, state, 1 + n_randint(state, 1000));
bound = fmpq_cfrac_bound(x);
c = _fmpz_vec_init(bound);
n = fmpq_get_cfrac(c, r, x, bound);
fmpq_set_cfrac(y, c, n);
if (!fmpq_equal(x, y))
{
printf("FAIL: x != y\n");
printf("x = "); fmpq_print(x); printf("\n");
printf("y = "); fmpq_print(y); printf("\n");
printf("c = "); _fmpz_vec_print(c, n); printf("\n\n");
abort();
}
_fmpz_vec_clear(c, bound);
fmpq_clear(x);
fmpq_clear(y);
fmpq_clear(r);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
long m, n, rep;
flint_rand_t state;
printf("add/sub/neg....");
fflush(stdout);
flint_randinit(state);
for (rep = 0; rep < 10000; 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))
{
printf("FAIL: matrices not equal!\n");
abort();
}
fmpz_mat_clear(A);
fmpz_mat_clear(B);
fmpz_mat_clear(C);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int main()
{
fmpq_poly_t Pn, Pn1, Pn2, R;
long n;
printf("legendre_polynomial....");
fflush(stdout);
fmpq_poly_init(Pn);
fmpq_poly_init(Pn1);
fmpq_poly_init(Pn2);
fmpq_poly_init(R);
fmpq_poly_set_ui(Pn, 1UL);
fmpq_poly_set_coeff_ui(Pn1, 1, 1UL);
for (n = 0; n <= 500; n++)
{
legendre_polynomial(R, n);
if (!fmpq_poly_equal(Pn, R))
{
printf("FAIL: n = %ld\n", n);
printf("Direct: "); fmpq_poly_print_pretty(R, "x"); printf("\n");
printf("Recur.: "); fmpq_poly_print_pretty(Pn, "x"); printf("\n");
abort();
}
fmpq_poly_shift_left(Pn2, Pn1, 1);
fmpq_poly_scalar_mul_ui(Pn2, Pn2, 2*n + 3);
fmpq_poly_scalar_mul_si(Pn, Pn, -(n+1));
fmpq_poly_add(Pn2, Pn2, Pn);
fmpq_poly_scalar_div_ui(Pn2, Pn2, n+2);
fmpq_poly_swap(Pn, Pn1);
fmpq_poly_swap(Pn1, Pn2);
}
fmpq_poly_clear(Pn);
fmpq_poly_clear(Pn1);
fmpq_poly_clear(Pn2);
fmpq_poly_clear(R);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int main(void)
{
long k;
flint_rand_t state;
printf("zeta_ui_bsplit....");
fflush(stdout);
flint_randinit(state);
for (k = 0; k < 100; k++)
{
long prec, n;
mpfr_t x, y;
n = 2 + n_randint(state, 20);
prec = 2 + n_randint(state, 10000);
mpfr_init2(x, prec);
mpfr_init2(y, prec);
mpfr_zeta_ui(x, n, MPFR_RNDN);
mpfr_zeta_ui_bsplit(y, n, MPFR_RNDN);
if (!mpfr_equal_p(x, y))
{
printf("FAIL:\n");
printf("Wrong value at n = %ld, prec = %ld\n", n, prec);
printf("x:\n");
mpfr_out_str(stdout, 10, 0, x, MPFR_RNDN);
printf("\n");
printf("x:\n");
mpfr_out_str(stdout, 10, 0, y, MPFR_RNDN);
printf("\n");
abort();
}
mpfr_clear(x);
mpfr_clear(y);
}
flint_randclear(state);
mpfr_free_cache();
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
long i, n;
fmpz_t x, y, z, w;
printf("fib_ui....");
fflush(stdout);
fmpz_init(x);
fmpz_init(y);
fmpz_init(z);
fmpz_init(w);
/* Twice to check demotion */
for (n = 0; n < 2; n++)
{
for (i = 0; i < 200; i++)
{
fmpz_fib_ui(x, i);
fmpz_fib_ui(y, i+1);
fmpz_fib_ui(z, i+2);
fmpz_add(w, x, y);
if (!fmpz_equal(w, z))
{
printf("FAIL: %ld\n", i);
fmpz_print(x);
printf("\n");
fmpz_print(y);
printf("\n");
fmpz_print(z);
printf("\n");
abort();
}
}
}
fmpz_clear(x);
fmpz_clear(y);
fmpz_clear(z);
fmpz_clear(w);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
int i;
flint_rand_t state;
printf("init/ init2/ clear... ");
fflush(stdout);
_randinit(state);
for (i = 0; i < 10000; i++)
{
ulong_queue_t Q;
ulong_queue_init(Q);
ulong_queue_clear(Q);
}
for (i = 0; i < 10000; i++)
{
ulong_queue_t Q;
long len;
len = n_randint(state, 100) + 1;
ulong_queue_init2(Q, len);
ulong_queue_clear(Q);
}
for (i = 0; i < 10000; i++)
{
ulong_queue_t Q;
long len;
len = n_randint(state, 100) + 1;
ulong_queue_init(Q);
ulong_queue_fit_size(Q, len);
ulong_queue_clear(Q);
}
_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
int
main(void)
{
long i;
fmpz_t x;
printf("abs_fits_ui....");
fflush(stdout);
fmpz_init(x);
fmpz_set_si(x, COEFF_MIN);
check(x, 1);
fmpz_set_si(x, COEFF_MAX);
check(x, 1);
fmpz_set_ui(x, ULONG_MAX);
check(x, 1);
fmpz_set_ui(x, ULONG_MAX);
fmpz_neg(x, x);
check(x, 1);
fmpz_set_ui(x, ULONG_MAX);
fmpz_add_ui(x, x, 1UL);
check(x, 0);
fmpz_neg(x, x);
check(x, 0);
for (i = 0; i < 1000; i++)
{
fmpz_set_ui(x, 1UL);
fmpz_mul_2exp(x, x, i);
check(x, i < FLINT_BITS);
fmpz_neg(x, x);
check(x, i < FLINT_BITS);
}
fmpz_clear(x);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int main(void)
{
flint_rand_t state;
long i, j;
printf("bell_number_nmod....");
fflush(stdout);
flint_randinit(state);
for (i = 0; i < 10; i++)
{
mp_ptr b;
long n;
nmod_t mod;
mp_limb_t p;
n = n_randint(state, 1000);
p = n_randtest_prime(state, 0);
nmod_init(&mod, p);
b = _nmod_vec_init(n + 1);
bell_number_nmod_vec(b, n + 1, mod);
for (j = 0; j <= n; j++)
{
mp_limb_t u = bell_number_nmod(j, mod);
if (u != b[j])
{
printf("FAIL: p = %lu, i = %ld\n", p, j);
abort();
}
}
_nmod_vec_clear(b);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
long m, n, i, j, rep;
flint_rand_t state;
printf("unit....");
fflush(stdout);
flint_randinit(state);
for (rep = 0; rep < 1000; rep++)
{
fmpz_mat_t A;
m = n_randint(state, 20);
n = n_randint(state, 20);
fmpz_mat_init(A, m, n);
fmpz_mat_randtest(A, state, 100);
fmpz_mat_unit(A);
for (i = 0; i < m; i++)
{
for (j = 0; j < n; j++)
{
if (fmpz_cmp_ui(fmpz_mat_entry(A,i,j), i == j) != 0)
{
printf("FAIL: nonzero entry\n");
abort();
}
}
}
fmpz_mat_clear(A);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
int i;
flint_rand_t state;
printf("init/init2/realloc/clear....");
fflush(stdout);
flint_randinit(state);
for (i = 0; i < 10000; i++)
{
fmpz_poly_t a;
fmpz_poly_init2(a, n_randint(state, 100));
fmpz_poly_clear(a);
}
for (i = 0; i < 10000; i++)
{
fmpz_poly_t a;
fmpz_poly_init2(a, n_randint(state, 100));
fmpz_poly_realloc(a, n_randint(state, 100));
fmpz_poly_clear(a);
}
for (i = 0; i < 10000; i++)
{
fmpz_poly_t a;
fmpz_poly_init(a);
fmpz_poly_randtest(a, state, n_randint(state, 100), 200);
fmpz_poly_clear(a);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
