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;
slong i;
flint_printf("partitions_fmpz_ui_threaded....");
fflush(stdout);
flint_randinit(state);
flint_set_num_threads(2);
{
fmpz_t p;
fmpz * v;
fmpz_init(p);
v = _fmpz_vec_init(NUM);
arith_number_of_partitions_vec(v, NUM);
for (i = 0; i < NUM; i++)
{
partitions_fmpz_ui(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, NUM);
for (i = 0; testdata[i][0] != 0; i++)
{
partitions_fmpz_ui(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_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return 0;
}
void
test_1(fmpz_t n)
{
mpfr_t q0; mpfr_init(q0);
mpfr_t q1; mpfr_init(q1);
fmpz_t m; fmpz_init(m);
int c;
fmpz_get_mpfr( q0, n , MPFR_RNDA );
fmpz_get_mpfr_3arg(q1, n[0], MPFR_RNDA );
assert( mpfr_equal_p( q0, q1 ) );
fmpz_set_mpfr(m, q0, MPFR_RNDA);
if( fmpz_cmp_ui( n, WORD(0) ) >= 0 )
{
if( fmpz_cmp(n,m) > 0 )
{
flint_printf("RNDA test failed, n="); fmpz_print(n);
flint_printf(", m="); fmpz_print(m); flint_printf("\n");
assert(0);
}
fmpz_sub(m, m, n);
IF_MORE_THAN_2;
}
else
{
if( fmpz_cmp(n,m) < 0 )
{
flint_printf("RNDA test failed, n="); fmpz_print(n);
flint_printf(", m="); fmpz_print(m); flint_printf("\n");
assert(0);
}
fmpz_sub(m, n, m);
IF_MORE_THAN_2;
}
fmpz_get_mpfr( q0, n, MPFR_RNDZ );
fmpz_set_mpfr( m, q0, MPFR_RNDZ );
c=fmpz_cmp_si( n, WORD(0) );
if(c==0)
assert(0 == fmpz_cmp_si(m,WORD(0)));
else
{
if(c<0)
{
fmpz_neg(n, n);
fmpz_neg(m, m);
}
assert( fmpz_cmp(n,m) >= 0 );
if(c)
assert( fmpz_cmp_si(m,WORD(0)) >= 0 );
fmpz_sub(m, n, m);
IF_MORE_THAN_2_AGAIN;
}
fmpz_clear(m);
mpfr_clear(q1);
mpfr_clear(q0);
}
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()
{
slong iter;
flint_rand_t state;
flint_printf("get_interval_fmpz_2exp....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000; iter++)
{
arb_t x;
arf_t y;
fmpz_t a, b, exp;
arb_init(x);
arf_init(y);
fmpz_init(a);
fmpz_init(b);
fmpz_init(exp);
arb_randtest(x, state, 200, 10);
arb_get_interval_fmpz_2exp(a, b, exp, x);
arf_set_fmpz_2exp(y, a, exp);
if (!arb_contains_arf(x, y))
{
flint_printf("FAIL:\n\n");
flint_printf("x = "); arb_print(x); flint_printf("\n\n");
flint_printf("a = "); fmpz_print(a);
flint_printf(" exp = "); fmpz_print(exp); flint_printf("\n\n");
abort();
}
arf_set_fmpz_2exp(y, b, exp);
if (!arb_contains_arf(x, y))
{
flint_printf("FAIL:\n\n");
flint_printf("x = "); arb_print(x); flint_printf("\n\n");
flint_printf("b = "); fmpz_print(b);
flint_printf(" exp = "); fmpz_print(exp); flint_printf("\n\n");
abort();
}
arb_clear(x);
arf_clear(y);
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(exp);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("bell_sum_taylor....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++)
{
arb_t s1, s2;
fmpz_t a, b, n;
slong prec;
arb_init(s1);
arb_init(s2);
fmpz_init(a);
fmpz_init(b);
fmpz_init(n);
prec = 2 + n_randint(state, 300);
fmpz_randtest_unsigned(n, state, 1 + n_randint(state, 100));
fmpz_randtest_unsigned(a, state, 1 + n_randint(state, 100));
fmpz_add_ui(b, a, n_randint(state, 100));
arb_bell_sum_bsplit(s1, n, a, b, NULL, prec);
arb_bell_sum_taylor(s2, n, a, b, NULL, prec);
if (!arb_overlaps(s1, s2) || (arb_rel_accuracy_bits(s1) < prec - 4)
|| (arb_rel_accuracy_bits(s2) < prec - 4))
{
flint_printf("FAIL: overlap or accuracy\n\n");
flint_printf("prec = %wd\n\n", prec);
flint_printf("n = "); fmpz_print(n); flint_printf("\n\n");
flint_printf("a = "); fmpz_print(a); flint_printf("\n\n");
flint_printf("b = "); fmpz_print(b); flint_printf("\n\n");
flint_printf("s1 = "); arb_printn(s1, 100, 0); flint_printf("\n\n");
flint_printf("s2 = "); arb_printn(s2, 100, 0); flint_printf("\n\n");
flint_abort();
}
arb_clear(s1);
arb_clear(s2);
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(n);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
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()
{
slong iter;
flint_rand_t state;
flint_printf("lshift_mpn....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++)
{
fmpz_t a, b, c;
ulong e;
mp_limb_t atmp;
mp_ptr aptr;
mp_size_t an;
int asgnbit;
fmpz_init(a);
fmpz_init(b);
fmpz_init(c);
fmpz_randtest_not_zero(a, state, 1 + n_randint(state, 2000));
fmpz_randtest(b, state, 1 + n_randint(state, 2000));
fmpz_randtest(c, state, 1 + n_randint(state, 2000));
e = n_randint(state, 1000);
FMPZ_GET_MPN_READONLY(asgnbit, an, aptr, atmp, *a)
fmpz_lshift_mpn(b, aptr, an, asgnbit, e);
fmpz_mul_2exp(c, a, e);
if (!fmpz_equal(b, c))
{
flint_printf("FAIL\n");
fmpz_print(a); flint_printf("\n\n");
fmpz_print(b); flint_printf("\n\n");
fmpz_print(c); flint_printf("\n\n");
flint_abort();
}
fmpz_clear(a);
fmpz_clear(b);
fmpz_clear(c);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("set_fmpz_2exp....");
fflush(stdout);
flint_randinit(state);
/* test exact roundtrip R -> Q -> R */
for (iter = 0; iter < 100000; iter++)
{
slong bits;
fmpr_t x, z;
fmpz_t y, e;
bits = 2 + n_randint(state, 200);
fmpr_init(x);
fmpr_init(z);
fmpz_init(y);
fmpz_init(e);
fmpr_randtest(x, state, bits, 10);
fmpr_randtest(z, state, bits, 10);
fmpr_get_fmpz_2exp(y, e, x);
fmpr_set_fmpz_2exp(z, y, e);
if (!fmpr_equal(x, z))
{
flint_printf("FAIL\n\n");
flint_printf("bits: %wd\n", bits);
flint_printf("x = "); fmpr_print(x); flint_printf("\n\n");
flint_printf("y = "); fmpz_print(y); flint_printf("\n\n");
flint_printf("e = "); fmpz_print(e); flint_printf("\n\n");
flint_printf("z = "); fmpr_print(z); flint_printf("\n\n");
abort();
}
fmpr_clear(x);
fmpr_clear(z);
fmpz_clear(y);
fmpz_clear(e);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
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_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(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()
{
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()
{
fmpz * num1;
fmpz * den1;
fmpz_t num2;
fmpz_t den2;
slong n, N;
flint_printf("fmpq_ui....");
fflush(stdout);
N = 4000;
num1 = _fmpz_vec_init(N);
den1 = _fmpz_vec_init(N);
fmpz_init(num2);
fmpz_init(den2);
_arith_bernoulli_number_vec_multi_mod(num1, den1, N);
for (n = 0; n < N; n++)
{
_bernoulli_fmpq_ui(num2, den2, n);
if (!fmpz_equal(num1 + n, num2))
{
flint_printf("FAIL: n = %wd, numerator\n", n);
flint_printf("vec: "); fmpz_print(num1 + n); flint_printf("\n");
flint_printf("single: "); fmpz_print(num2); flint_printf("\n");
abort();
}
if (!fmpz_equal(den1 + n, den2))
{
flint_printf("FAIL: n = %wd, denominator\n", n);
flint_printf("vec: "); fmpz_print(den1 + n); flint_printf("\n");
flint_printf("single: "); fmpz_print(den2); flint_printf("\n");
abort();
}
}
_fmpz_vec_clear(num1, N);
_fmpz_vec_clear(den1, N);
fmpz_clear(num2);
fmpz_clear(den2);
flint_cleanup();
flint_printf("PASS\n");
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(int argc, char* argv[])
{
fmpz_t c, n;
long N = 0;
if (argc == 2)
N = atol(argv[1]);
if (argc != 2 || N < 1)
{
printf("Syntax: delta_qexp <integer>\n");
printf("where <integer> is the (positive) number of terms to compute\n");
return EXIT_FAILURE;
}
fmpz_init(c);
fmpz_init(n);
fmpz_set_si(n, N);
fmpz_ramanujan_tau(c, n);
printf("Coefficient of q^%ld is ", N);
fmpz_print(c);
printf("\n");
fmpz_clear(c);
fmpz_clear(n);
return EXIT_SUCCESS;
}
int fmpq_poly_debug(const fmpq_poly_t poly)
{
long i;
printf("{alloc: %ld, length: %ld, coeffs:", poly->alloc, poly->length);
for (i = 0; i < poly->alloc; i++)
{
printf(" ");
fmpz_print(poly->coeffs + i);
}
printf(", den: ");
fmpz_print(poly->den);
printf("}");
return 1;
}
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;
}
static void check(fmpz_t x, int expected)
{
if (fmpz_abs_fits_ui(x) != expected)
{
printf("FAIL:\n\n");
printf("x = "), fmpz_print(x), printf("\n");
abort();
}
}
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()
{
slong iter;
flint_rand_t state;
flint_printf("abs_bound_le_2exp_fmpz....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
arf_t x, y;
fmpz_t b;
int cmp1, cmp2;
arf_init(x);
arf_init(y);
fmpz_init(b);
arf_randtest_not_zero(x, state, 2 + n_randint(state, 1000), 100);
arf_abs_bound_le_2exp_fmpz(b, x);
arf_one(y);
arf_mul_2exp_fmpz(y, y, b);
cmp1 = (arf_cmpabs(x, y) <= 0);
arf_mul_2exp_si(y, y, -1);
cmp2 = (arf_cmpabs(y, x) < 0);
arf_mul_2exp_si(y, y, 1);
if (!cmp1 || !cmp2)
{
flint_printf("FAIL\n\n");
flint_printf("x = "); arf_print(x); flint_printf("\n\n");
flint_printf("y = "); arf_print(y); flint_printf("\n\n");
flint_printf("b = "); fmpz_print(b); flint_printf("\n\n");
flint_printf("cmp1 = %d, cmp2 = %d\n\n", cmp1, cmp2);
abort();
}
arf_clear(x);
arf_clear(y);
fmpz_clear(b);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
static void check(fmpz_t x, int expected)
{
if (fmpz_fits_si(x) != expected)
{
printf("FAIL:\n\n");
printf("x = "), fmpz_print(x), printf("\n");
printf("fmpz_fits_si(x) = %d\n", fmpz_fits_si(x));
printf("LONG_MIN = %ld\n", LONG_MIN);
abort();
}
}
int
main(void)
{
long i, n;
fmpz_t x;
fmpz_t y;
printf("fac_ui....");
fflush(stdout);
fmpz_init(x);
fmpz_init(y);
/* Twice to check demotion */
for (n = 0; n < 2; n++)
{
fmpz_set_ui(y, 1UL);
for (i = 0; i < 100; i++)
{
fmpz_fac_ui(x, i);
fmpz_mul_ui(y, y, FLINT_MAX(1, i));
if (!fmpz_equal(x, y))
{
printf("FAIL: %ld\n", i);
fmpz_print(x);
printf("\n");
fmpz_print(y);
printf("\n");
abort();
}
}
}
fmpz_clear(x);
fmpz_clear(y);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
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;
printf("init_set_ui....");
fflush(stdout);
flint_randinit(state);
for (i = 0; i < 100000; i++)
{
fmpz_t a, b;
ulong x = n_randtest(state);
fmpz_init(a);
fmpz_set_ui(a, x);
fmpz_init_set_ui(b, x);
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");
printf("x = %lu\n", x);
abort();
}
fmpz_clear(a);
fmpz_clear(b);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("sub_si_inline....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100000; iter++)
{
fmpz_t a, c, d;
slong b;
fmpz_init(a);
fmpz_init(c);
fmpz_init(d);
fmpz_randtest(a, state, 1 + n_randint(state, 200));
fmpz_randtest(c, state, 1 + n_randint(state, 200));
fmpz_randtest(d, state, 1 + n_randint(state, 200));
b = n_randtest(state);
fmpz_sub_si(c, a, b);
fmpz_sub_si_inline(d, a, b);
if (!fmpz_equal(c, d))
{
flint_printf("FAIL\n");
fmpz_print(a); flint_printf("\n\n");
flint_printf("%wd", b); flint_printf("\n\n");
fmpz_print(c); flint_printf("\n\n");
fmpz_print(d); flint_printf("\n\n");
abort();
}
fmpz_sub_si_inline(a, a, b);
if (!fmpz_equal(c, a))
{
flint_printf("FAIL (aliasing)\n");
fmpz_print(a); flint_printf("\n\n");
flint_printf("%wd", b); flint_printf("\n\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);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
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;
}
static void fmpz_mat_window_unsh_print(const char* m,const MATR A)
{
#if 0
printf("\n%s\n",m);
slong i,j;
for(i=0;i<A->r;i++)
{
for(j=0;j<A->c;j++)
{
//printf("%ld ",(slong)(fmpz_mat_window_entry(A,i,j)));
fmpz_print( A->rows[i]+j ); printf(" ");
}
printf("\n");
}
printf("\n");
#endif
}
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 check_ceil(renf_elem_t a, renf_t nf, int ans, const char * s)
{
fmpz_t n;
int test;
fmpz_init(n);
renf_elem_ceil(n, a, nf);
test = fmpz_cmp_si(n, ans);
fmpz_clear(n);
if (test)
{
printf("FAIL:\n");
printf("a = "); renf_elem_print_pretty(a, s, nf, 10, EANTIC_STR_ALG & EANTIC_STR_D); printf("\n");
printf("got n = "); fmpz_print(n); printf(" but expected %d\n", ans);
abort();
}
return 0;
}
