void nmod_poly_mat_det(nmod_poly_t det, const nmod_poly_mat_t A) { slong n = A->r; if (n == 0) { nmod_poly_one(det); } else if (n == 1) { nmod_poly_set(det, nmod_poly_mat_entry(A, 0, 0)); } else if (n == 2) { nmod_poly_t tmp; nmod_poly_init(tmp, nmod_poly_mat_modulus(A)); nmod_poly_mul(det, nmod_poly_mat_entry(A, 0, 0), nmod_poly_mat_entry(A, 1, 1)); nmod_poly_mul(tmp, nmod_poly_mat_entry(A, 0, 1), nmod_poly_mat_entry(A, 1, 0)); nmod_poly_sub(det, det, tmp); nmod_poly_clear(tmp); } else if (n < 15) /* should be entry sensitive too */ { nmod_poly_mat_det_fflu(det, A); } else { nmod_poly_mat_det_interpolate(det, A); } }
/*------------------------------------------------------------*/ void check(int opt){ long i; flint_rand_t state; flint_randinit(state); mp_limb_t n = 65537; for (i = 1; i < 200; i+=20){ mp_ptr powers_inverse_square_q = _nmod_vec_init(2*i-1); nmod_poly_t S; nmod_poly_init(S, n); mp_limb_t q = nmod_poly_find_root(2*i, S->mod); if (opt == 1){ nmod_poly_eval_geom_prepare(powers_inverse_square_q, S, q, i); sage_output_init(S->mod); printf("q = k(%lu)\n", q); printf("i = %lu\n", i); sage_output_assign_poly(S, "S"); sage_output_assign_vec(powers_inverse_square_q, 2*i-1, "powers_inverse_square_q"); printf("powers_inverse_square_q == [1/q^(j^2) for j in range(2*i-1)]\n"); printf("S == U([q^(j^2) for j in range(2*i-1)])\n"); } else{ double t, u; long j; t = util_gettime(); for (j = 0; j < 10000; j++) nmod_poly_eval_geom_prepare(powers_inverse_square_q, S, q, i); t = util_gettime() - t; nmod_poly_t tmp1, tmp2, tmp3; nmod_poly_init(tmp1, n); nmod_poly_init(tmp2, n); nmod_poly_init(tmp3, n); nmod_poly_rand_dense(tmp1, state, i); nmod_poly_rand_dense(tmp2, state, i); u = util_gettime(); for (j = 0; j < 10000; j++) nmod_poly_mul(tmp3, tmp1, tmp2); u = util_gettime() - u; nmod_poly_clear(tmp1); nmod_poly_clear(tmp2); nmod_poly_clear(tmp3); printf("%lu %f %f\n", i, t, u); } nmod_poly_clear(S); _nmod_vec_clear(powers_inverse_square_q); } flint_randclear(state); }
/*------------------------------------------------------------*/ void check(int opt){ long i; flint_rand_t state; flint_randinit(state); mp_limb_t n = 65537; for (i = 1; i < 200; i+=20){ nmod_poly_t A, B, C; nmod_poly_init(A, n); nmod_poly_init(B, n); nmod_poly_init(C, n); nmod_poly_rand_dense_monic(A, state, i); nmod_poly_rand_dense(B, state, i); if (opt == 1){ nmod_poly_invmod(C, B, A); sage_output_init(A->mod); sage_output_assign_poly(A, "A"); sage_output_assign_poly(B, "B"); sage_output_assign_poly(C, "C"); printf("C*B %% A == 1\n"); } else{ double t, u; long j; t = util_gettime(); for (j = 0; j < 10000; j++) nmod_poly_invmod(C, B, A); t = util_gettime() - t; nmod_poly_t tmp1, tmp2, tmp3; nmod_poly_init(tmp1, n); nmod_poly_init(tmp2, n); nmod_poly_init(tmp3, n); nmod_poly_rand_dense(tmp1, state, i); nmod_poly_rand_dense(tmp2, state, i); u = util_gettime(); for (j = 0; j < 10000; j++) nmod_poly_mul(tmp3, tmp1, tmp2); u = util_gettime() - u; nmod_poly_clear(tmp1); nmod_poly_clear(tmp2); nmod_poly_clear(tmp3); printf("%lu %f %f\n", i, t, u); } nmod_poly_clear(A); nmod_poly_clear(B); nmod_poly_clear(C); } flint_randclear(state); }
/*------------------------------------------------------------*/ void check(int opt){ long i; flint_rand_t state; flint_randinit(state); mp_limb_t n = 65537; nmod_t mod; nmod_init(&mod, n); for (i = 1; i < 200; i+=1){ mp_ptr val = _nmod_vec_init(i); mp_limb_t q = nmod_poly_find_root(i, mod); if (opt == 1){ nmod_poly_eval_geom_derivative_fanin(val, q, i, mod); sage_output_init(mod); printf("q = k(%lu)\n", q); printf("i = %lu\n", i); sage_output_assign_vec(val, i, "val"); printf("P = mul([x-q^j for j in range(i)])\n"); printf("val == [P.derivative()(q^j) for j in range(i)]\n"); } else{ double t, u; long j; t = util_gettime(); for (j = 0; j < 10000; j++) nmod_poly_eval_geom_derivative_fanin(val, q, i, mod); t = util_gettime() - t; nmod_poly_t tmp1, tmp2, tmp3; nmod_poly_init(tmp1, n); nmod_poly_init(tmp2, n); nmod_poly_init(tmp3, n); nmod_poly_rand_dense(tmp1, state, i); nmod_poly_rand_dense(tmp2, state, i); u = util_gettime(); for (j = 0; j < 10000; j++) nmod_poly_mul(tmp3, tmp1, tmp2); u = util_gettime() - u; nmod_poly_clear(tmp1); nmod_poly_clear(tmp2); nmod_poly_clear(tmp3); printf("%lu %f %f\n", i, t, u); } _nmod_vec_clear(val); } flint_randclear(state); }
void nmod_poly_mat_scalar_mul_nmod_poly(nmod_poly_mat_t B, const nmod_poly_mat_t A, const nmod_poly_t c) { long i, j; for (i = 0; i < nmod_poly_mat_nrows(B); i++) for (j = 0; j < nmod_poly_mat_ncols(B); j++) nmod_poly_mul(nmod_poly_mat_entry(B, i, j), nmod_poly_mat_entry(A, i, j), c); }
void nmod_poly_pow(nmod_poly_t res, const nmod_poly_t poly, ulong e) { const slong len = poly->length; slong rlen; if ((len < 2) | (e < UWORD(3))) { if (len == 0) nmod_poly_zero(res); else if (len == 1) { nmod_poly_fit_length(res, 1); res->coeffs[0] = n_powmod2_ui_preinv(poly->coeffs[0], e, poly->mod.n, poly->mod.ninv); res->length = 1; _nmod_poly_normalise(res); } else if (e == UWORD(0)) { nmod_poly_set_coeff_ui(res, 0, UWORD(1)); res->length = 1; _nmod_poly_normalise(res); } else if (e == UWORD(1)) nmod_poly_set(res, poly); else /* e == UWORD(2) */ nmod_poly_mul(res, poly, poly); return; } rlen = (slong) e * (len - 1) + 1; if (res != poly) { nmod_poly_fit_length(res, rlen); _nmod_poly_pow(res->coeffs, poly->coeffs, len, e, poly->mod); } else { nmod_poly_t t; nmod_poly_init2(t, poly->mod.n, rlen); _nmod_poly_pow(t->coeffs, poly->coeffs, len, e, poly->mod); nmod_poly_swap(res, t); nmod_poly_clear(t); } res->length = rlen; _nmod_poly_normalise(res); }
void nmod_poly_mulmod(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2, const nmod_poly_t f) { long len1, len2, lenf; mp_ptr fcoeffs; lenf = f->length; len1 = poly1->length; len2 = poly2->length; if (lenf == 0) { printf("Exception: nmod_poly_mulmod: divide by zero\n"); abort(); } if (lenf == 1 || len1 == 0 || len2 == 0) { nmod_poly_zero(res); return; } if (len1 + len2 - lenf > 0) { if (f == res) { fcoeffs = flint_malloc(sizeof(mp_limb_t) * lenf); _nmod_vec_set(fcoeffs, f->coeffs, lenf); } else fcoeffs = f->coeffs; nmod_poly_fit_length(res, lenf - 1); _nmod_poly_mulmod(res->coeffs, poly1->coeffs, len1, poly2->coeffs, len2, fcoeffs, lenf, res->mod); if (f == res) flint_free(fcoeffs); res->length = lenf - 1; _nmod_poly_normalise(res); } else { nmod_poly_mul(res, poly1, poly2); } }
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_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, 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_rand_t state; flint_randinit(state); printf("rem...."); fflush(stdout); /* Check result of rem */ for (i = 0; i < 1000; i++) { nmod_poly_t a, b, q, r, prod; 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(q, n); nmod_poly_init(r, n); nmod_poly_init(prod, n); nmod_poly_randtest(a, state, n_randint(state, 2000)); do nmod_poly_randtest(b, state, n_randint(state, 2000)); while (b->length == 0); nmod_poly_div(q, a, b); nmod_poly_rem(r, a, b); nmod_poly_mul(prod, q, b); nmod_poly_add(prod, prod, r); result = (nmod_poly_equal(a, prod)); if (!result) { printf("FAIL:\n"); nmod_poly_print(a), printf("\n\n"); nmod_poly_print(prod), printf("\n\n"); nmod_poly_print(q), printf("\n\n"); nmod_poly_print(r), printf("\n\n"); printf("n = %ld\n", n); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(q); nmod_poly_clear(r); nmod_poly_clear(prod); } /* Check aliasing of a and r */ for (i = 0; i < 1000; i++) { nmod_poly_t a, b, r; 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(r, n); nmod_poly_randtest(a, state, n_randint(state, 2000)); do nmod_poly_randtest(b, state, n_randint(state, 2000)); while (b->length == 0); nmod_poly_rem(r, a, b); nmod_poly_rem(a, a, b); result = (nmod_poly_equal(a, r)); if (!result) { printf("FAIL:\n"); nmod_poly_print(a), printf("\n\n"); nmod_poly_print(b), printf("\n\n"); nmod_poly_print(r), printf("\n\n"); printf("n = %ld\n", n); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(r); } /* Check aliasing of b and r */ for (i = 0; i < 1000; i++) { nmod_poly_t a, b, r; 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(r, n); nmod_poly_randtest(a, state, n_randint(state, 2000)); do nmod_poly_randtest(b, state, n_randint(state, 2000)); while (b->length == 0); nmod_poly_rem(r, a, b); nmod_poly_rem(b, a, b); result = (nmod_poly_equal(b, r)); if (!result) { printf("FAIL:\n"); nmod_poly_print(a), printf("\n\n"); nmod_poly_print(b), printf("\n\n"); nmod_poly_print(r), printf("\n\n"); printf("n = %ld\n", n); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(r); } /* Check result of rem_q1 */ for (i = 0; i < 5000; i++) { nmod_poly_t a, b, q0, r0, r; mp_limb_t n = n_randprime(state, n_randint(state,FLINT_BITS-1)+2, 0); nmod_poly_init(a, n); nmod_poly_init(b, n); nmod_poly_init(q0, n); nmod_poly_init(r0, n); nmod_poly_init(r, n); do nmod_poly_randtest(a, state, n_randint(state, 1000)); while (a->length < 2); nmod_poly_fit_length(b, a->length - 1); mpn_zero(b->coeffs, a->length - 1); nmod_poly_randtest_not_zero(b, state, n_randint(state, 1000) + 1); do b->coeffs[a->length - 2] = n_randint(state, n); while (b->coeffs[a->length - 2] == 0); b->length = a->length - 1; nmod_poly_divrem(q0, r0, a, b); nmod_poly_rem(r, a, b); result = (nmod_poly_equal(r0, r)); if (!result) { printf("FAIL:\n"); nmod_poly_print(a), printf("\n\n"); nmod_poly_print(b), printf("\n\n"); nmod_poly_print(q0), printf("\n\n"); nmod_poly_print(r0), printf("\n\n"); nmod_poly_print(r), printf("\n\n"); printf("n = %ld\n", n); abort(); } nmod_poly_clear(a); nmod_poly_clear(b); nmod_poly_clear(q0); nmod_poly_clear(r0); nmod_poly_clear(r); } flint_randclear(state); printf("PASS\n"); return 0; }
/*------------------------------------------------------------*/ void check(int opt){ long i; flint_rand_t state; flint_randinit(state); mp_limb_t n = 65537; for (i = 0; i < 1000; i+=10){ nmod_poly_t P; nmod_poly_init(P, n); nmod_poly_rand_dense_monic(P, state, i); nmod_poly_t S0; nmod_poly_init(S0, n); if (opt == 1){ nmod_poly_inverse_reverse(S0, P, i+10); sage_output_init(P->mod); sage_output_assign_poly(P, "P"); sage_output_assign_poly(S0, "S0"); nmod_poly_inverse_reverse_main(P, P); sage_output_assign_poly(P, "S1"); printf("print (S0*P.reverse()) %% x^%lu == 1\n", i+10); if (i > 1) printf("print (S1*P.reverse()) %% x^%lu == 1\n", i-1); } else{ double t, u; long j; t = util_gettime(); for (j = 0; j < 10000; j++) nmod_poly_inverse_reverse_main(S0, P); t = util_gettime() - t; nmod_poly_t tmp1, tmp2, tmp3; nmod_poly_init(tmp1, n); nmod_poly_init(tmp2, n); nmod_poly_init(tmp3, n); nmod_poly_rand_dense(tmp1, state, i); nmod_poly_rand_dense(tmp2, state, i); u = util_gettime(); for (j = 0; j < 10000; j++) nmod_poly_mul(tmp3, tmp1, tmp2); u = util_gettime() - u; nmod_poly_clear(tmp1); nmod_poly_clear(tmp2); nmod_poly_clear(tmp3); printf("%lu %f %f\n", i, t, u); } nmod_poly_clear(P); nmod_poly_clear(S0); } flint_randclear(state); }
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; 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, 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 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; 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; }
/*------------------------------------------------------------*/ void check(int opt){ long i; flint_rand_t state; flint_randinit(state); for (i = 1; i < 1000; i+=10){ mp_limb_t n = 0; while (n < i) n = n_randtest_prime(state, 0); nmod_poly_t P; mp_ptr roots; nmod_poly_t A; nmod_poly_init(P, n); roots = _nmod_vec_init(i); _nmod_vec_randtest(roots, state, i, P->mod); nmod_poly_product_roots_nmod_vec(P, roots, i); nmod_poly_init(A, n); nmod_poly_rand_dense(A, state, i); if (opt == 1){ mp_limb_t tr1 = nmod_poly_trace(A, P); mp_limb_t tr2 = 0; long j; for (j = 0; j < i; j++) tr2 = nmod_add(tr2, nmod_poly_evaluate_nmod(A, roots[j]), P->mod); sage_output_init(P->mod); sage_output_assign_poly(P, "P"); printf("tr1 = %lu\n", tr1); printf("tr2 = %lu\n", tr2); printf("tr1 == tr2\n"); } else{ double t, u; long j; t = util_gettime(); for (j = 0; j < 10000; j++) nmod_poly_trace(A, P); t = util_gettime() - t; nmod_poly_t tmp1, tmp2, tmp3; nmod_poly_init(tmp1, n); nmod_poly_init(tmp2, n); nmod_poly_init(tmp3, n); nmod_poly_rand_dense(tmp1, state, i); nmod_poly_rand_dense(tmp2, state, i); u = util_gettime(); for (j = 0; j < 10000; j++) nmod_poly_mul(tmp3, tmp1, tmp2); u = util_gettime() - u; nmod_poly_clear(tmp1); nmod_poly_clear(tmp2); nmod_poly_clear(tmp3); printf("%lu %f %f\n", i, t, u); } nmod_poly_clear(P); nmod_poly_clear(A); _nmod_vec_clear(roots); } }
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 iter; FLINT_TEST_INIT(state); flint_printf("is_squarefree...."); fflush(stdout); for (iter = 0; iter < 200 * flint_test_multiplier(); iter++) { nmod_poly_t poly, Q, R, t; mp_limb_t modulus; slong i, num_factors, exp, max_exp; int v, result; modulus = n_randtest_prime(state, 0); nmod_poly_init(poly, modulus); nmod_poly_init(t, modulus); nmod_poly_init(Q, modulus); nmod_poly_init(R, modulus); nmod_poly_set_coeff_ui(poly, 0, n_randint(state, modulus)); num_factors = n_randint(state, 5); max_exp = 0; for (i = 0; i < num_factors; i++) { do { nmod_poly_randtest(t, state, n_randint(state, 10)); } while (!nmod_poly_is_irreducible(t) || (nmod_poly_length(t) < 2)); exp = n_randint(state, 4) + 1; if (n_randint(state, 2) == 0) exp = 1; nmod_poly_divrem(Q, R, poly, t); if (!nmod_poly_is_zero(R)) { nmod_poly_pow(t, t, exp); nmod_poly_mul(poly, poly, t); max_exp = FLINT_MAX(exp, max_exp); } } v = nmod_poly_is_squarefree(poly); if (v == 1) result = (max_exp <= 1 && !nmod_poly_is_zero(poly)); else result = (max_exp > 1 || nmod_poly_is_zero(poly)); if (!result) { flint_printf("FAIL: %wu, %wd, %d\n", modulus, max_exp, v); nmod_poly_print(poly); flint_printf("\n"); abort(); } nmod_poly_clear(poly); nmod_poly_clear(t); nmod_poly_clear(Q); nmod_poly_clear(R); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
slong nmod_poly_mat_rref(nmod_poly_mat_t R, nmod_poly_t den, const nmod_poly_mat_t A) { slong i, j, k, m, n, rank; slong *pivots, *nonpivots; rank = nmod_poly_mat_fflu(R, den, NULL, A, 0); m = nmod_poly_mat_nrows(R); n = nmod_poly_mat_ncols(R); /* clear bottom */ for (i = rank; i < m; i++) for (j = 0; j < n; j++) nmod_poly_zero(nmod_poly_mat_entry(R, i, j)); /* Convert row echelon form to reduced row echelon form */ if (rank > 1) { nmod_poly_t tmp, tmp2; nmod_poly_init(tmp, nmod_poly_mat_modulus(R)); nmod_poly_init(tmp2, nmod_poly_mat_modulus(R)); pivots = flint_malloc(sizeof(slong) * n); nonpivots = pivots + rank; /* find pivot positions */ for (i = j = k = 0; i < rank; i++) { while (nmod_poly_is_zero(nmod_poly_mat_entry(R, i, j))) { nonpivots[k] = j; k++; j++; } pivots[i] = j; j++; } while (k < n - rank) { nonpivots[k] = j; k++; j++; } for (k = 0; k < n - rank; k++) { for (i = rank - 2; i >= 0; i--) { nmod_poly_mul(tmp, den, nmod_poly_mat_entry(R, i, nonpivots[k])); for (j = i + 1; j < rank; j++) { nmod_poly_mul(tmp2, nmod_poly_mat_entry(R, i, pivots[j]), nmod_poly_mat_entry(R, j, nonpivots[k])); nmod_poly_sub(tmp, tmp, tmp2); } nmod_poly_div(nmod_poly_mat_entry(R, i, nonpivots[k]), tmp, nmod_poly_mat_entry(R, i, pivots[i])); } } /* clear pivot columns */ for (i = 0; i < rank; i++) { for (j = 0; j < rank; j++) { if (i == j) nmod_poly_set(nmod_poly_mat_entry(R, j, pivots[i]), den); else nmod_poly_zero(nmod_poly_mat_entry(R, j, pivots[i])); } } flint_free(pivots); nmod_poly_clear(tmp); nmod_poly_clear(tmp2); } return rank; }