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 pq_nmod_elt_equal(const pq_nmod_elt_t x, const pq_nmod_elt_t y, const pq_nmod_t A) { if ((nmod_poly_is_zero(x->mono) ^ nmod_poly_is_zero(y->mono)) && (nmod_poly_is_zero(x->dual) ^ nmod_poly_is_zero(y->dual))) { _pq_nmod_insure_mono(x, A); _pq_nmod_insure_mono(y, A); } return (nmod_poly_is_zero(x->mono) && nmod_poly_is_zero(y->mono)) || nmod_poly_equal(x->mono, y->mono) || nmod_poly_equal(x->dual, y->dual); }
int main(void) { int i, result; flint_rand_t state; flint_randinit(state); printf("bit_pack/bit_unpack...."); fflush(stdout); /* Check aliasing of a and c */ for (i = 0; i < 10000; i++) { nmod_poly_t a, b; mp_limb_t n; ulong bits; mp_ptr mpn; do { n = n_randtest_not_zero(state); } while (n == 1); bits = 2 * FLINT_BIT_COUNT(n) + n_randint(state, FLINT_BITS); nmod_poly_init(a, n); nmod_poly_init(b, n); do { nmod_poly_randtest(a, state, n_randint(state, 100)); } while (a->length == 0); mpn = malloc(sizeof(mp_limb_t) * ((bits * a->length - 1) / FLINT_BITS + 1)); _nmod_poly_bit_pack(mpn, a->coeffs, a->length, bits); nmod_poly_fit_length(b, a->length); _nmod_poly_bit_unpack(b->coeffs, a->length, mpn, bits, a->mod); b->length = a->length; 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 = 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; }
int main(void) { int i, result = 1; flint_rand_t state; flint_randinit(state); printf("interpolate_nmod_vec_fast...."); fflush(stdout); for (i = 0; i < 10000; i++) { nmod_poly_t P, Q; mp_ptr x, y; mp_limb_t mod; long 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) { printf("FAIL:\n"); printf("mod=%lu, n=%ld, npoints=%ld\n\n", mod, n, npoints); nmod_poly_print(P), printf("\n\n"); nmod_poly_print(Q), printf("\n\n"); abort(); } nmod_poly_clear(P); nmod_poly_clear(Q); _nmod_vec_clear(x); _nmod_vec_clear(y); } flint_randclear(state); 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, result; flint_rand_t state; flint_randinit(state); printf("neg...."); fflush(stdout); /* Check neg neg a == a */ for (i = 0; i < 10000; i++) { nmod_poly_t a, b; mp_limb_t n = n_randtest_not_zero(state); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_randtest(a, state, n_randint(state, 100)); nmod_poly_neg(b, a); nmod_poly_neg(b, b); result = (nmod_poly_equal(a, b)); if (!result) { printf("FAIL:\n"); printf("a->length = %ld, n = %lu\n", a->length, a->mod.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("add...."); fflush(stdout); /* Check aliasing of a and c */ for (i = 0; i < 1000 * flint_test_multiplier(); i++) { nmod_poly_t a, b, c; mp_limb_t n = n_randtest_not_zero(state); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(c, n); nmod_poly_randtest(a, state, n_randint(state, 100)); nmod_poly_randtest(b, state, n_randint(state, 100)); nmod_poly_add(c, a, b); nmod_poly_add(a, a, b); result = (nmod_poly_equal(a, c)); if (!result) { flint_printf("FAIL:\n"); nmod_poly_print(a), flint_printf("\n\n"); nmod_poly_print(b), flint_printf("\n\n"); nmod_poly_print(c), flint_printf("\n\n"); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(c); } /* Check aliasing of b and c */ for (i = 0; i < 1000 * flint_test_multiplier(); i++) { nmod_poly_t a, b, c; mp_limb_t n = n_randtest_not_zero(state); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(c, n); nmod_poly_randtest(a, state, n_randint(state, 100)); nmod_poly_randtest(b, state, n_randint(state, 100)); nmod_poly_add(c, a, b); nmod_poly_add(b, a, b); result = (nmod_poly_equal(b, c)); if (!result) { flint_printf("FAIL:\n"); nmod_poly_print(a), flint_printf("\n\n"); nmod_poly_print(b), flint_printf("\n\n"); nmod_poly_print(c), 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, 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("mul_KS...."); fflush(stdout); /* Check aliasing of a and b */ for (i = 0; i < 200 * flint_test_multiplier(); i++) { nmod_poly_t a, b, c; mp_limb_t n = n_randtest_not_zero(state); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(c, n); nmod_poly_randtest(b, state, n_randint(state, 50)); nmod_poly_randtest(c, state, n_randint(state, 50)); nmod_poly_mul_KS(a, b, c, 0); nmod_poly_mul_KS(b, b, c, 0); 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); nmod_poly_clear(c); } /* Check aliasing of a and c */ for (i = 0; i < 200 * flint_test_multiplier(); i++) { nmod_poly_t a, b, c; mp_limb_t n = n_randtest_not_zero(state); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(c, n); nmod_poly_randtest(b, state, n_randint(state, 50)); nmod_poly_randtest(c, state, n_randint(state, 50)); nmod_poly_mul_KS(a, b, c, 0); nmod_poly_mul_KS(c, b, c, 0); result = (nmod_poly_equal(a, c)); if (!result) { flint_printf("FAIL:\n"); nmod_poly_print(a), flint_printf("\n\n"); nmod_poly_print(c), flint_printf("\n\n"); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(c); } /* Compare with mul_classical */ for (i = 0; i < 200 * flint_test_multiplier(); i++) { nmod_poly_t a1, a2, b, c; mp_limb_t n = n_randtest_not_zero(state); nmod_poly_init(a1, n); nmod_poly_init(a2, n); nmod_poly_init(b, n); nmod_poly_init(c, n); nmod_poly_randtest(b, state, n_randint(state, 50)); nmod_poly_randtest(c, state, n_randint(state, 50)); nmod_poly_mul_classical(a1, b, c); nmod_poly_mul_KS(a2, b, c, 0); result = (nmod_poly_equal(a1, a2)); if (!result) { flint_printf("FAIL:\n"); nmod_poly_print(a1), flint_printf("\n\n"); nmod_poly_print(a2), flint_printf("\n\n"); abort(); } nmod_poly_clear(a1); nmod_poly_clear(a2); nmod_poly_clear(b); nmod_poly_clear(c); } 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("compose_divconquer...."); fflush(stdout); /* Compare aliasing */ for (i = 0; i < 5000; i++) { nmod_poly_t a, b, r1; mp_limb_t n = n_randtest_not_zero(state); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(r1, n); nmod_poly_randtest(a, state, n_randint(state, 30)); nmod_poly_randtest(b, state, n_randint(state, 15)); nmod_poly_compose_divconquer(r1, a, b); nmod_poly_compose_divconquer(a, a, b); result = nmod_poly_equal(r1, a); if (!result) { printf("FAIL:\n"); printf("a->length = %ld, n = %lu\n", a->length, a->mod.n); nmod_poly_print(r1), printf("\n\n"); nmod_poly_print(a), printf("\n\n"); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(r1); } /* Compare other aliasing */ for (i = 0; i < 5000; i++) { nmod_poly_t a, b, r1; mp_limb_t n = n_randtest_not_zero(state); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(r1, n); nmod_poly_randtest(a, state, n_randint(state, 30)); nmod_poly_randtest(b, state, n_randint(state, 15)); nmod_poly_compose_divconquer(r1, a, b); nmod_poly_compose_divconquer(b, a, b); result = nmod_poly_equal(r1, b); if (!result) { printf("FAIL:\n"); printf("a->length = %ld, n = %lu\n", a->length, a->mod.n); nmod_poly_print(r1), printf("\n\n"); nmod_poly_print(b), printf("\n\n"); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(r1); } /* Compare with compose_horner */ for (i = 0; i < 5000; i++) { nmod_poly_t a, b, r1, r2; mp_limb_t n = n_randtest_not_zero(state); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(r1, n); nmod_poly_init(r2, n); nmod_poly_randtest(a, state, n_randint(state, 30)); nmod_poly_randtest(b, state, n_randint(state, 15)); nmod_poly_compose_divconquer(r1, a, b); nmod_poly_compose_horner(r2, a, b); result = nmod_poly_equal(r1, r2); if (!result) { printf("FAIL:\n"); printf("a->length = %ld, n = %lu\n", a->length, a->mod.n); nmod_poly_print(r1), printf("\n\n"); nmod_poly_print(r2), printf("\n\n"); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(r1); nmod_poly_clear(r2); } flint_randclear(state); printf("PASS\n"); return 0; }
int main(void) { int i, result = 1; flint_rand_t state; flint_randinit(state); printf("asin_series...."); fflush(stdout); /* Check asin(A) = atan(A/sqrt(1-A^2)) */ for (i = 0; i < 1000; i++) { nmod_poly_t A, B, asinA, atanB; long 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(B, mod); nmod_poly_init(asinA, mod); nmod_poly_init(atanB, mod); nmod_poly_randtest(A, state, n_randint(state, 100)); nmod_poly_set_coeff_ui(A, 0, 0UL); nmod_poly_mullow(B, A, A, n); nmod_poly_neg(B, B); nmod_poly_set_coeff_ui(B, 0, 1UL); nmod_poly_invsqrt_series(B, B, n); nmod_poly_mullow(B, A, B, n); nmod_poly_asin_series(asinA, A, n); nmod_poly_atan_series(atanB, B, n); result = nmod_poly_equal(asinA, atanB); if (!result) { printf("FAIL:\n"); printf("n = %ld, mod = %lu\n", n, mod); printf("A: "); nmod_poly_print(A), printf("\n\n"); printf("B: "); nmod_poly_print(B), printf("\n\n"); printf("asin(A): "); nmod_poly_print(asinA), printf("\n\n"); printf("atan(B): "); nmod_poly_print(atanB), printf("\n\n"); abort(); } nmod_poly_clear(A); nmod_poly_clear(B); nmod_poly_clear(asinA); nmod_poly_clear(atanB); } /* 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_asin_series(B, A, n); nmod_poly_asin_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_rand_t state; flint_randinit(state); printf("bit_pack/bit_unpack...."); fflush(stdout); /* Check aliasing of a and c */ for (i = 0; i < 10000; i++) { nmod_poly_t a, b; mp_limb_t n; ulong bits; mp_ptr mpn; do { n = n_randtest_not_zero(state); } while (n == 1); bits = 2 * FLINT_BIT_COUNT(n) + n_randint(state, FLINT_BITS); nmod_poly_init(a, n); nmod_poly_init(b, n); do { nmod_poly_randtest(a, state, n_randint(state, 100)); } while (a->length == 0); mpn = flint_malloc(sizeof(mp_limb_t) * ((bits * a->length - 1) / FLINT_BITS + 1)); _nmod_poly_bit_pack(mpn, a->coeffs, a->length, bits); nmod_poly_fit_length(b, a->length); _nmod_poly_bit_unpack(b->coeffs, a->length, mpn, bits, a->mod); b->length = a->length; 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_free(mpn); } for (i = 0; i < 20000; i++) { fmpz_t f; nmod_poly_t A, B; long b; mp_limb_t n; do { n = n_randtest_not_zero(state); } while (n == 1); fmpz_init(f); nmod_poly_init(A, n); nmod_poly_init(B, n); nmod_poly_randtest(A, state, 1+n_randint(state,100)); b = FLINT_BIT_COUNT(n) + n_randint(state, FLINT_BITS); nmod_poly_bit_pack(f, A, b); nmod_poly_bit_unpack(B, f, b); if (!nmod_poly_equal(A, B)) { mpz_t zz; printf("FAIL:\n"); printf("INPUT: "); nmod_poly_print(A); printf("\n"); mpz_init(zz); fmpz_get_mpz(zz, f); printf("PACKED: "); mpz_out_str(stdout, 2, zz); printf("\n"); printf("OUTPUT: "); nmod_poly_print(B); printf("\n\n"); abort(); } fmpz_clear(f); nmod_poly_clear(A); nmod_poly_clear(B); } flint_randclear(state); _fmpz_cleanup(); 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; }
int main(void) { int iter; FLINT_TEST_INIT(state); flint_printf("deflate...."); fflush(stdout); for (iter = 0; iter < 100 * flint_test_multiplier(); iter++) { nmod_poly_t poly1, poly2, poly3; mp_limb_t modulus; ulong infl1, infl, deflation; modulus = n_randtest_prime(state, 0); nmod_poly_init(poly1, modulus); nmod_poly_init(poly2, modulus); nmod_poly_init(poly3, modulus); nmod_poly_randtest(poly1, state, n_randint(state, 15)); if (nmod_poly_length(poly1) <= 1) { if (nmod_poly_deflation(poly1) != nmod_poly_length(poly1)) { flint_printf("FAIL: wrong deflation for constant polynomial\n"); abort(); } nmod_poly_deflate(poly2, poly1, n_randint(state, 5) + 1); if (!nmod_poly_equal(poly2, poly1)) { flint_printf("FAIL: constant polynomial changed on deflation\n"); abort(); } } else { infl = n_randint(state, 13) + 1; infl1 = nmod_poly_deflation(poly1); nmod_poly_inflate(poly2, poly1, infl); deflation = nmod_poly_deflation(poly2); if (deflation != infl * infl1) { flint_printf("FAIL: deflation = %wu, inflation: %wu, %wu\n", deflation, infl, infl1); 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_deflate(poly3, poly2, infl); if (!nmod_poly_equal(poly3, poly1)) { flint_printf("FAIL: deflation = %wu, inflation: %wu, %wu\n", deflation, infl, infl1); flint_printf("Deflated polynomial not equal to input:\n"); 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(poly2); flint_printf("\n\n"); abort(); } nmod_poly_deflate(poly2, poly2, infl); if (!nmod_poly_equal(poly3, poly2)) { flint_printf("FAIL: aliasing\n"); abort(); } } nmod_poly_clear(poly1); nmod_poly_clear(poly2); nmod_poly_clear(poly3); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int i, result; flint_rand_t state; flint_randinit(state); printf("mul...."); fflush(stdout); /* Check aliasing of a and b */ for (i = 0; i < 2000; i++) { nmod_poly_t a, b, c; mp_limb_t n = n_randtest_not_zero(state); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(c, n); nmod_poly_randtest(b, state, n_randint(state, 50)); nmod_poly_randtest(c, state, n_randint(state, 50)); nmod_poly_mul(a, b, c); nmod_poly_mul(b, b, c); 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); nmod_poly_clear(c); } /* Check aliasing of a and c */ for (i = 0; i < 2000; i++) { nmod_poly_t a, b, c; mp_limb_t n = n_randtest_not_zero(state); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(c, n); nmod_poly_randtest(b, state, n_randint(state, 50)); nmod_poly_randtest(c, state, n_randint(state, 50)); nmod_poly_mul(a, b, c); nmod_poly_mul(c, b, c); result = (nmod_poly_equal(a, c)); if (!result) { printf("FAIL:\n"); nmod_poly_print(a), printf("\n\n"); nmod_poly_print(c), printf("\n\n"); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(c); } /* Check (b*c)+(b*d) = b*(c+d) */ for (i = 0; i < 2000; i++) { nmod_poly_t a1, a2, b, c, d; mp_limb_t n = n_randtest_not_zero(state); nmod_poly_init(a1, n); nmod_poly_init(a2, n); nmod_poly_init(b, n); nmod_poly_init(c, n); nmod_poly_init(d, n); nmod_poly_randtest(b, state, n_randint(state, 100)); nmod_poly_randtest(c, state, n_randint(state, 100)); nmod_poly_randtest(d, state, n_randint(state, 100)); nmod_poly_mul(a1, b, c); nmod_poly_mul(a2, b, d); nmod_poly_add(a1, a1, a2); nmod_poly_add(c, c, d); nmod_poly_mul(a2, b, c); result = (nmod_poly_equal(a1, a2)); if (!result) { printf("FAIL:\n"); nmod_poly_print(a1), printf("\n\n"); nmod_poly_print(a2), printf("\n\n"); abort(); } nmod_poly_clear(a1); nmod_poly_clear(a2); nmod_poly_clear(b); nmod_poly_clear(c); nmod_poly_clear(d); } flint_randclear(state); printf("PASS\n"); return 0; }
int main(void) { int i; flint_rand_t state; printf("sqrt... "); fflush(stdout); flint_randinit(state); /* Test aliasing */ for (i = 0; i < 2000; i++) { nmod_poly_t a, b; int square1, square2; mp_limb_t mod; mod = n_randtest_prime(state, 0); nmod_poly_init(a, mod); nmod_poly_init(b, mod); nmod_poly_randtest(a, state, 1 + n_randint(state, 50)); if (n_randint(state, 2)) nmod_poly_mul(a, a, a); square1 = nmod_poly_sqrt(b, a); square2 = nmod_poly_sqrt(a, a); if ((square1 != square2) || (square1 && !nmod_poly_equal(a, b))) { printf("FAIL: aliasing:\n"); printf("square1 = %d, square2 = %d\n\n", square1, square2); printf("a: "); nmod_poly_print(a); printf("\n\n"); printf("b: "); nmod_poly_print(b); printf("\n\n"); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); } /* Test random squares */ for (i = 0; i < 2000; i++) { nmod_poly_t a, b, c; int square; mp_limb_t mod; mod = n_randtest_prime(state, 0); nmod_poly_init(a, mod); nmod_poly_init(b, mod); nmod_poly_init(c, mod); nmod_poly_randtest(a, state, 1 + n_randint(state, 50)); nmod_poly_mul(b, a, a); square = nmod_poly_sqrt(c, b); if (!square) { printf("FAIL: square reported nonsquare:\n"); printf("a: "); nmod_poly_print(a); printf("\n\n"); printf("b: "); nmod_poly_print(b); printf("\n\n"); printf("c: "); nmod_poly_print(c); printf("\n\n"); abort(); } nmod_poly_mul(c, c, c); if (!nmod_poly_equal(c, b)) { printf("FAIL: sqrt(b)^2 != b:\n"); printf("a: "); nmod_poly_print(a); printf("\n\n"); printf("b: "); nmod_poly_print(b); printf("\n\n"); printf("c: "); nmod_poly_print(c); printf("\n\n"); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(c); } /* Test "almost" squares */ for (i = 0; i < 2000; i++) { nmod_poly_t a, b, c; long j; int square; mp_limb_t mod; mod = n_randtest_prime(state, 0); nmod_poly_init(a, mod); nmod_poly_init(b, mod); nmod_poly_init(c, mod); nmod_poly_randtest_not_zero(a, state, 1 + n_randint(state, 50)); nmod_poly_mul(b, a, a); j = n_randint(state, nmod_poly_length(b)); b->coeffs[j] = n_randint(state, mod); _nmod_poly_normalise(b); square = nmod_poly_sqrt(c, b); if (square) { nmod_poly_mul(c, c, c); if (!nmod_poly_equal(c, b)) { printf("FAIL: sqrt(b)^2 != b:\n"); printf("a: "); nmod_poly_print(a); printf("\n\n"); printf("b: "); nmod_poly_print(b); printf("\n\n"); printf("c: "); nmod_poly_print(c); printf("\n\n"); abort(); } } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(c); } flint_randclear(state); printf("PASS\n"); return 0; }
int main(void) { int i, result; flint_rand_t state; flint_randinit(state); printf("gcd_euclidean...."); fflush(stdout); /* Find coprime polys, multiply by another poly and check the GCD is that poly */ for (i = 0; i < 1000; i++) { nmod_poly_t a, b, c, g; mp_limb_t n; do n = n_randtest_not_zero(state); while (!n_is_probabprime(n)); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(c, n); nmod_poly_init(g, n); do { nmod_poly_randtest(a, state, n_randint(state, 200)); nmod_poly_randtest(b, state, n_randint(state, 200)); nmod_poly_gcd_euclidean(g, a, b); } while (g->length != 1); do { nmod_poly_randtest(c, state, n_randint(state, 200)); } while (c->length < 2); nmod_poly_make_monic(c, c); nmod_poly_mul(a, a, c); nmod_poly_mul(b, b, c); nmod_poly_gcd_euclidean(g, a, b); result = (nmod_poly_equal(g, c)); if (!result) { printf("FAIL:\n"); nmod_poly_print(a), printf("\n\n"); nmod_poly_print(b), printf("\n\n"); nmod_poly_print(c), printf("\n\n"); nmod_poly_print(g), printf("\n\n"); printf("n = %ld\n", n); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(c); nmod_poly_clear(g); } /* Check aliasing of a and g */ for (i = 0; i < 1000; i++) { nmod_poly_t a, b, g; mp_limb_t n; do n = n_randtest(state); while (!n_is_probabprime(n)); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(g, n); nmod_poly_randtest(a, state, n_randint(state, 200)); nmod_poly_randtest(b, state, n_randint(state, 200)); nmod_poly_gcd_euclidean(g, a, b); nmod_poly_gcd_euclidean(a, a, b); result = (nmod_poly_equal(a, g)); if (!result) { printf("FAIL:\n"); nmod_poly_print(a), printf("\n\n"); nmod_poly_print(b), printf("\n\n"); nmod_poly_print(g), printf("\n\n"); printf("n = %ld\n", n); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(g); } /* Check aliasing of b and g */ for (i = 0; i < 1000; i++) { nmod_poly_t a, b, g; mp_limb_t n; do n = n_randtest(state); while (!n_is_probabprime(n)); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(g, n); nmod_poly_randtest(a, state, n_randint(state, 200)); nmod_poly_randtest(b, state, n_randint(state, 200)); nmod_poly_gcd_euclidean(g, a, b); nmod_poly_gcd_euclidean(b, a, b); result = (nmod_poly_equal(b, g)); if (!result) { printf("FAIL:\n"); nmod_poly_print(a), printf("\n\n"); nmod_poly_print(b), printf("\n\n"); nmod_poly_print(g), printf("\n\n"); printf("n = %ld\n", n); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(g); } flint_randclear(state); printf("PASS\n"); return 0; }
int main(void) { int i, result; FLINT_TEST_INIT(state); flint_printf("xgcd_euclidean...."); fflush(stdout); /* Compare with result from gcd and check a*s + b*t = g */ for (i = 0; i < 1000 * flint_test_multiplier(); i++) { nmod_poly_t a, b, c, g1, s, t, g2; mp_limb_t n; do n = n_randtest_not_zero(state); while (!n_is_probabprime(n)); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(c, n); nmod_poly_init(g1, n); nmod_poly_init(g2, n); nmod_poly_init(s, n); nmod_poly_init(t, n); nmod_poly_randtest(a, state, n_randtest(state) % 200); nmod_poly_randtest(b, state, n_randtest(state) % 200); nmod_poly_randtest(c, state, n_randtest(state) % 200); nmod_poly_mul(a, a, c); nmod_poly_mul(b, b, c); nmod_poly_gcd_euclidean(g1, a, b); nmod_poly_xgcd_euclidean(g2, s, t, a, b); nmod_poly_mul(s, s, a); nmod_poly_mul(t, t, b); nmod_poly_add(s, s, t); result = (nmod_poly_equal(g1, g2) && nmod_poly_equal(s, g1) && (g1->length == 0 || g1->coeffs[g1->length - 1] == 1)); if (!result) { flint_printf("FAIL:\n"); nmod_poly_print(a), flint_printf("\n\n"); nmod_poly_print(b), flint_printf("\n\n"); nmod_poly_print(c), flint_printf("\n\n"); nmod_poly_print(g1), flint_printf("\n\n"); nmod_poly_print(g2), flint_printf("\n\n"); nmod_poly_print(s), flint_printf("\n\n"); nmod_poly_print(t), flint_printf("\n\n"); flint_printf("n = %wd\n", n); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(c); nmod_poly_clear(g1); nmod_poly_clear(g2); nmod_poly_clear(s); nmod_poly_clear(t); } /* Check aliasing of a and g */ for (i = 0; i < 20 * flint_test_multiplier(); i++) { nmod_poly_t a, b, g, s, t; mp_limb_t n; do n = n_randtest(state); while (!n_is_probabprime(n)); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(g, n); nmod_poly_init(s, n); nmod_poly_init(t, n); nmod_poly_randtest(a, state, n_randtest(state) % 200); nmod_poly_randtest(b, state, n_randtest(state) % 200); nmod_poly_xgcd_euclidean(g, s, t, a, b); nmod_poly_xgcd_euclidean(a, s, t, a, b); result = (nmod_poly_equal(a, g)); if (!result) { flint_printf("FAIL:\n"); nmod_poly_print(a), flint_printf("\n\n"); nmod_poly_print(b), flint_printf("\n\n"); nmod_poly_print(g), flint_printf("\n\n"); flint_printf("n = %wd\n", n); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(g); nmod_poly_clear(s); nmod_poly_clear(t); } /* Check aliasing of b and g */ for (i = 0; i < 20 * flint_test_multiplier(); i++) { nmod_poly_t a, b, g, s, t; mp_limb_t n; do n = n_randtest(state); while (!n_is_probabprime(n)); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(g, n); nmod_poly_init(s, n); nmod_poly_init(t, n); nmod_poly_randtest(a, state, n_randtest(state) % 200); nmod_poly_randtest(b, state, n_randtest(state) % 200); nmod_poly_xgcd_euclidean(g, s, t, a, b); nmod_poly_xgcd_euclidean(b, s, t, a, b); result = (nmod_poly_equal(b, g)); if (!result) { flint_printf("FAIL:\n"); nmod_poly_print(a), flint_printf("\n\n"); nmod_poly_print(b), flint_printf("\n\n"); nmod_poly_print(g), flint_printf("\n\n"); flint_printf("n = %wd\n", n); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(g); nmod_poly_clear(s); nmod_poly_clear(t); } /* Check aliasing of s and a */ for (i = 0; i < 20 * flint_test_multiplier(); i++) { nmod_poly_t a, b, g, s, t; mp_limb_t n; do n = n_randtest(state); while (!n_is_probabprime(n)); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(g, n); nmod_poly_init(s, n); nmod_poly_init(t, n); nmod_poly_randtest(a, state, n_randtest(state) % 200); nmod_poly_randtest(b, state, n_randtest(state) % 200); nmod_poly_xgcd_euclidean(g, s, t, a, b); nmod_poly_xgcd_euclidean(g, a, t, a, b); result = (nmod_poly_equal(s, a)); if (!result) { flint_printf("FAIL:\n"); nmod_poly_print(a), flint_printf("\n\n"); nmod_poly_print(s), flint_printf("\n\n"); flint_printf("n = %wd\n", n); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(g); nmod_poly_clear(s); nmod_poly_clear(t); } /* Check aliasing of s and b */ for (i = 0; i < 20 * flint_test_multiplier(); i++) { nmod_poly_t a, b, g, s, t; mp_limb_t n; do n = n_randtest(state); while (!n_is_probabprime(n)); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(g, n); nmod_poly_init(s, n); nmod_poly_init(t, n); nmod_poly_randtest(a, state, n_randtest(state) % 200); nmod_poly_randtest(b, state, n_randtest(state) % 200); nmod_poly_xgcd_euclidean(g, s, t, a, b); nmod_poly_xgcd_euclidean(g, b, t, a, b); result = (nmod_poly_equal(s, b)); if (!result) { flint_printf("FAIL:\n"); nmod_poly_print(b), flint_printf("\n\n"); nmod_poly_print(s), flint_printf("\n\n"); flint_printf("n = %wd\n", n); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(g); nmod_poly_clear(s); nmod_poly_clear(t); } /* Check aliasing of t and a */ for (i = 0; i < 20 * flint_test_multiplier(); i++) { nmod_poly_t a, b, g, s, t; mp_limb_t n; do n = n_randtest(state); while (!n_is_probabprime(n)); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(g, n); nmod_poly_init(s, n); nmod_poly_init(t, n); nmod_poly_randtest(a, state, n_randtest(state) % 200); nmod_poly_randtest(b, state, n_randtest(state) % 200); nmod_poly_xgcd_euclidean(g, s, t, a, b); nmod_poly_xgcd_euclidean(g, s, a, a, b); result = (nmod_poly_equal(t, a)); if (!result) { flint_printf("FAIL:\n"); nmod_poly_print(a), flint_printf("\n\n"); nmod_poly_print(t), flint_printf("\n\n"); flint_printf("n = %wd\n", n); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(g); nmod_poly_clear(s); nmod_poly_clear(t); } /* Check aliasing of t and b */ for (i = 0; i < 20 * flint_test_multiplier(); i++) { nmod_poly_t a, b, g, s, t; mp_limb_t n; do n = n_randtest(state); while (!n_is_probabprime(n)); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(g, n); nmod_poly_init(s, n); nmod_poly_init(t, n); nmod_poly_randtest(a, state, n_randtest(state) % 200); nmod_poly_randtest(b, state, n_randtest(state) % 200); nmod_poly_xgcd_euclidean(g, s, t, a, b); nmod_poly_xgcd_euclidean(g, s, b, a, b); result = (nmod_poly_equal(t, b)); if (!result) { flint_printf("FAIL:\n"); nmod_poly_print(b), flint_printf("\n\n"); nmod_poly_print(t), flint_printf("\n\n"); flint_printf("n = %wd\n", n); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(g); nmod_poly_clear(s); nmod_poly_clear(t); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int i; FLINT_TEST_INIT(state); flint_printf("taylor_shift_horner...."); fflush(stdout); /* Check aliasing */ for (i = 0; i < 1000 * flint_test_multiplier(); i++) { nmod_poly_t f, g; mp_limb_t c, mod; mod = n_randtest_prime(state, 0); nmod_poly_init(f, mod); nmod_poly_init(g, mod); nmod_poly_randtest(f, state, 1 + n_randint(state, 50)); c = n_randtest(state) % mod; nmod_poly_taylor_shift_horner(g, f, c); nmod_poly_taylor_shift_horner(f, f, c); if (!nmod_poly_equal(g, f)) { flint_printf("FAIL\n"); nmod_poly_print(f); flint_printf("\n"); nmod_poly_print(g); flint_printf("\n"); abort(); } nmod_poly_clear(f); nmod_poly_clear(g); } /* Compare with composition */ for (i = 0; i < 1000 * flint_test_multiplier(); i++) { nmod_poly_t f, g, h1, h2; mp_limb_t mod, c; mod = n_randtest_prime(state, 0); nmod_poly_init(f, mod); nmod_poly_init(g, mod); nmod_poly_init(h1, mod); nmod_poly_init(h2, mod); nmod_poly_randtest(f, state, 1 + n_randint(state, 50)); c = n_randtest(state) % mod; nmod_poly_set_coeff_ui(g, 1, 1); nmod_poly_set_coeff_ui(g, 0, c); nmod_poly_taylor_shift_horner(h1, f, c); nmod_poly_compose(h2, f, g); if (!nmod_poly_equal(h1, h2)) { flint_printf("FAIL\n"); nmod_poly_print(f); flint_printf("\n"); nmod_poly_print(g); flint_printf("\n"); nmod_poly_print(h1); flint_printf("\n"); nmod_poly_print(h2); flint_printf("\n"); abort(); } nmod_poly_clear(f); nmod_poly_clear(g); nmod_poly_clear(h1); nmod_poly_clear(h2); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int i, result; flint_rand_t state; flint_randinit(state); printf("mulmod...."); fflush(stdout); /* Aliasing res and a */ for (i = 0; i < 500; i++) { nmod_poly_t a, b, res, t, f; mp_limb_t n = n_randtest_prime(state, 0); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(f, n); nmod_poly_init(res, n); nmod_poly_init(t, n); nmod_poly_randtest(a, state, n_randint(state, 50)); nmod_poly_randtest(b, state, n_randint(state, 50)); do { nmod_poly_randtest(f, state, n_randint(state, 50)); } while (nmod_poly_is_zero(f)); nmod_poly_mulmod(res, a, b, f); nmod_poly_mulmod(a, a, b, f); result = (nmod_poly_equal(res, a)); if (!result) { printf("FAIL:\n"); printf("a:\n"); nmod_poly_print(a), printf("\n\n"); printf("b:\n"); nmod_poly_print(b), printf("\n\n"); printf("f:\n"); nmod_poly_print(f), printf("\n\n"); printf("res1:\n"); nmod_poly_print(res), printf("\n\n"); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(f); nmod_poly_clear(res); nmod_poly_clear(t); } /* Aliasing res and b */ for (i = 0; i < 500; i++) { nmod_poly_t a, b, res, t, f; mp_limb_t n = n_randtest_prime(state, 0); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(f, n); nmod_poly_init(res, n); nmod_poly_init(t, n); nmod_poly_randtest(a, state, n_randint(state, 50)); nmod_poly_randtest(b, state, n_randint(state, 50)); do { nmod_poly_randtest(f, state, n_randint(state, 50)); } while (nmod_poly_is_zero(f)); nmod_poly_mulmod(res, a, b, f); nmod_poly_mulmod(b, a, b, f); result = (nmod_poly_equal(res, b)); if (!result) { printf("FAIL:\n"); printf("a:\n"); nmod_poly_print(a), printf("\n\n"); printf("b:\n"); nmod_poly_print(b), printf("\n\n"); printf("f:\n"); nmod_poly_print(f), printf("\n\n"); printf("res1:\n"); nmod_poly_print(res), printf("\n\n"); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(f); nmod_poly_clear(res); nmod_poly_clear(t); } /* Aliasing res and f */ for (i = 0; i < 500; i++) { nmod_poly_t a, b, res, t, f; mp_limb_t n = n_randtest_prime(state, 0); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(f, n); nmod_poly_init(res, n); nmod_poly_init(t, n); nmod_poly_randtest(a, state, n_randint(state, 50)); nmod_poly_randtest(b, state, n_randint(state, 50)); do { nmod_poly_randtest(f, state, n_randint(state, 50)); } while (nmod_poly_is_zero(f)); nmod_poly_mulmod(res, a, b, f); nmod_poly_mulmod(f, a, b, f); result = (nmod_poly_equal(res, f)); if (!result) { printf("FAIL:\n"); printf("a:\n"); nmod_poly_print(a), printf("\n\n"); printf("b:\n"); nmod_poly_print(b), printf("\n\n"); printf("f:\n"); nmod_poly_print(f), printf("\n\n"); printf("res1:\n"); nmod_poly_print(res), printf("\n\n"); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(f); nmod_poly_clear(res); nmod_poly_clear(t); } /* No aliasing */ for (i = 0; i < 1000; i++) { nmod_poly_t a, b, res1, res2, t, f; mp_limb_t n = n_randtest_prime(state, 0); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(f, n); nmod_poly_init(res1, n); nmod_poly_init(res2, n); nmod_poly_init(t, n); nmod_poly_randtest(a, state, n_randint(state, 50)); nmod_poly_randtest(b, state, n_randint(state, 50)); do { nmod_poly_randtest(f, state, n_randint(state, 50)); } while (nmod_poly_is_zero(f)); nmod_poly_mulmod(res1, a, b, f); nmod_poly_mul(res2, a, b); nmod_poly_divrem(t, res2, res2, f); result = (nmod_poly_equal(res1, res2)); if (!result) { printf("FAIL:\n"); printf("a:\n"); nmod_poly_print(a), printf("\n\n"); printf("b:\n"); nmod_poly_print(b), printf("\n\n"); printf("f:\n"); nmod_poly_print(f), printf("\n\n"); printf("res1:\n"); nmod_poly_print(res1), printf("\n\n"); printf("res2:\n"); nmod_poly_print(res2), printf("\n\n"); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(f); nmod_poly_clear(res1); nmod_poly_clear(res2); nmod_poly_clear(t); } flint_randclear(state); printf("PASS\n"); return 0; }
int main(void) { int i, result; flint_rand_t state; flint_randinit(state); printf("shift_left_right...."); fflush(stdout); /* Check a << shift >> shift == a */ for (i = 0; i < 10000; i++) { nmod_poly_t a, b; mp_limb_t n = n_randtest_not_zero(state); long shift = n_randint(state, 100); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_randtest(a, state, n_randint(state, 100)); nmod_poly_shift_left(b, a, shift); nmod_poly_shift_right(b, b, shift); result = (nmod_poly_equal(a, b)); if (!result) { printf("FAIL:\n"); printf("shift = %ld, a->length = %ld, n = %lu\n", shift, a->length, a->mod.n); nmod_poly_print(a), printf("\n\n"); nmod_poly_print(b), printf("\n\n"); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); } /* Check a << shift >> shift == a aliasing the other way */ for (i = 0; i < 10000; i++) { nmod_poly_t a, b, c; mp_limb_t n = n_randtest_not_zero(state); long shift = n_randint(state, 100); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(c, n); nmod_poly_randtest(c, state, n_randint(state, 100)); nmod_poly_set(a, c); nmod_poly_shift_left(c, c, shift); nmod_poly_shift_right(b, c, shift); result = (nmod_poly_equal(a, b)); if (!result) { printf("FAIL:\n"); printf("shift = %ld, c->length = %ld, n = %lu\n", shift, c->length, a->mod.n); nmod_poly_print(a), printf("\n\n"); nmod_poly_print(b), printf("\n\n"); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(c); } flint_randclear(state); 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; printf("revert_series...."); fflush(stdout); flint_randinit(state); /* Check aliasing */ for (i = 0; i < 100; i++) { nmod_poly_t f, g; mp_limb_t m; long n; m = n_randtest_prime(state, 0); nmod_poly_init(f, m); nmod_poly_init(g, m); do { nmod_poly_randtest(g, state, n_randint(state, 100)); } while (nmod_poly_get_coeff_ui(g, 1) == 0); nmod_poly_set_coeff_ui(g, 0, 0); do { n = n_randint(state, 100); } while (n >= m); nmod_poly_revert_series(f, g, n); nmod_poly_revert_series(g, g, n); result = (nmod_poly_equal(f, g)); if (!result) { printf("FAIL (aliasing):\n"); nmod_poly_print(f), printf("\n\n"); nmod_poly_print(g), printf("\n\n"); abort(); } nmod_poly_clear(f); nmod_poly_clear(g); } /* Check f(f^(-1)) = id */ for (i = 0; i < 1000; i++) { nmod_poly_t f, g, h; mp_limb_t m; long n; m = n_randtest_prime(state, 0); nmod_poly_init(f, m); nmod_poly_init(g, m); nmod_poly_init(h, m); do { nmod_poly_randtest(g, state, n_randint(state, 100)); } while (nmod_poly_get_coeff_ui(g, 1) == 0); nmod_poly_set_coeff_ui(g, 0, 0); do { n = n_randint(state, 100); } while (n >= m); nmod_poly_revert_series(f, g, n); nmod_poly_compose_series(h, g, f, n); result = ((n <= 1 && nmod_poly_is_zero(h)) || (h->length == 2 && h->coeffs[0] == 0 && h->coeffs[1] == 1)); if (!result) { printf("FAIL (comparison):\n"); nmod_poly_print(g), printf("\n\n"); nmod_poly_print(f), printf("\n\n"); nmod_poly_print(h), printf("\n\n"); abort(); } nmod_poly_clear(f); nmod_poly_clear(g); nmod_poly_clear(h); } flint_randclear(state); printf("PASS\n"); return 0; }
int main(void) { int i, result; flint_rand_t state; flint_randinit(state); printf("xgcd_hgcd...."); fflush(stdout); /* Compare with result from gcd and check a*s + b*t = g */ for (i = 0; i < 1000; i++) { nmod_poly_t a, b, c, g1, g2, s, t, sum, temp; mp_limb_t n; do n = n_randtest_not_zero(state); while (!n_is_probabprime(n)); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(c, n); nmod_poly_init(g1, n); nmod_poly_init(g2, n); nmod_poly_init(s, n); nmod_poly_init(t, n); nmod_poly_init(sum, n); nmod_poly_init(temp, n); nmod_poly_randtest(a, state, n_randint(state, 600)); nmod_poly_randtest(b, state, n_randint(state, 600)); nmod_poly_randtest(c, state, n_randint(state, 400)); nmod_poly_mul(a, a, c); nmod_poly_mul(b, b, c); nmod_poly_gcd(g1, a, b); nmod_poly_xgcd_hgcd(g2, s, t, a, b); nmod_poly_mul(sum, s, a); nmod_poly_mul(temp, t, b); nmod_poly_add(sum, sum, temp); result = (nmod_poly_equal(g1, g2) && nmod_poly_equal(g1, sum) && (g1->length == 0 || g1->coeffs[g1->length - 1] == 1)); if (!result) { printf("FAIL:\n"); nmod_poly_print(a), printf("\n\n"); nmod_poly_print(b), printf("\n\n"); nmod_poly_print(c), printf("\n\n"); nmod_poly_print(g1), printf("\n\n"); nmod_poly_print(g2), printf("\n\n"); nmod_poly_print(sum), printf("\n\n"); nmod_poly_print(s), printf("\n\n"); nmod_poly_print(t), printf("\n\n"); printf("n = %ld\n", n); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(c); nmod_poly_clear(g1); nmod_poly_clear(g2); nmod_poly_clear(s); nmod_poly_clear(t); nmod_poly_clear(sum); nmod_poly_clear(temp); } /* Check aliasing of a and g */ for (i = 0; i < 200; i++) { nmod_poly_t a, b, g, s, t; mp_limb_t n; do n = n_randtest(state); while (!n_is_probabprime(n)); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(g, n); nmod_poly_init(s, n); nmod_poly_init(t, n); nmod_poly_randtest(a, state, n_randint(state, 200)); nmod_poly_randtest(b, state, n_randint(state, 200)); nmod_poly_xgcd_hgcd(g, s, t, a, b); nmod_poly_xgcd_hgcd(a, s, t, a, b); result = (nmod_poly_equal(a, g)); if (!result) { printf("FAIL:\n"); nmod_poly_print(a), printf("\n\n"); nmod_poly_print(b), printf("\n\n"); nmod_poly_print(g), printf("\n\n"); printf("n = %ld\n", n); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(g); nmod_poly_clear(s); nmod_poly_clear(t); } /* Check aliasing of b and g */ for (i = 0; i < 200; i++) { nmod_poly_t a, b, g, s, t; mp_limb_t n; do n = n_randtest(state); while (!n_is_probabprime(n)); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(g, n); nmod_poly_init(s, n); nmod_poly_init(t, n); nmod_poly_randtest(a, state, n_randint(state, 200)); nmod_poly_randtest(b, state, n_randint(state, 200)); nmod_poly_xgcd_hgcd(g, s, t, a, b); nmod_poly_xgcd_hgcd(b, s, t, a, b); result = (nmod_poly_equal(b, g)); if (!result) { printf("FAIL:\n"); nmod_poly_print(a), printf("\n\n"); nmod_poly_print(b), printf("\n\n"); nmod_poly_print(g), printf("\n\n"); printf("n = %ld\n", n); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(g); nmod_poly_clear(s); nmod_poly_clear(t); } /* Check aliasing of s and a */ for (i = 0; i < 200; i++) { nmod_poly_t a, b, g, s, t; mp_limb_t n; do n = n_randtest(state); while (!n_is_probabprime(n)); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(g, n); nmod_poly_init(s, n); nmod_poly_init(t, n); nmod_poly_randtest(a, state, n_randint(state, 200)); nmod_poly_randtest(b, state, n_randint(state, 200)); nmod_poly_xgcd_hgcd(g, s, t, a, b); nmod_poly_xgcd_hgcd(g, a, t, a, b); result = (nmod_poly_equal(s, a)); if (!result) { printf("FAIL:\n"); nmod_poly_print(a), printf("\n\n"); nmod_poly_print(s), printf("\n\n"); printf("n = %ld\n", n); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(g); nmod_poly_clear(s); nmod_poly_clear(t); } /* Check aliasing of s and b */ for (i = 0; i < 200; i++) { nmod_poly_t a, b, g, s, t; mp_limb_t n; do n = n_randtest(state); while (!n_is_probabprime(n)); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(g, n); nmod_poly_init(s, n); nmod_poly_init(t, n); nmod_poly_randtest(a, state, n_randint(state, 200)); nmod_poly_randtest(b, state, n_randint(state, 200)); nmod_poly_xgcd_hgcd(g, s, t, a, b); nmod_poly_xgcd_hgcd(g, b, t, a, b); result = (nmod_poly_equal(s, b)); if (!result) { printf("FAIL:\n"); nmod_poly_print(b), printf("\n\n"); nmod_poly_print(s), printf("\n\n"); printf("n = %ld\n", n); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(g); nmod_poly_clear(s); nmod_poly_clear(t); } /* Check aliasing of t and a */ for (i = 0; i < 200; i++) { nmod_poly_t a, b, g, s, t; mp_limb_t n; do n = n_randtest(state); while (!n_is_probabprime(n)); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(g, n); nmod_poly_init(s, n); nmod_poly_init(t, n); nmod_poly_randtest(a, state, n_randint(state, 200)); nmod_poly_randtest(b, state, n_randint(state, 200)); nmod_poly_xgcd_hgcd(g, s, t, a, b); nmod_poly_xgcd_hgcd(g, s, a, a, b); result = (nmod_poly_equal(t, a)); if (!result) { printf("FAIL:\n"); nmod_poly_print(a), printf("\n\n"); nmod_poly_print(t), printf("\n\n"); printf("n = %ld\n", n); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(g); nmod_poly_clear(s); nmod_poly_clear(t); } /* Check aliasing of t and b */ for (i = 0; i < 200; i++) { nmod_poly_t a, b, g, s, t; mp_limb_t n; do n = n_randtest(state); while (!n_is_probabprime(n)); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(g, n); nmod_poly_init(s, n); nmod_poly_init(t, n); nmod_poly_randtest(a, state, n_randint(state, 200)); nmod_poly_randtest(b, state, n_randint(state, 200)); nmod_poly_xgcd_hgcd(g, s, t, a, b); nmod_poly_xgcd_hgcd(g, s, b, a, b); result = (nmod_poly_equal(t, b)); if (!result) { printf("FAIL:\n"); nmod_poly_print(b), printf("\n\n"); nmod_poly_print(t), printf("\n\n"); printf("n = %ld\n", n); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(g); nmod_poly_clear(s); nmod_poly_clear(t); } flint_randclear(state); 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 iter; flint_rand_t state; flint_randinit(state); printf("factor...."); fflush(stdout); /* Default algorithm */ for (iter = 0; iter < 100; iter++) { int result = 1; nmod_poly_t pol1, poly, quot, rem, product; nmod_poly_factor_t res; mp_limb_t modulus, lead = 1; long length, num, i, j; ulong exp[5], prod1; modulus = n_randtest_prime(state, 0); nmod_poly_init(pol1, modulus); nmod_poly_init(poly, modulus); nmod_poly_init(quot, modulus); nmod_poly_init(rem, modulus); nmod_poly_zero(pol1); nmod_poly_set_coeff_ui(pol1, 0, 1); length = n_randint(state, 7) + 2; do { nmod_poly_randtest(poly, state, length); if (poly->length) nmod_poly_make_monic(poly, poly); } while ((!nmod_poly_is_irreducible(poly)) || (poly->length < 2)); exp[0] = n_randint(state, 30) + 1; prod1 = exp[0]; for (i = 0; i < exp[0]; i++) nmod_poly_mul(pol1, pol1, poly); num = n_randint(state, 5) + 1; for (i = 1; i < num; i++) { do { length = n_randint(state, 7) + 2; nmod_poly_randtest(poly, state, length); if (poly->length) { nmod_poly_make_monic(poly, poly); nmod_poly_divrem(quot, rem, pol1, poly); } } while ((!nmod_poly_is_irreducible(poly)) || (poly->length < 2) || (rem->length == 0)); exp[i] = n_randint(state, 30) + 1; prod1 *= exp[i]; for (j = 0; j < exp[i]; j++) nmod_poly_mul(pol1, pol1, poly); } nmod_poly_factor_init(res); switch (n_randint(state, 3)) { case 0: lead = nmod_poly_factor(res, pol1); break; case 1: lead = nmod_poly_factor_with_berlekamp(res, pol1); break; case 2: if (modulus == 2) lead = nmod_poly_factor(res, pol1); else lead = nmod_poly_factor_with_cantor_zassenhaus(res, pol1); break; } result &= (res->num == num); if (!result) { printf("Error: number of factors incorrect, %ld, %ld\n", res->num, num); abort(); } nmod_poly_init(product, pol1->mod.n); nmod_poly_set_coeff_ui(product, 0, 1); for (i = 0; i < res->num; i++) for (j = 0; j < res->exp[i]; j++) nmod_poly_mul(product, product, res->p + i); nmod_poly_scalar_mul_nmod(product, product, lead); result &= nmod_poly_equal(pol1, product); if (!result) { printf("Error: product of factors does not equal original polynomial\n"); nmod_poly_print(pol1); printf("\n"); nmod_poly_print(product); printf("\n"); abort(); } nmod_poly_clear(product); nmod_poly_clear(quot); nmod_poly_clear(rem); nmod_poly_clear(pol1); nmod_poly_clear(poly); nmod_poly_factor_clear(res); } /* Test deflation trick */ for (iter = 0; iter < 100; iter++) { nmod_poly_t pol1, poly, quot, rem; nmod_poly_factor_t res, res2; mp_limb_t modulus; long length, num, i, j; long exp[5], prod1; ulong inflation; int found; do { modulus = n_randtest_prime(state, 0); } while (modulus == 2); /* To compare with CZ */ nmod_poly_init(pol1, modulus); nmod_poly_init(poly, modulus); nmod_poly_init(quot, modulus); nmod_poly_init(rem, modulus); nmod_poly_zero(pol1); nmod_poly_set_coeff_ui(pol1, 0, 1); inflation = n_randint(state, 7) + 1; length = n_randint(state, 7) + 2; do { nmod_poly_randtest(poly, state, length); if (poly->length) nmod_poly_make_monic(poly, poly); } while ((!nmod_poly_is_irreducible(poly)) || (poly->length < 2)); nmod_poly_inflate(poly, poly, inflation); exp[0] = n_randint(state, 6) + 1; prod1 = exp[0]; for (i = 0; i < exp[0]; i++) nmod_poly_mul(pol1, pol1, poly); num = n_randint(state, 5) + 1; for (i = 1; i < num; i++) { do { length = n_randint(state, 6) + 2; nmod_poly_randtest(poly, state, length); if (poly->length) { nmod_poly_make_monic(poly, poly); nmod_poly_divrem(quot, rem, pol1, poly); } } while ((!nmod_poly_is_irreducible(poly)) || (poly->length < 2) || (rem->length == 0)); exp[i] = n_randint(state, 6) + 1; prod1 *= exp[i]; nmod_poly_inflate(poly, poly, inflation); for (j = 0; j < exp[i]; j++) nmod_poly_mul(pol1, pol1, poly); } nmod_poly_factor_init(res); nmod_poly_factor_init(res2); switch (n_randint(state, 3)) { case 0: nmod_poly_factor(res, pol1); break; case 1: nmod_poly_factor_with_berlekamp(res, pol1); break; case 2: nmod_poly_factor_with_cantor_zassenhaus(res, pol1); break; } nmod_poly_factor_cantor_zassenhaus(res2, pol1); if (res->num != res2->num) { printf("FAIL: different number of factors found\n"); abort(); } for (i = 0; i < res->num; i++) { found = 0; for (j = 0; j < res2->num; j++) { if (nmod_poly_equal(res->p + i, res2->p + j) && res->exp[i] == res2->exp[j]) { found = 1; break; } } if (!found) { printf("FAIL: factor not found\n"); abort(); } } nmod_poly_clear(quot); nmod_poly_clear(rem); nmod_poly_clear(pol1); nmod_poly_clear(poly); nmod_poly_factor_clear(res); nmod_poly_factor_clear(res2); } flint_randclear(state); printf("PASS\n"); return 0; }
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_TEST_INIT(state); flint_printf("atanh_series...."); fflush(stdout); /* Check 2*atanh(A) = atanh(2*A/(1+A^2)) */ for (i = 0; i < 100 * flint_test_multiplier(); i++) { nmod_poly_t A, B, atanhA, atanhB; 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(B, mod); nmod_poly_init(atanhA, mod); nmod_poly_init(atanhB, mod); nmod_poly_randtest(A, state, n_randint(state, 100)); nmod_poly_set_coeff_ui(A, 0, UWORD(0)); nmod_poly_mullow(B, A, A, n); nmod_poly_set_coeff_ui(B, 0, UWORD(1)); nmod_poly_div_series(B, A, B, n); nmod_poly_add(B, B, B); nmod_poly_atanh_series(atanhA, A, n); nmod_poly_atanh_series(atanhB, B, n); nmod_poly_add(atanhA, atanhA, atanhA); result = nmod_poly_equal(atanhA, atanhB); 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("B: "); nmod_poly_print(B), flint_printf("\n\n"); flint_printf("2*atanh(A): "); nmod_poly_print(atanhA), flint_printf("\n\n"); flint_printf("atanh(B): "); nmod_poly_print(atanhB), flint_printf("\n\n"); abort(); } nmod_poly_clear(A); nmod_poly_clear(B); nmod_poly_clear(atanhA); nmod_poly_clear(atanhB); } /* 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_atanh_series(B, A, n); nmod_poly_atanh_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; }