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 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 main() { slong i; mp_limb_t p, w; nmod_poly_t f; mp_ptr res, res2, vect; // p premier // Le cardinal du groupe multiplicatif doit être une puissance de 2 // Ne marche que pour p = 0, 1, 2, 3, 5, 17, 257, 65537. p = 17; nmod_poly_init(f, p); nmod_poly_set_coeff_ui(f, 0, 0); nmod_poly_set_coeff_ui(f, 1, 1); nmod_poly_set_coeff_ui(f, 2, 2); nmod_poly_set_coeff_ui(f, 3, 1); nmod_poly_set_coeff_ui(f, 4, 1); w = n_primitive_root_prime(p); res = _nmod_vec_init(p); nmod_poly_fft_pow2(res, f, w); flint_printf("w : %d\n", w); _fmpz_vec_print(res, p); flint_printf("\n"); vect = _nmod_vec_init(p); for(i = 0 ; i < p ; i++) { vect[i] = i; } res2 = _nmod_vec_init(p); nmod_poly_evaluate_nmod_vec(res2, f, vect, p); _fmpz_vec_print(res2, p); flint_printf("\nBooléen d'égalité : %d\n", _nmod_vec_equal(res,res2,p)); nmod_poly_clear(f); _nmod_vec_clear(res); _nmod_vec_clear(res2); _nmod_vec_clear(vect); return 0; }
void nmod_poly_factor_cantor_zassenhaus(nmod_poly_factor_t res, const nmod_poly_t f) { nmod_poly_t h, v, g, x; slong i, j, num; nmod_poly_init_preinv(h, f->mod.n, f->mod.ninv); nmod_poly_init_preinv(g, f->mod.n, f->mod.ninv); nmod_poly_init_preinv(v, f->mod.n, f->mod.ninv); nmod_poly_init_preinv(x, f->mod.n, f->mod.ninv); nmod_poly_set_coeff_ui(h, 1, 1); nmod_poly_set_coeff_ui(x, 1, 1); nmod_poly_make_monic(v, f); i = 0; do { i++; nmod_poly_powmod_ui_binexp(h, h, f->mod.n, v); nmod_poly_sub(h, h, x); nmod_poly_gcd(g, h, v); nmod_poly_add(h, h, x); if (g->length != 1) { nmod_poly_make_monic(g, g); num = res->num; nmod_poly_factor_equal_deg(res, g, i); for (j = num; j < res->num; j++) res->exp[j] = nmod_poly_remove(v, res->p + j); } } while (v->length >= 2*i + 3); if (v->length > 1) nmod_poly_factor_insert(res, v, 1); nmod_poly_clear(g); nmod_poly_clear(h); nmod_poly_clear(v); nmod_poly_clear(x); }
void nmod_poly_cosh_series(nmod_poly_t g, const nmod_poly_t h, long n) { mp_ptr g_coeffs, h_coeffs; nmod_poly_t t1; long h_len; h_len = h->length; if (h_len > 0 && h->coeffs[0] != 0UL) { printf("Exception: nmod_poly_cosh_series: constant term != 0\n"); abort(); } if (h_len == 1 || n < 2) { nmod_poly_zero(g); if (n > 0) nmod_poly_set_coeff_ui(g, 0, 1UL); return; } if (h_len < n) { h_coeffs = _nmod_vec_init(n); mpn_copyi(h_coeffs, h->coeffs, h_len); mpn_zero(h_coeffs + h_len, n - h_len); } else h_coeffs = h->coeffs; if (h == g && h_len >= n) { nmod_poly_init2(t1, h->mod.n, n); g_coeffs = t1->coeffs; } else { nmod_poly_fit_length(g, n); g_coeffs = g->coeffs; } _nmod_poly_cosh_series(g_coeffs, h_coeffs, n, h->mod); if (h == g && h_len >= n) { nmod_poly_swap(g, t1); nmod_poly_clear(t1); } g->length = n; if (h_len < n) _nmod_vec_free(h_coeffs); _nmod_poly_normalise(g); }
int main(void) { int i, result = 1; FLINT_TEST_INIT(state); flint_printf("exp_series_monomial_ui...."); fflush(stdout); for (i = 0; i < 1000 * flint_test_multiplier(); i++) { nmod_poly_t A, expA, res; slong n; mp_limb_t mod; ulong power; mp_limb_t coeff; mod = n_randtest_prime(state, 0); n = n_randtest(state) % 100; n = FLINT_MIN(n, mod); nmod_poly_init(A, mod); nmod_poly_init(expA, mod); nmod_poly_init(res, mod); coeff = n_randlimb(state) % mod; power = 1 + n_randint(state, 2*n + 1); nmod_poly_set_coeff_ui(A, power, coeff); nmod_poly_exp_series(expA, A, n); nmod_poly_exp_series_monomial_ui(res, coeff, power, n); result = nmod_poly_equal(expA, res); if (!result) { flint_printf("FAIL:\n"); flint_printf("n = %wd, mod = %wu\n", n, mod); flint_printf("power = %wu, coeff = %wu\n", power, coeff); flint_printf("A: "); nmod_poly_print(A), flint_printf("\n\n"); flint_printf("exp(A): "); nmod_poly_print(expA), flint_printf("\n\n"); flint_printf("res: "); nmod_poly_print(res), flint_printf("\n\n"); abort(); } nmod_poly_clear(A); nmod_poly_clear(expA); nmod_poly_clear(res); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
void fq_zech_get_fq_nmod(fq_nmod_t rop, const fq_zech_t op, const fq_zech_ctx_t ctx) { slong i; mp_limb_t q, r; nmod_poly_fit_length(rop, fq_zech_ctx_degree(ctx)); q = ctx->eval_table[op->value]; i = 0; while (q >= ctx->p) { r = n_divrem2_precomp(&q, q, ctx->p, ctx->ppre); nmod_poly_set_coeff_ui(rop, i, r); i ++; } nmod_poly_set_coeff_ui(rop, i, q); }
explicit Flintzz_pX(const zz_pX& a) { long da = deg(a); nmod_poly_init2(value, zz_p::modulus(), da+1); for (long i = 0; i <= da; i++) { nmod_poly_set_coeff_ui(value, i, rep(a[i])); } }
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); }
int main(void) { int i, result; ulong j; FLINT_TEST_INIT(state); flint_printf("get/set_coeff_ui...."); fflush(stdout); /* Check aliasing of a and b */ for (i = 0; i < 1000 * flint_test_multiplier(); i++) { nmod_poly_t a; mp_limb_t n = n_randtest_not_zero(state); mp_limb_t c1 = n_randtest(state), c2; j = n_randint(state, 100); nmod_poly_init(a, n); nmod_poly_randtest(a, state, n_randint(state, 100)); nmod_poly_set_coeff_ui(a, j, c1); c2 = nmod_poly_get_coeff_ui(a, j); result = (c2 == c1 % n); if (!result) { flint_printf("FAIL:\n"); flint_printf("j = %wu, c1 = %wu, c2 = %wu, n = %wu\n", j, c1, c2, a->mod.n); nmod_poly_print(a), flint_printf("\n\n"); abort(); } nmod_poly_clear(a); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
void nmod_poly_compose_divconquer(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2) { const long len1 = poly1->length; const long len2 = poly2->length; long lenr; if (len1 == 0) { nmod_poly_zero(res); return; } if (len1 == 1 || len2 == 0) { nmod_poly_set_coeff_ui(res, 0, poly1->coeffs[0]); nmod_poly_truncate(res, 1); return; } lenr = (len1 - 1) * (len2 - 1) + 1; if (res != poly1 && res != poly2) { nmod_poly_fit_length(res, lenr); _nmod_poly_compose_divconquer(res->coeffs, poly1->coeffs, len1, poly2->coeffs, len2, poly1->mod); } else { nmod_poly_t t; nmod_poly_init2(t, poly1->mod.n, lenr); _nmod_poly_compose_divconquer(t->coeffs, poly1->coeffs, len1, poly2->coeffs, len2, poly1->mod); nmod_poly_swap(res, t); nmod_poly_clear(t); } res->length = lenr; _nmod_poly_normalise(res); }
void embeddings_isomorphism(nmod_poly_t G, mp_srcptr F, const embeddings_t FP, const embeddings_t FQ, const embeddings_t FR){ long m = nmod_poly_degree(FP->P); long n = nmod_poly_degree(FQ->P); long i; nmod_poly_t tmpF, tmpG, S, X; nmod_t mod = FP->P->mod; nmod_poly_init(tmpF, mod.n); nmod_poly_init(tmpG, mod.n); nmod_poly_init(S, mod.n); nmod_poly_init(X, mod.n); nmod_poly_zero(G); nmod_poly_zero(X); nmod_poly_set_coeff_ui(X, 1, 1); embeddings_embed(S, X, FP, FQ, FR); for (i = m-1; i >= 0; i--){ nmod_poly_fit_length(tmpF, n); long j; long offset = i*n; for (j = 0; j < n; j++) tmpF->coeffs[j] = F[offset+j]; tmpF->length = n; _nmod_poly_normalise(tmpF); embeddings_embed(tmpG, tmpF, FQ, FP, FR); nmod_poly_mulmod(G, G, S, FR->P); nmod_poly_add(G, G, tmpG); } nmod_poly_clear(tmpF); nmod_poly_clear(tmpG); nmod_poly_clear(X); nmod_poly_clear(S); }
int main (void) { double t; nmod_poly_t f, g, h; for (int i= 15001;i < 16000; i++) { nmod_poly_init2 (f, 17, i/2+1); nmod_poly_init2 (g, 17, i+1); nmod_poly_set_coeff_ui (f, i/2, 1); nmod_poly_set_coeff_ui (f, 1, 1); nmod_poly_set_coeff_ui (f, 0, ((i%17)*(i%17)+3) % 17); nmod_poly_set_coeff_ui (g, i, 1); nmod_poly_set_coeff_ui (g, i/2+1, 1); nmod_poly_set_coeff_ui (g, 1, ((i % 17)+1)%17); nmod_poly_set_coeff_ui (g, 0, 15); nmod_poly_init (h, 17); nmod_poly_gcd (h, f, g); if (!nmod_poly_is_one (h)) { flint_printf ("i= %d\n", i); nmod_poly_factor_t factors; nmod_poly_factor_init (factors); t= clock(); nmod_poly_factor (factors, h); t = (clock() - t) / CLOCKS_PER_SEC; flint_printf("factorization %.2lf\n", t); nmod_poly_factor_clear (factors); } nmod_poly_clear (f); nmod_poly_clear (g); nmod_poly_clear (h); } return EXIT_SUCCESS; }
void ARingGFFlint::fromSmallIntegerCoefficients(ElementType& result, const std::vector<long>& poly) const { fq_nmod_t f; fq_nmod_init(f, mBigContext); #if 0 printf("input = "); for (long i=0; i<poly.size(); i++) printf("%ld ", poly[i]); printf("\n"); #endif for (long i=poly.size()-1; i>=0; i--) { long a = poly[i]; if (a == 0) continue; if (a < 0) a += characteristic(); nmod_poly_set_coeff_ui(f, i, a); } #if 0 printf(" result before reduction = "); fq_nmod_print_pretty(f, mBigContext); printf("\n"); #endif fq_nmod_reduce(f, mBigContext); #if 0 printf(" result = "); fq_nmod_print_pretty(f, mBigContext); printf("\n"); #endif fq_zech_set_fq_nmod(&result, f, mContext); #if 0 printf(" zech result = %lu", result.value); printf("\n"); #endif fq_nmod_clear(f, mBigContext); }
int main() { flint_rand_t state; slong nmax, n, bound, count; mp_limb_t p, pinv, m1, m2; nmod_poly_t A; flint_printf("rev...."); fflush(stdout); flint_randinit(state); bound = 100000; p = n_nextprime(UWORD(1) << (FLINT_BITS - 1), 0); pinv = n_preinvert_limb(p); nmod_poly_init(A, p); nmod_poly_set_coeff_ui(A, 1, 1); nmod_poly_exp_series(A, A, bound); nmod_poly_shift_right(A, A, 1); nmod_poly_inv_series(A, A, bound); m1 = 1; for (n = 0; n < A->length; n++) { A->coeffs[n] = n_mulmod2_preinv(A->coeffs[n], m1, p, pinv); m1 = n_mulmod2_preinv(m1, n + 1, p, pinv); } for (nmax = 0; nmax < bound; nmax = 1.5 * nmax + 2) { fmpz_t numer, denom; bernoulli_rev_t iter; fmpz_init(numer); fmpz_init(denom); nmax += (nmax % 2); bernoulli_rev_init(iter, nmax); if (nmax < 8000) count = 4000; else count = 100; /* flint_printf("nmax = %wd, count = %wd\n", nmax, count); */ for (n = nmax; n >= 0 && count > 0; n -= 2, count--) { bernoulli_rev_next(numer, denom, iter); m1 = fmpz_fdiv_ui(numer, p); m2 = fmpz_fdiv_ui(denom, p); m2 = n_invmod(m2, p); m1 = n_mulmod2_preinv(m1, m2, p, pinv); m2 = nmod_poly_get_coeff_ui(A, n); if (m1 != m2) { flint_printf("FAIL:\n"); flint_printf("nmax = %wd, n = %wd\n", nmax, n); flint_printf("m1 = %wu mod %wu\n", m1, p); flint_printf("m2 = %wu mod %wu\n", m2, p); abort(); } } bernoulli_rev_clear(iter); fmpz_clear(numer); fmpz_clear(denom); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
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; }
void nmod_poly_factor_squarefree(nmod_poly_factor_t res, const nmod_poly_t f) { nmod_poly_t f_d, g, g_1; mp_limb_t p; slong deg, i; if (f->length <= 1) { res->num = 0; return; } if (f->length == 2) { nmod_poly_factor_insert(res, f, 1); return; } p = nmod_poly_modulus(f); deg = nmod_poly_degree(f); /* Step 1, look at f', if it is zero then we are done since f = h(x)^p for some particular h(x), clearly f(x) = sum a_k x^kp, k <= deg(f) */ nmod_poly_init(g_1, p); nmod_poly_init(f_d, p); nmod_poly_init(g, p); nmod_poly_derivative(f_d, f); /* Case 1 */ if (nmod_poly_is_zero(f_d)) { nmod_poly_factor_t new_res; nmod_poly_t h; nmod_poly_init(h, p); for (i = 0; i <= deg / p; i++) /* this will be an integer since f'=0 */ { nmod_poly_set_coeff_ui(h, i, nmod_poly_get_coeff_ui(f, i * p)); } /* Now run square-free on h, and return it to the pth power */ nmod_poly_factor_init(new_res); nmod_poly_factor_squarefree(new_res, h); nmod_poly_factor_pow(new_res, p); nmod_poly_factor_concat(res, new_res); nmod_poly_clear(h); nmod_poly_factor_clear(new_res); } else { nmod_poly_t h, z; nmod_poly_gcd(g, f, f_d); nmod_poly_div(g_1, f, g); i = 1; nmod_poly_init(h, p); nmod_poly_init(z, p); /* Case 2 */ while (!nmod_poly_is_one(g_1)) { nmod_poly_gcd(h, g_1, g); nmod_poly_div(z, g_1, h); /* out <- out.z */ if (z->length > 1) { nmod_poly_factor_insert(res, z, 1); nmod_poly_make_monic(res->p + (res->num - 1), res->p + (res->num - 1)); if (res->num) res->exp[res->num - 1] *= i; } i++; nmod_poly_set(g_1, h); nmod_poly_div(g, g, h); } nmod_poly_clear(h); nmod_poly_clear(z); nmod_poly_make_monic(g, g); if (!nmod_poly_is_one(g)) { /* so now we multiply res with square-free(g^1/p) ^ p */ nmod_poly_t g_p; /* g^(1/p) */ nmod_poly_factor_t new_res_2; nmod_poly_init(g_p, p); for (i = 0; i <= nmod_poly_degree(g) / p; i++) nmod_poly_set_coeff_ui(g_p, i, nmod_poly_get_coeff_ui(g, i*p)); nmod_poly_factor_init(new_res_2); /* square-free(g^(1/p)) */ nmod_poly_factor_squarefree(new_res_2, g_p); nmod_poly_factor_pow(new_res_2, p); nmod_poly_factor_concat(res, new_res_2); nmod_poly_clear(g_p); nmod_poly_factor_clear(new_res_2); } } nmod_poly_clear(g_1); nmod_poly_clear(f_d); nmod_poly_clear(g); }
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("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 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; }
void nmod_poly_xgcd_hgcd(nmod_poly_t G, nmod_poly_t S, nmod_poly_t T, const nmod_poly_t A, const nmod_poly_t B) { if (A->length < B->length) { nmod_poly_xgcd_hgcd(G, T, S, B, A); } else /* lenA >= lenB >= 0 */ { const slong lenA = A->length, lenB = B->length; mp_limb_t inv; if (lenA == 0) /* lenA = lenB = 0 */ { nmod_poly_zero(G); nmod_poly_zero(S); nmod_poly_zero(T); } else if (lenB == 0) /* lenA > lenB = 0 */ { inv = n_invmod(A->coeffs[lenA - 1], A->mod.n); nmod_poly_scalar_mul_nmod(G, A, inv); nmod_poly_zero(T); nmod_poly_set_coeff_ui(S, 0, inv); S->length = 1; } else if (lenB == 1) /* lenA >= lenB = 1 */ { nmod_poly_fit_length(T, 1); T->length = 1; T->coeffs[0] = n_invmod(B->coeffs[0], A->mod.n); nmod_poly_one(G); nmod_poly_zero(S); } else /* lenA >= lenB >= 2 */ { mp_ptr g, s, t; slong lenG; if (G == A || G == B) { g = _nmod_vec_init(FLINT_MIN(lenA, lenB)); } else { nmod_poly_fit_length(G, FLINT_MIN(lenA, lenB)); g = G->coeffs; } if (S == A || S == B) { s = _nmod_vec_init(FLINT_MAX(lenB - 1, 2)); } else { nmod_poly_fit_length(S, FLINT_MAX(lenB - 1, 2)); s = S->coeffs; } if (T == A || T == B) { t = _nmod_vec_init(FLINT_MAX(lenA - 1, 2)); } else { nmod_poly_fit_length(T, FLINT_MAX(lenA - 1, 2)); t = T->coeffs; } if (lenA >= lenB) lenG = _nmod_poly_xgcd_hgcd(g, s, t, A->coeffs, lenA, B->coeffs, lenB, A->mod); else lenG = _nmod_poly_xgcd_hgcd(g, t, s, B->coeffs, lenB, A->coeffs, lenA, A->mod); if (G == A || G == B) { flint_free(G->coeffs); G->coeffs = g; G->alloc = FLINT_MIN(lenA, lenB); } if (S == A || S == B) { flint_free(S->coeffs); S->coeffs = s; S->alloc = FLINT_MAX(lenB - 1, 2); } if (T == A || T == B) { flint_free(T->coeffs); T->coeffs = t; T->alloc = FLINT_MAX(lenA - 1, 2); } G->length = lenG; S->length = FLINT_MAX(lenB - lenG, 1); T->length = FLINT_MAX(lenA - lenG, 1); MPN_NORM(S->coeffs, S->length); MPN_NORM(T->coeffs, T->length); if (G->coeffs[lenG - 1] != 1) { inv = n_invmod(G->coeffs[lenG - 1], A->mod.n); nmod_poly_scalar_mul_nmod(G, G, inv); nmod_poly_scalar_mul_nmod(S, S, inv); nmod_poly_scalar_mul_nmod(T, T, inv); } } } }
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; 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; }
void nmod_poly_xgcd(nmod_poly_t G, nmod_poly_t S, nmod_poly_t T, const nmod_poly_t A, const nmod_poly_t B) { const long lenA = A->length, lenB = B->length; mp_limb_t inv; if (lenA == 0) { if (lenB == 0) { nmod_poly_zero(G); nmod_poly_zero(S); nmod_poly_zero(T); } else { inv = n_invmod(B->coeffs[lenB - 1], B->mod.n); nmod_poly_scalar_mul_nmod(G, B, inv); nmod_poly_zero(S); nmod_poly_set_coeff_ui(T, 0, inv); T->length = 1; } } else if (lenB == 0) { inv = n_invmod(A->coeffs[lenA - 1], A->mod.n); nmod_poly_scalar_mul_nmod(G, A, inv); nmod_poly_zero(T); nmod_poly_set_coeff_ui(S, 0, inv); S->length = 1; } else { nmod_poly_t tG, tS, tT; mp_ptr g, s, t; long lenG; if (G == A || G == B) { nmod_poly_init2(tG, A->mod.n, FLINT_MIN(lenA, lenB)); g = tG->coeffs; } else { nmod_poly_fit_length(G, FLINT_MIN(lenA, lenB)); g = G->coeffs; } if (S == A || S == B) { nmod_poly_init2(tS, A->mod.n, lenB - 1); s = tS->coeffs; } else { nmod_poly_fit_length(S, lenB - 1); s = S->coeffs; } if (T == A || T == B) { nmod_poly_init2(tT, A->mod.n, lenA - 1); t = tT->coeffs; } else { nmod_poly_fit_length(T, lenA - 1); t = T->coeffs; } if (lenA >= lenB) lenG = _nmod_poly_xgcd(g, s, t, A->coeffs, lenA, B->coeffs, lenB, A->mod); else lenG = _nmod_poly_xgcd(g, t, s, B->coeffs, lenB, A->coeffs, lenA, A->mod); if (G == A || G == B) { nmod_poly_swap(tG, G); nmod_poly_clear(tG); } if (S == A || S == B) { nmod_poly_swap(tS, S); nmod_poly_clear(tS); } if (T == A || T == B) { nmod_poly_swap(tT, T); nmod_poly_clear(tT); } G->length = lenG; S->length = lenB - lenG; T->length = lenA - lenG; MPN_NORM(S->coeffs, S->length); MPN_NORM(T->coeffs, T->length); if (G->coeffs[lenG - 1] != 1) { inv = n_invmod(G->coeffs[lenG - 1], A->mod.n); nmod_poly_scalar_mul_nmod(G, G, inv); nmod_poly_scalar_mul_nmod(S, S, inv); nmod_poly_scalar_mul_nmod(T, T, inv); } } }
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 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; }
void embeddings_isomorphism_2(nmod_poly_t G, mp_srcptr F, const embeddings_t FP, const embeddings_t FQ, const embeddings_t FR){ nmod_t mod = G->mod; long m = nmod_poly_degree(FP->P); long n = nmod_poly_degree(FQ->P); long np = n + m - 1; long p = ceil(sqrt(np)); long q = ceil((1.0*np)/p); long i, j, k; nmod_poly_t iT, iTm, T, X, tmp; nmod_poly_struct *TT; nmod_poly_init(iTm, mod.n); nmod_poly_init(iT, mod.n); nmod_poly_init(T, mod.n); nmod_poly_init(X, mod.n); nmod_poly_init(tmp, mod.n); nmod_poly_mat_t MT, MH, MV; nmod_poly_mat_init(MT, q, n, mod.n); nmod_poly_mat_init(MH, p, q, mod.n); nmod_poly_mat_init(MV, p, n, mod.n); TT = flint_malloc(sizeof(nmod_poly_struct) * (q+1)); for (i = 0; i < q+1; i++) nmod_poly_init(TT+i, mod.n); nmod_poly_set_coeff_ui(X, 1, 1); embeddings_embed(T, X, FQ, FP, FR); nmod_poly_invmod(iT, T, FR->P); nmod_poly_powmod_ui_binexp(iTm, iT, m-1, FR->P); nmod_poly_zero(TT); nmod_poly_set_coeff_ui(TT, 0, 1); for (i = 1; i < q+1; i++) nmod_poly_mulmod(TT+i, TT+(i-1), T, FR->P); for (i = 0; i < q; i++) for (j = 0; j < n; j++){ long jm = j*m; for (k = 0; k < m; k++) nmod_poly_set_coeff_ui(nmod_poly_mat_entry(MT, i, j), k, nmod_poly_get_coeff_ui(TT+i, k+jm)); } for (i = 0; i < p; i++) for (j = 0; j < q; j++){ long idx = i*q+j; long lo = FLINT_MAX(0,m-1-idx); long hi = FLINT_MIN(m,n+m-1-idx); for (k = lo; k < hi; k++) nmod_poly_set_coeff_ui(nmod_poly_mat_entry(MH, i, j), k, F[k*n+k+idx-m+1]); } nmod_poly_mat_mul(MV, MH, MT); nmod_poly_zero(G); for (i = p-1; i >= 0; i--){ nmod_poly_zero(tmp); for (j = 0; j < n; j++){ long len = nmod_poly_mat_entry(MV, i, j)->length; mp_ptr coefs = nmod_poly_mat_entry(MV, i, j)->coeffs; long jm = j*m; for (k = 0; k < len; k++) nmod_poly_set_coeff_ui(tmp, k+jm, n_addmod(nmod_poly_get_coeff_ui(tmp, k+jm), coefs[k], mod.n)); } nmod_poly_rem(tmp, tmp, FR->P); nmod_poly_mulmod(G, G, TT+q, FR->P); nmod_poly_add(G, G, tmp); } nmod_poly_mulmod(G, G, iTm, FR->P); nmod_poly_clear(tmp); nmod_poly_mat_clear(MT); nmod_poly_mat_clear(MH); nmod_poly_mat_clear(MV); for (i = 0; i < q+1; i++) nmod_poly_clear(TT+i); flint_free(TT); nmod_poly_clear(iTm); nmod_poly_clear(iT); nmod_poly_clear(T); nmod_poly_clear(X); }