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;
}
void
nmod_poly_compose_divconquer(nmod_poly_t res,
const nmod_poly_t poly1, const nmod_poly_t poly2)
{
const long len1 = poly1->length;
const long len2 = poly2->length;
long lenr;
if (len1 == 0)
{
nmod_poly_zero(res);
return;
}
if (len1 == 1 || len2 == 0)
{
nmod_poly_set_coeff_ui(res, 0, poly1->coeffs[0]);
nmod_poly_truncate(res, 1);
return;
}
lenr = (len1 - 1) * (len2 - 1) + 1;
if (res != poly1 && res != poly2)
{
nmod_poly_fit_length(res, lenr);
_nmod_poly_compose_divconquer(res->coeffs, poly1->coeffs, len1,
poly2->coeffs, len2, poly1->mod);
}
else
{
nmod_poly_t t;
nmod_poly_init2(t, poly1->mod.n, lenr);
_nmod_poly_compose_divconquer(t->coeffs, poly1->coeffs, len1,
poly2->coeffs, len2, poly1->mod);
nmod_poly_swap(res, t);
nmod_poly_clear(t);
}
res->length = lenr;
_nmod_poly_normalise(res);
}
void nmod_poly_mat_right_tmul(nmod_poly_mat_t C, const nmod_poly_mat_t L, const nmod_poly_mat_t Bin, long m, long k){
long qq = nmod_poly_mat_nrows(Bin);
long rr = nmod_poly_mat_ncols(Bin);
long pp = nmod_poly_mat_nrows(L);
nmod_poly_mat_t B;
nmod_poly_mat_init(B, rr, qq, nmod_poly_mat_modulus(Bin));
long i, j;
for (i = 0; i < rr; i++)
for (j = 0; j < qq; j++)
nmod_poly_reverse(nmod_poly_mat_entry(B, i, j), nmod_poly_mat_entry(Bin, j, i), m+1);
nmod_poly_mat_mul(C, L, B);
for (i = 0; i < pp; i++)
for (j = 0; j < qq; j++){
nmod_poly_truncate(nmod_poly_mat_entry(C, i, j), k+m);
nmod_poly_shift_right(nmod_poly_mat_entry(C, i, j), nmod_poly_mat_entry(C, i, j), m);
}
nmod_poly_mat_clear(B);
}
int
main(void)
{
int i, result = 1;
FLINT_TEST_INIT(state);
flint_printf("tan_series....");
fflush(stdout);
/* Check atan(tan(A)) = A */
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
nmod_poly_t A, tanA, B;
slong n;
mp_limb_t mod;
mod = n_randtest_prime(state, 0);
n = 1 + n_randtest(state) % 100;
n = FLINT_MIN(n, mod);
nmod_poly_init(A, mod);
nmod_poly_init(tanA, mod);
nmod_poly_init(B, mod);
nmod_poly_randtest(A, state, n_randint(state, 100));
nmod_poly_set_coeff_ui(A, 0, UWORD(0));
nmod_poly_tan_series(tanA, A, n);
nmod_poly_atan_series(B, tanA, n);
nmod_poly_truncate(A, n);
result = nmod_poly_equal(A, B);
if (!result)
{
flint_printf("FAIL:\n");
flint_printf("n = %wd, mod = %wu\n", n, mod);
flint_printf("A: "); nmod_poly_print(A), flint_printf("\n\n");
flint_printf("tan(A): "); nmod_poly_print(tanA), flint_printf("\n\n");
flint_printf("B: "); nmod_poly_print(B), flint_printf("\n\n");
abort();
}
nmod_poly_clear(A);
nmod_poly_clear(tanA);
nmod_poly_clear(B);
}
/* Check aliasing */
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
nmod_poly_t A, B;
slong n;
mp_limb_t mod;
mod = n_randtest_prime(state, 0);
n = n_randtest(state) % 50;
n = FLINT_MIN(n, mod);
nmod_poly_init(A, mod);
nmod_poly_init(B, mod);
nmod_poly_randtest(A, state, n_randint(state, 50));
nmod_poly_set_coeff_ui(A, 0, UWORD(0));
nmod_poly_tan_series(B, A, n);
nmod_poly_tan_series(A, A, n);
result = nmod_poly_equal(A, B);
if (!result)
{
flint_printf("FAIL:\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);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result = 1;
flint_rand_t state;
flint_randinit(state);
printf("tanh_series....");
fflush(stdout);
/* Check atanh(tanh(A)) = A */
for (i = 0; i < 1000; i++)
{
nmod_poly_t A, tanhA, B;
long n;
mp_limb_t mod;
do { mod = n_randtest_prime(state, 0); } while (mod == 2);
n = 1 + n_randtest(state) % 100;
n = FLINT_MIN(n, mod);
nmod_poly_init(A, mod);
nmod_poly_init(tanhA, mod);
nmod_poly_init(B, mod);
nmod_poly_randtest(A, state, n_randint(state, 100));
nmod_poly_set_coeff_ui(A, 0, 0UL);
nmod_poly_tanh_series(tanhA, A, n);
nmod_poly_atanh_series(B, tanhA, n);
nmod_poly_truncate(A, n);
result = nmod_poly_equal(A, B);
if (!result)
{
printf("FAIL:\n");
printf("n = %ld, mod = %lu\n", n, mod);
printf("A: "); nmod_poly_print(A), printf("\n\n");
printf("tanh(A): "); nmod_poly_print(tanhA), printf("\n\n");
printf("B: "); nmod_poly_print(B), printf("\n\n");
abort();
}
nmod_poly_clear(A);
nmod_poly_clear(tanhA);
nmod_poly_clear(B);
}
/* Check aliasing */
for (i = 0; i < 1000; i++)
{
nmod_poly_t A, B;
long n;
mp_limb_t mod;
mod = n_randtest_prime(state, 0);
n = n_randtest(state) % 50;
n = FLINT_MIN(n, mod);
nmod_poly_init(A, mod);
nmod_poly_init(B, mod);
nmod_poly_randtest(A, state, n_randint(state, 50));
nmod_poly_set_coeff_ui(A, 0, 0UL);
nmod_poly_tanh_series(B, A, n);
nmod_poly_tanh_series(A, A, n);
result = nmod_poly_equal(A, B);
if (!result)
{
printf("FAIL:\n");
nmod_poly_print(A), printf("\n\n");
nmod_poly_print(B), printf("\n\n");
abort();
}
nmod_poly_clear(A);
nmod_poly_clear(B);
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("inv_series_newton....");
fflush(stdout);
/* Check Q * Qinv = 1 mod x^n */
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
nmod_poly_t q, qinv, prod;
slong m;
mp_limb_t n;
do n = n_randtest_not_zero(state);
while (!n_is_probabprime(n));
nmod_poly_init(prod, n);
nmod_poly_init(qinv, n);
nmod_poly_init(q, n);
do nmod_poly_randtest(q, state, n_randint(state, 2000));
while (q->length == 0 || q->coeffs[0] == 0);
m = n_randint(state, q->length) + 1;
nmod_poly_inv_series_newton(qinv, q, m);
nmod_poly_mul(prod, q, qinv);
nmod_poly_truncate(prod, m);
result = (prod->length == 1 && prod->coeffs[0] == 1);
if (!result)
{
flint_printf("FAIL:\n");
nmod_poly_print(q), flint_printf("\n\n");
nmod_poly_print(qinv), flint_printf("\n\n");
nmod_poly_print(prod), flint_printf("\n\n");
flint_printf("n = %wd\n", n);
abort();
}
nmod_poly_clear(q);
nmod_poly_clear(qinv);
nmod_poly_clear(prod);
}
/* Check aliasing of q and qinv */
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
nmod_poly_t q, qinv;
slong m;
mp_limb_t n;
do n = n_randtest(state);
while (!n_is_probabprime(n));
nmod_poly_init(q, n);
nmod_poly_init(qinv, n);
do nmod_poly_randtest(q, state, n_randint(state, 1000));
while (q->length == 0 || q->coeffs[0] == 0);
m = n_randint(state, q->length) + 1;
nmod_poly_inv_series_newton(qinv, q, m);
nmod_poly_inv_series_newton(q, q, m);
result = (nmod_poly_equal(q, qinv));
if (!result)
{
flint_printf("FAIL:\n");
nmod_poly_print(q), flint_printf("\n\n");
nmod_poly_print(qinv), flint_printf("\n\n");
nmod_poly_print(q), flint_printf("\n\n");
flint_printf("n = %wd, m = %wd\n", n, m);
abort();
}
nmod_poly_clear(q);
nmod_poly_clear(qinv);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
FLINT_TEST_INIT(state);
flint_printf("div_series....");
fflush(stdout);
/* Check A/B * B = A */
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
nmod_poly_t q, a, b, prod;
slong m;
mp_limb_t n;
do n = n_randtest_not_zero(state);
while (!n_is_probabprime(n));
nmod_poly_init(prod, n);
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_init(q, n);
nmod_poly_randtest(a, state, n_randint(state, 2000));
do nmod_poly_randtest(b, state, n_randint(state, 2000));
while (b->length == 0 || b->coeffs[0] == 0);
m = n_randint(state, 2000) + 1;
nmod_poly_div_series(q, a, b, m);
nmod_poly_mullow(prod, q, b, m);
nmod_poly_truncate(a, m);
result = (nmod_poly_equal(a, prod));
if (!result)
{
flint_printf("FAIL:\n");
nmod_poly_print(q), flint_printf("\n\n");
nmod_poly_print(b), flint_printf("\n\n");
nmod_poly_print(a), flint_printf("\n\n");
nmod_poly_print(prod), flint_printf("\n\n");
flint_printf("n = %wd\n", n);
abort();
}
nmod_poly_clear(q);
nmod_poly_clear(a);
nmod_poly_clear(b);
nmod_poly_clear(prod);
}
/* Check aliasing of q and a */
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
nmod_poly_t q, a, b;
slong m;
mp_limb_t n;
do n = n_randtest(state);
while (!n_is_probabprime(n));
nmod_poly_init(q, n);
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_randtest(a, state, n_randint(state, 1000));
do nmod_poly_randtest(b, state, n_randint(state, 1000));
while (b->length == 0 || b->coeffs[0] == 0);
m = n_randint(state, 1000) + 1;
nmod_poly_div_series(q, a, b, m);
nmod_poly_div_series(a, a, b, m);
result = (nmod_poly_equal(q, a));
if (!result)
{
flint_printf("FAIL:\n");
nmod_poly_print(b), flint_printf("\n\n");
nmod_poly_print(q), flint_printf("\n\n");
nmod_poly_print(a), flint_printf("\n\n");
flint_printf("n = %wd, m = %wd\n", n, m);
abort();
}
nmod_poly_clear(q);
nmod_poly_clear(a);
nmod_poly_clear(b);
}
/* Check aliasing of q and b */
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
nmod_poly_t q, a, b;
slong m;
mp_limb_t n;
do n = n_randtest(state);
while (!n_is_probabprime(n));
nmod_poly_init(q, n);
nmod_poly_init(a, n);
nmod_poly_init(b, n);
nmod_poly_randtest(a, state, n_randint(state, 1000));
do nmod_poly_randtest(b, state, n_randint(state, 1000));
while (b->length == 0 || b->coeffs[0] == 0);
m = n_randint(state, 1000) + 1;
nmod_poly_div_series(q, a, b, m);
nmod_poly_div_series(b, a, b, m);
result = (nmod_poly_equal(q, b));
if (!result)
{
flint_printf("FAIL:\n");
nmod_poly_print(a), flint_printf("\n\n");
nmod_poly_print(q), flint_printf("\n\n");
nmod_poly_print(b), flint_printf("\n\n");
flint_printf("n = %wd, m = %wd\n", n, m);
abort();
}
nmod_poly_clear(q);
nmod_poly_clear(a);
nmod_poly_clear(b);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
int i, result;
flint_rand_t state;
flint_randinit(state);
printf("invsqrt_series....");
fflush(stdout);
/* Check 1/g^2 = h mod x^m */
for (i = 0; i < 1000; i++)
{
nmod_poly_t h, g, r;
long m;
mp_limb_t n;
do n = n_randtest_prime(state, 0);
while (n == 2UL);
nmod_poly_init(h, n);
nmod_poly_init(g, n);
nmod_poly_init(r, n);
do nmod_poly_randtest(h, state, n_randint(state, 1000));
while (h->length == 0);
nmod_poly_set_coeff_ui(h, 0, 1UL);
m = n_randint(state, h->length) + 1;
nmod_poly_invsqrt_series(g, h, m);
nmod_poly_mullow(r, g, g, m);
nmod_poly_inv_series(r, r, m);
nmod_poly_truncate(h, m);
result = (nmod_poly_equal(r, h));
if (!result)
{
printf("FAIL:\n");
nmod_poly_print(h), printf("\n\n");
nmod_poly_print(g), printf("\n\n");
nmod_poly_print(r), printf("\n\n");
printf("n = %ld\n", n);
abort();
}
nmod_poly_clear(h);
nmod_poly_clear(g);
nmod_poly_clear(r);
}
/* Check aliasing of h and g */
for (i = 0; i < 1000; i++)
{
nmod_poly_t g, h;
long m;
mp_limb_t n;
do n = n_randtest_prime(state, 0);
while (n == 2UL);
nmod_poly_init(h, n);
nmod_poly_init(g, n);
do nmod_poly_randtest(h, state, n_randint(state, 500));
while (h->length == 0);
nmod_poly_set_coeff_ui(h, 0, 1UL);
m = n_randint(state, h->length) + 1;
nmod_poly_invsqrt_series(g, h, m);
nmod_poly_invsqrt_series(h, h, m);
result = (nmod_poly_equal(g, h));
if (!result)
{
printf("FAIL:\n");
nmod_poly_print(h), printf("\n\n");
nmod_poly_print(g), printf("\n\n");
printf("n = %ld, m = %ld\n", n, m);
abort();
}
nmod_poly_clear(g);
nmod_poly_clear(h);
}
flint_randclear(state);
printf("PASS\n");
return 0;
}
