void
hmod_mat_randtril(hmod_mat_t mat, flint_rand_t state, int unit)
{
long i, j;
for (i = 0; i < mat->r; i++)
{
for (j = 0; j < mat->c; j++)
{
if (j < i)
{
hmod_mat_entry(mat, i, j) = n_randlimb(state) % (mat->mod.n);
}
else if (i == j)
{
hmod_mat_entry(mat, i, j) = n_randlimb(state) % (mat->mod.n);
if (unit || hmod_mat_entry(mat, i, j) == 0UL)
hmod_mat_entry(mat, i, j) = 1UL;
}
else
{
hmod_mat_entry(mat, i, j) = 0UL;
}
}
}
}
void sample(void * arg, ulong count)
{
mp_limb_t n;
nmod_t mod;
info_t * info = (info_t *) arg;
mp_bitcnt_t bits = info->bits;
mp_ptr vec = _nmod_vec_init(1000);
mp_ptr vec2 = _nmod_vec_init(1000);
mp_size_t j;
long i;
flint_rand_t state;
flint_randinit(state);
for (j = 0; j < 1000; j++)
vec[j] = n_randlimb(state);
prof_start();
for (i = 0; i < count; i++)
{
n = n_randbits(state, bits);
if (n == 0UL) n++;
nmod_init(&mod, n);
_nmod_vec_reduce(vec2, vec, 1000, mod);
}
prof_stop();
flint_randclear(state);
_nmod_vec_clear(vec);
_nmod_vec_clear(vec2);
}
slong
R()
{
mp_limb_t t;
slong r;
while(1)
{
t=n_randlimb(st);
if(t<COEFF_MAX)
break;
}
r=t;
if( n_randlimb(st) & 1 )
r=-r;
return r;
}
int
main(void)
{
int i, result = 1;
flint_rand_t state;
flint_randinit(state);
printf("log_series_monomial_ui....");
fflush(stdout);
for (i = 0; i < 10000; i++)
{
nmod_poly_t A, logA, res;
long 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(logA, 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, 0, 1UL);
nmod_poly_set_coeff_ui(A, power, coeff);
nmod_poly_log_series(logA, A, n);
nmod_poly_log_series_monomial_ui(res, coeff, power, n);
result = nmod_poly_equal(logA, res);
if (!result)
{
printf("FAIL:\n");
printf("n = %ld, mod = %lu\n", n, mod);
printf("power = %lu, coeff = %lu\n", power, coeff);
printf("A: "); nmod_poly_print(A), printf("\n\n");
printf("log(A): "); nmod_poly_print(logA), printf("\n\n");
printf("res: "); nmod_poly_print(res), printf("\n\n");
abort();
}
nmod_poly_clear(A);
nmod_poly_clear(logA);
nmod_poly_clear(res);
}
flint_randclear(state);
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;
}
void
fmpz_randtest(fmpz_t f, flint_rand_t state, mp_bitcnt_t bits)
{
ulong m;
fmpz_randtest_unsigned(f, state, bits);
m = n_randlimb(state);
if (m & UWORD(1))
fmpz_neg(f, f);
}
void
fmpz_randtest_mod_signed(fmpz_t f, flint_rand_t state, const fmpz_t m)
{
/* Randomly generate m/2 when included in the range */
if ((n_randlimb(state) % 32 == 1) && (fmpz_fdiv_ui(m, 2) == 0))
{
fmpz_fdiv_q_ui(f, m, UWORD(2));
}
else
{
fmpz_t t;
fmpz_init(t);
fmpz_tdiv_q_ui(t, m, UWORD(2));
fmpz_randtest_mod(t, state, t);
if (n_randlimb(state) & UWORD(1))
{
fmpz_neg(t, t);
}
fmpz_set(f, t);
fmpz_clear(t);
}
}
void
fmpz_randtest_mod(fmpz_t f, flint_rand_t state, const fmpz_t m)
{
fmpz_t t;
fmpz_init(t);
fmpz_randtest_unsigned(t, state, fmpz_bits(m) + 2);
fmpz_mod(t, t, m);
if (n_randlimb(state) & UWORD(1))
{
fmpz_sub(t, m, t);
fmpz_sub_ui(t, t, UWORD(1));
}
fmpz_set(f, t);
fmpz_clear(t);
}
void fmpq_poly_randtest_unsigned(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_unsigned(poly->coeffs, state, len, bits);
}
else
{
fmpz_t x;
fmpz_init(x);
fmpz_randtest_unsigned(x, state, bits / 2);
_fmpz_vec_randtest_unsigned(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);
}
}
void
fmpz_randtest_unsigned(fmpz_t f, flint_rand_t state, mp_bitcnt_t bits)
{
ulong m;
m = n_randlimb(state);
bits = n_randint(state, bits + 1);
if (bits <= FLINT_BITS - 2)
{
_fmpz_demote(f);
if (m & UWORD(3))
*f = n_randtest_bits(state, bits);
else
{
m >>= 2;
if (bits == 0)
*f = 0;
else if (bits < FLINT_BITS - 2)
*f = m & UWORD(1);
else
*f = COEFF_MAX;
}
}
void
_fmpq_randtest(fmpz_t num, fmpz_t den, flint_rand_t state, mp_bitcnt_t bits)
{
ulong x = n_randlimb(state);
fmpz_randtest(num, state, bits);
fmpz_randtest_not_zero(den, state, bits);
switch (x % 16)
{
case 0:
fmpz_set_si(num, 1);
break;
case 1:
fmpz_set_si(num, -1);
break;
case 2:
fmpz_set_si(num, 2);
break;
case 3:
fmpz_set_si(num, -2);
break;
}
switch ((x / 16) % 16)
{
case 0:
fmpz_set_si(den, 1);
break;
case 2:
fmpz_set_si(den, 2);
break;
}
_fmpq_canonicalise(num, den);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("airy_series....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++)
{
acb_poly_t ai, aip, bi, bip, ai2, aip2, bi2, bip2, z, w, t;
acb_t c;
slong n1, n2, prec1, prec2;
unsigned int mask;
acb_poly_init(ai); acb_poly_init(aip);
acb_poly_init(bi); acb_poly_init(bip);
acb_poly_init(ai2); acb_poly_init(aip2);
acb_poly_init(bi2); acb_poly_init(bip2);
acb_poly_init(z); acb_poly_init(w);
acb_poly_init(t); acb_init(c);
prec1 = 2 + n_randint(state, 300);
prec2 = 2 + n_randint(state, 300);
n1 = n_randint(state, 6);
n2 = n_randint(state, 6);
acb_poly_randtest(ai, state, 10, prec1, 10);
acb_poly_randtest(aip, state, 10, prec1, 10);
acb_poly_randtest(bi, state, 10, prec1, 10);
acb_poly_randtest(bip, state, 10, prec1, 10);
acb_poly_randtest(z, state, 1 + n_randint(state, 10), prec1, 10);
acb_hypgeom_airy_series(ai, aip, bi, bip, z, n1, prec1);
acb_poly_mullow(w, ai, bip, n1, prec1);
acb_poly_mullow(t, bi, aip, n1, prec1);
acb_poly_sub(w, w, t, prec1);
acb_const_pi(c, prec1);
acb_inv(c, c, prec1);
acb_poly_set_acb(t, c);
acb_poly_truncate(t, n1);
if (!acb_poly_overlaps(w, t))
{
flint_printf("FAIL: wronskian\n\n");
flint_printf("z = "); acb_poly_printd(z, 30); flint_printf("\n\n");
flint_printf("ai = "); acb_poly_printd(ai, 30); flint_printf("\n\n");
flint_printf("aip = "); acb_poly_printd(aip, 30); flint_printf("\n\n");
flint_printf("bi = "); acb_poly_printd(bi, 30); flint_printf("\n\n");
flint_printf("bip = "); acb_poly_printd(bip, 30); flint_printf("\n\n");
flint_printf("w = "); acb_poly_printd(w, 30); flint_printf("\n\n");
abort();
}
mask = n_randlimb(state);
acb_hypgeom_airy_series((mask & 1) ? ai2 : NULL,
(mask & 2) ? aip2 : NULL,
(mask & 4) ? bi2 : NULL,
(mask & 8) ? bip2 : NULL, z, n2, prec2);
acb_poly_truncate(ai, FLINT_MIN(n1, n2));
acb_poly_truncate(aip, FLINT_MIN(n1, n2));
acb_poly_truncate(bi, FLINT_MIN(n1, n2));
acb_poly_truncate(bip, FLINT_MIN(n1, n2));
acb_poly_truncate(ai2, FLINT_MIN(n1, n2));
acb_poly_truncate(aip2, FLINT_MIN(n1, n2));
acb_poly_truncate(bi2, FLINT_MIN(n1, n2));
acb_poly_truncate(bip2, FLINT_MIN(n1, n2));
if (((mask & 1) && (!acb_poly_overlaps(ai, ai2))) ||
((mask & 2) && (!acb_poly_overlaps(aip, aip2))) ||
((mask & 4) && (!acb_poly_overlaps(bi, bi2))) ||
((mask & 8) && (!acb_poly_overlaps(bip, bip2))))
{
flint_printf("FAIL: consistency (mask)\n\n");
flint_printf("mask = %u\n\n", mask);
flint_printf("len1 = %wd, len2 = %wd\n\n", n1, n2);
flint_printf("z = "); acb_poly_printd(z, 30); flint_printf("\n\n");
flint_printf("ai = "); acb_poly_printd(ai, 30); flint_printf("\n\n");
flint_printf("ai2 = "); acb_poly_printd(ai2, 30); flint_printf("\n\n");
flint_printf("aip = "); acb_poly_printd(aip, 30); flint_printf("\n\n");
flint_printf("aip2 = "); acb_poly_printd(aip2, 30); flint_printf("\n\n");
flint_printf("bi = "); acb_poly_printd(bi, 30); flint_printf("\n\n");
flint_printf("bi2 = "); acb_poly_printd(bi2, 30); flint_printf("\n\n");
flint_printf("bip = "); acb_poly_printd(bip, 30); flint_printf("\n\n");
flint_printf("bip2 = "); acb_poly_printd(bip2, 30); flint_printf("\n\n");
abort();
}
acb_poly_clear(ai); acb_poly_clear(aip);
acb_poly_clear(bi); acb_poly_clear(bip);
acb_poly_clear(ai2); acb_poly_clear(aip2);
acb_poly_clear(bi2); acb_poly_clear(bip2);
acb_poly_clear(z); acb_poly_clear(w);
acb_poly_clear(t); acb_clear(c);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("airy....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
acb_t z, t, w;
acb_t ai1, aip1, bi1, bip1;
acb_t ai2, aip2, bi2, bip2;
slong n1, n2, prec1, prec2;
unsigned int mask;
acb_init(z); acb_init(t); acb_init(w);
acb_init(ai1); acb_init(aip1); acb_init(bi1); acb_init(bip1);
acb_init(ai2); acb_init(aip2); acb_init(bi2); acb_init(bip2);
prec1 = 2 + n_randint(state, 1000);
prec2 = 2 + n_randint(state, 1000);
n1 = n_randint(state, 300);
n2 = n_randint(state, 300);
acb_randtest_param(z, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100));
acb_randtest_param(t, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100));
acb_add(z, z, t, 1000);
acb_sub(z, z, t, 1000);
switch (n_randint(state, 3))
{
case 0:
acb_hypgeom_airy_direct(ai1, aip1, bi1, bip1, z, n1, prec1);
break;
case 1:
acb_hypgeom_airy_asymp(ai1, aip1, bi1, bip1, z, n1, prec1);
break;
default:
acb_hypgeom_airy(ai1, aip1, bi1, bip1, z, prec1);
break;
}
switch (n_randint(state, 3))
{
case 0:
acb_hypgeom_airy_direct(ai2, aip2, bi2, bip2, z, n2, prec2);
break;
case 1:
acb_hypgeom_airy_asymp(ai2, aip2, bi2, bip2, z, n2, prec2);
break;
default:
acb_hypgeom_airy(ai2, aip2, bi2, bip2, z, prec2);
break;
}
if (!acb_overlaps(ai1, ai2))
{
flint_printf("FAIL: consistency (Ai)\n\n");
flint_printf("z = "); acb_printd(z, 30); flint_printf("\n\n");
flint_printf("ai1 = "); acb_printd(ai1, 30); flint_printf("\n\n");
flint_printf("ai2 = "); acb_printd(ai2, 30); flint_printf("\n\n");
abort();
}
if (!acb_overlaps(aip1, aip2))
{
flint_printf("FAIL: consistency (Ai')\n\n");
flint_printf("z = "); acb_printd(z, 30); flint_printf("\n\n");
flint_printf("aip1 = "); acb_printd(aip1, 30); flint_printf("\n\n");
flint_printf("aip2 = "); acb_printd(aip2, 30); flint_printf("\n\n");
abort();
}
if (!acb_overlaps(bi1, bi2))
{
flint_printf("FAIL: consistency (Bi)\n\n");
flint_printf("z = "); acb_printd(z, 30); flint_printf("\n\n");
flint_printf("bi1 = "); acb_printd(bi1, 30); flint_printf("\n\n");
flint_printf("bi2 = "); acb_printd(bi2, 30); flint_printf("\n\n");
abort();
}
if (!acb_overlaps(bip1, bip2))
{
flint_printf("FAIL: consistency (Bi')\n\n");
flint_printf("z = "); acb_printd(z, 30); flint_printf("\n\n");
flint_printf("bip1 = "); acb_printd(bip1, 30); flint_printf("\n\n");
flint_printf("bip2 = "); acb_printd(bip2, 30); flint_printf("\n\n");
abort();
}
acb_mul(w, ai1, bip1, prec1);
acb_submul(w, bi1, aip1, prec1);
acb_const_pi(t, prec1);
acb_inv(t, t, prec1);
if (!acb_overlaps(w, t))
{
flint_printf("FAIL: wronskian\n\n");
flint_printf("z = "); acb_printd(z, 30); flint_printf("\n\n");
flint_printf("ai1 = "); acb_printd(ai1, 30); flint_printf("\n\n");
flint_printf("aip1 = "); acb_printd(aip1, 30); flint_printf("\n\n");
flint_printf("bi1 = "); acb_printd(bi1, 30); flint_printf("\n\n");
flint_printf("bip1 = "); acb_printd(bip1, 30); flint_printf("\n\n");
flint_printf("w = "); acb_printd(w, 30); flint_printf("\n\n");
abort();
}
mask = n_randlimb(state);
acb_hypgeom_airy((mask & 1) ? ai2 : NULL,
(mask & 2) ? aip2 : NULL,
(mask & 4) ? bi2 : NULL,
(mask & 8) ? bip2 : NULL, z, prec2);
if (!acb_overlaps(ai1, ai2) || !acb_overlaps(aip1, aip2) ||
!acb_overlaps(bi1, bi2) || !acb_overlaps(bip1, bip2))
{
flint_printf("FAIL: consistency (mask)\n\n");
flint_printf("mask = %u\n\n", mask);
flint_printf("z = "); acb_printd(z, 30); flint_printf("\n\n");
flint_printf("ai1 = "); acb_printd(ai1, 30); flint_printf("\n\n");
flint_printf("ai2 = "); acb_printd(ai2, 30); flint_printf("\n\n");
flint_printf("aip1 = "); acb_printd(aip1, 30); flint_printf("\n\n");
flint_printf("aip2 = "); acb_printd(aip2, 30); flint_printf("\n\n");
flint_printf("bi1 = "); acb_printd(bi1, 30); flint_printf("\n\n");
flint_printf("bi2 = "); acb_printd(bi2, 30); flint_printf("\n\n");
flint_printf("bip1 = "); acb_printd(bip1, 30); flint_printf("\n\n");
flint_printf("bip2 = "); acb_printd(bip2, 30); flint_printf("\n\n");
abort();
}
acb_clear(z); acb_clear(t); acb_clear(w);
acb_clear(ai1); acb_clear(aip1); acb_clear(bi1); acb_clear(bip1);
acb_clear(ai2); acb_clear(aip2); acb_clear(bi2); acb_clear(bip2);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
void
grow(fmpz_t x)
{
fmpz_mul(x, x, two__64);
fmpz_add_ui(x, x, n_randlimb(st) );
}
int
main(void)
{
flint_rand_t state;
long i;
printf("nullspace....");
fflush(stdout);
flint_randinit(state);
for (i = 0; i < 10000; i++)
{
nmod_mat_t A, B, ker;
mp_limb_t mod;
long m, n, d, r, nullity, nulrank;
m = n_randint(state, 30);
n = n_randint(state, 30);
for (r = 0; r <= FLINT_MIN(m,n); r++)
{
mod = n_randtest_prime(state, 0);
d = n_randint(state, 2*m*n + 1);
nmod_mat_init(A, m, n, mod);
nmod_mat_init(ker, n, n, mod);
nmod_mat_init(B, m, n, mod);
nmod_mat_randrank(A, state, r);
/* Densify */
if (n_randlimb(state) % 2)
nmod_mat_randops(A, d, state);
nullity = nmod_mat_nullspace(ker, A);
nulrank = nmod_mat_rank(ker);
if (nullity != nulrank)
{
printf("FAIL:\n");
printf("rank(ker) != nullity!\n");
nmod_mat_print_pretty(A);
printf("\n");
abort();
}
if (nullity + r != n)
{
printf("FAIL:\n");
printf("nullity + rank != n\n");
nmod_mat_print_pretty(A);
printf("\n");
abort();
}
nmod_mat_mul(B, A, ker);
if (nmod_mat_rank(B) != 0)
{
printf("FAIL:\n");
printf("A * ker != 0\n");
nmod_mat_print_pretty(A);
printf("\n");
abort();
}
nmod_mat_clear(A);
nmod_mat_clear(ker);
nmod_mat_clear(B);
}
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
int
main(void)
{
fmpz_mat_t A;
flint_rand_t state;
long i, m;
fmpz_t det1, det2;
printf("det_multi_mod....");
fflush(stdout);
flint_randinit(state);
for (i = 0; i < 10000; i++)
{
int proved = n_randlimb(state) % 2;
m = n_randint(state, 10);
fmpz_mat_init(A, m, m);
fmpz_init(det1);
fmpz_init(det2);
fmpz_mat_randtest(A, state, 1+n_randint(state,200));
fmpz_mat_det_bareiss(det1, A);
fmpz_mat_det_multi_mod(det2, A, proved);
if (!fmpz_equal(det1, det2))
{
printf("FAIL:\n");
printf("different determinants!\n");
fmpz_mat_print_pretty(A), printf("\n");
printf("det1: "), fmpz_print(det1), printf("\n");
printf("det2: "), fmpz_print(det2), printf("\n");
abort();
}
fmpz_clear(det1);
fmpz_clear(det2);
fmpz_mat_clear(A);
}
for (i = 0; i < 10000; i++)
{
m = 2 + n_randint(state, 10);
fmpz_mat_init(A, m, m);
fmpz_init(det2);
fmpz_mat_randrank(A, state, 1+n_randint(state, m - 1), 1+n_randint(state, 10));
fmpz_mat_randops(A, state, n_randint(state, 2*m*m + 1));
fmpz_mat_det_multi_mod(det2, A, 0);
if (*det2)
{
printf("FAIL:\n");
printf("expected zero determinant!\n");
fmpz_mat_print_pretty(A), printf("\n");
abort();
}
fmpz_mat_clear(A);
fmpz_clear(det2);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
printf("revert_series....");
fflush(stdout);
flint_randinit(state);
/* Check aliasing */
for (i = 0; i < 50; i++)
{
fmpz_poly_t f, g;
long n;
fmpz_poly_init(f);
fmpz_poly_init(g);
fmpz_poly_randtest(g, state, n_randint(state, 50),
1+n_randint(state,100));
fmpz_poly_set_coeff_ui(g, 0, 0);
fmpz_poly_set_coeff_ui(g, 1, 1);
if (n_randlimb(state) % 2)
fmpz_poly_neg(g, g); /* get -x term */
n = n_randint(state, 50);
fmpz_poly_revert_series(f, g, n);
fmpz_poly_revert_series(g, g, n);
result = (fmpz_poly_equal(f, g));
if (!result)
{
printf("FAIL (aliasing):\n");
fmpz_poly_print(f), printf("\n\n");
fmpz_poly_print(g), printf("\n\n");
abort();
}
fmpz_poly_clear(f);
fmpz_poly_clear(g);
}
/* Check f(f^(-1)) = id */
for (i = 0; i < 50; i++)
{
fmpz_poly_t f, g, h;
long n;
fmpz_poly_init(f);
fmpz_poly_init(g);
fmpz_poly_init(h);
fmpz_poly_randtest(g, state, n_randint(state, 50), 10);
fmpz_poly_set_coeff_ui(g, 0, 0);
fmpz_poly_set_coeff_ui(g, 1, 1);
if (n_randlimb(state) % 2)
fmpz_poly_neg(g, g); /* get -x term */
n = n_randint(state, 50);
fmpz_poly_revert_series(f, g, n);
fmpz_poly_compose_series(h, g, f, n);
result = ((n <= 1 && fmpz_poly_is_zero(h)) ||
(h->length == 2 && fmpz_is_zero(h->coeffs + 0) &&
fmpz_is_one(h->coeffs + 1)));
if (!result)
{
printf("FAIL (comparison):\n");
fmpz_poly_print(f), printf("\n\n");
fmpz_poly_print(g), printf("\n\n");
fmpz_poly_print(h), printf("\n\n");
abort();
}
fmpz_poly_clear(f);
fmpz_poly_clear(g);
fmpz_poly_clear(h);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("revert_series_lagrange_fast....");
fflush(stdout);
/* Check aliasing */
for (i = 0; i < 10 * flint_test_multiplier(); i++)
{
fmpz_poly_t f, g;
slong n;
fmpz_poly_init(f);
fmpz_poly_init(g);
fmpz_poly_randtest(g, state, n_randint(state, 50),
1+n_randint(state,100));
fmpz_poly_set_coeff_ui(g, 0, 0);
fmpz_poly_set_coeff_ui(g, 1, 1);
if (n_randlimb(state) % 2)
fmpz_poly_neg(g, g); /* get -x term */
n = n_randint(state, 50);
fmpz_poly_revert_series_lagrange_fast(f, g, n);
fmpz_poly_revert_series_lagrange_fast(g, g, n);
result = (fmpz_poly_equal(f, g));
if (!result)
{
flint_printf("FAIL (aliasing):\n");
fmpz_poly_print(f), flint_printf("\n\n");
fmpz_poly_print(g), flint_printf("\n\n");
abort();
}
fmpz_poly_clear(f);
fmpz_poly_clear(g);
}
/* Check f(f^(-1)) = id */
for (i = 0; i < 10 * flint_test_multiplier(); i++)
{
fmpz_poly_t f, g, h;
slong n;
fmpz_poly_init(f);
fmpz_poly_init(g);
fmpz_poly_init(h);
fmpz_poly_randtest(g, state, n_randint(state, 50), 1+n_randint(state,100));
fmpz_poly_set_coeff_ui(g, 0, 0);
fmpz_poly_set_coeff_ui(g, 1, 1);
if (n_randlimb(state) % 2)
fmpz_poly_neg(g, g); /* get -x term */
n = n_randint(state, 50);
fmpz_poly_revert_series_lagrange_fast(f, g, n);
fmpz_poly_compose_series(h, g, f, n);
result = ((n <= 1 && fmpz_poly_is_zero(h)) ||
(h->length == 2 && fmpz_is_zero(h->coeffs + 0) &&
fmpz_is_one(h->coeffs + 1)));
if (!result)
{
flint_printf("FAIL (comparison):\n");
fmpz_poly_print(f), flint_printf("\n\n");
fmpz_poly_print(g), flint_printf("\n\n");
fmpz_poly_print(h), flint_printf("\n\n");
abort();
}
fmpz_poly_clear(f);
fmpz_poly_clear(g);
fmpz_poly_clear(h);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
