int main(void) { int i, result; FLINT_TEST_INIT(state); flint_printf("mul... "); fflush(stdout); /* Check aliasing: a = a * b */ for (i = 0; i < 2000; i++) { fmpz_t p; slong d, N; qadic_ctx_t ctx; qadic_t a, b, c; fmpz_init_set_ui(p, n_randprime(state, 2 + n_randint(state, 3), 1)); d = n_randint(state, 10) + 1; N = z_randint(state, 50) + 1; qadic_ctx_init_conway(ctx, p, d, FLINT_MAX(0,N-10), FLINT_MAX(0,N+10), "a", PADIC_SERIES); qadic_init2(a, N); qadic_init2(b, N); qadic_init2(c, N); qadic_randtest(a, state, ctx); qadic_randtest(b, state, ctx); qadic_mul(c, a, b, ctx); qadic_mul(a, a, b, ctx); result = (qadic_equal(a, c)); if (!result) { flint_printf("FAIL:\n\n"); flint_printf("a = "), qadic_print_pretty(a, ctx), flint_printf("\n"); flint_printf("b = "), qadic_print_pretty(b, ctx), flint_printf("\n"); flint_printf("c = "), qadic_print_pretty(c, ctx), flint_printf("\n"); abort(); } qadic_clear(a); qadic_clear(b); qadic_clear(c); fmpz_clear(p); qadic_ctx_clear(ctx); } /* Check aliasing: b = a * b */ for (i = 0; i < 2000; i++) { fmpz_t p; slong d, N; qadic_ctx_t ctx; qadic_t a, b, c; fmpz_init_set_ui(p, n_randprime(state, 2 + n_randint(state, 3), 1)); d = n_randint(state, 10) + 1; N = z_randint(state, 50) + 1; qadic_ctx_init_conway(ctx, p, d, FLINT_MAX(0, N-10), FLINT_MAX(0, N+10), "a", PADIC_SERIES); qadic_init2(a, N); qadic_init2(b, N); qadic_init2(c, N); qadic_randtest(a, state, ctx); qadic_randtest(b, state, ctx); qadic_mul(c, a, b, ctx); qadic_mul(b, a, b, ctx); result = (qadic_equal(b, c)); if (!result) { flint_printf("FAIL:\n\n"); flint_printf("a = "), qadic_print_pretty(a, ctx), flint_printf("\n"); flint_printf("b = "), qadic_print_pretty(b, ctx), flint_printf("\n"); flint_printf("c = "), qadic_print_pretty(c, ctx), flint_printf("\n"); abort(); } qadic_clear(a); qadic_clear(b); qadic_clear(c); fmpz_clear(p); qadic_ctx_clear(ctx); } /* Check aliasing: a = a + a */ for (i = 0; i < 2000; i++) { fmpz_t p; slong d, N; qadic_ctx_t ctx; qadic_t a, c; fmpz_init_set_ui(p, n_randprime(state, 2 + n_randint(state, 3), 1)); d = n_randint(state, 10) + 1; N = z_randint(state, 50) + 1; qadic_ctx_init_conway(ctx, p, d, FLINT_MAX(0,N-10), FLINT_MAX(0,N+10), "a", PADIC_SERIES); qadic_init2(a, N); qadic_init2(c, N); qadic_randtest(a, state, ctx); qadic_add(c, a, a, ctx); qadic_add(a, a, a, ctx); result = (qadic_equal(a, c)); if (!result) { flint_printf("FAIL:\n\n"); flint_printf("a = "), qadic_print_pretty(a, ctx), flint_printf("\n"); flint_printf("c = "), qadic_print_pretty(c, ctx), flint_printf("\n"); abort(); } qadic_clear(a); qadic_clear(c); fmpz_clear(p); qadic_ctx_clear(ctx); } /* Check that a * b == b * a */ for (i = 0; i < 2000; i++) { fmpz_t p; slong d, N; qadic_ctx_t ctx; qadic_t a, b, c1, c2; fmpz_init_set_ui(p, n_randprime(state, 2 + n_randint(state, 3), 1)); d = n_randint(state, 10) + 1; N = z_randint(state, 50) + 1; qadic_ctx_init_conway(ctx, p, d, FLINT_MAX(0,N-10), FLINT_MAX(0,N+10), "a", PADIC_SERIES); qadic_init2(a, N); qadic_init2(b, N); qadic_init2(c1, N); qadic_init2(c2, N); qadic_randtest(a, state, ctx); qadic_randtest(b, state, ctx); qadic_mul(c1, a, b, ctx); qadic_mul(c2, b, a, ctx); result = (qadic_equal(c1, c2)); if (!result) { flint_printf("FAIL:\n\n"); flint_printf("a = "), qadic_print_pretty(a, ctx), flint_printf("\n"); flint_printf("b = "), qadic_print_pretty(b, ctx), flint_printf("\n"); flint_printf("c1 = "), qadic_print_pretty(c1, ctx), flint_printf("\n"); flint_printf("c2 = "), qadic_print_pretty(c2, ctx), flint_printf("\n"); abort(); } qadic_clear(a); qadic_clear(b); qadic_clear(c1); qadic_clear(c2); fmpz_clear(p); qadic_ctx_clear(ctx); } /* Check that (a * b) * c == a * (b * c) for integral values */ for (i = 0; i < 2000; i++) { fmpz_t p; slong d, N; qadic_ctx_t ctx; qadic_t a, b, c, lhs, rhs; fmpz_init_set_ui(p, n_randprime(state, 2 + n_randint(state, 3), 1)); d = n_randint(state, 10) + 1; N = n_randint(state, 50) + 1; qadic_ctx_init_conway(ctx, p, d, FLINT_MAX(0,N-10), FLINT_MAX(0,N+10), "a", PADIC_SERIES); qadic_init2(a, N); qadic_init2(b, N); qadic_init2(c, N); qadic_init2(lhs, N); qadic_init2(rhs, N); qadic_randtest_int(a, state, ctx); qadic_randtest_int(b, state, ctx); qadic_randtest_int(c, state, ctx); qadic_mul(lhs, a, b, ctx); qadic_mul(lhs, lhs, c, ctx); qadic_mul(rhs, b, c, ctx); qadic_mul(rhs, a, rhs, ctx); result = (qadic_equal(lhs, rhs)); if (!result) { flint_printf("FAIL:\n\n"); flint_printf("a = "), qadic_print_pretty(a, ctx), flint_printf("\n"); flint_printf("b = "), qadic_print_pretty(b, ctx), flint_printf("\n"); flint_printf("c = "), qadic_print_pretty(c, ctx), flint_printf("\n"); flint_printf("lhs = "), qadic_print_pretty(lhs, ctx), flint_printf("\n"); flint_printf("rhs = "), qadic_print_pretty(rhs, ctx), flint_printf("\n"); abort(); } qadic_clear(a); qadic_clear(b); qadic_clear(c); qadic_clear(lhs); qadic_clear(rhs); fmpz_clear(p); qadic_ctx_clear(ctx); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { long iter; flint_rand_t state; printf("submul_fmpz...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000; iter++) { arb_t a, b, c, d; fmpz_t x; long prec; arb_init(a); arb_init(b); arb_init(c); arb_init(d); fmpz_init(x); arb_randtest_special(a, state, 1 + n_randint(state, 2000), 100); arb_randtest_special(b, state, 1 + n_randint(state, 2000), 100); arb_randtest_special(c, state, 1 + n_randint(state, 2000), 100); fmpz_randtest(x, state, 1 + n_randint(state, 2000)); prec = 2 + n_randint(state, 2000); arb_set_fmpz(b, x); arb_set(d, c); arb_submul_fmpz(c, a, x, prec); arb_submul(d, a, b, prec); if (!arb_equal(c, d)) { printf("FAIL\n\n"); printf("a = "); arb_print(a); printf("\n\n"); printf("b = "); arb_print(b); printf("\n\n"); printf("c = "); arb_print(c); printf("\n\n"); printf("d = "); arb_print(d); printf("\n\n"); abort(); } arb_clear(a); arb_clear(b); arb_clear(c); arb_clear(d); fmpz_clear(x); } /* aliasing */ for (iter = 0; iter < 10000; iter++) { arb_t a, b, c; fmpz_t x; long prec; arb_init(a); arb_init(b); arb_init(c); fmpz_init(x); arb_randtest_special(a, state, 1 + n_randint(state, 2000), 100); arb_randtest_special(b, state, 1 + n_randint(state, 2000), 100); arb_randtest_special(c, state, 1 + n_randint(state, 2000), 100); fmpz_randtest(x, state, 1 + n_randint(state, 2000)); prec = 2 + n_randint(state, 2000); arb_set_fmpz(b, x); arb_set(c, a); arb_submul_fmpz(c, a, x, prec); arb_submul_fmpz(a, a, x, prec); if (!arb_equal(a, c)) { printf("FAIL (aliasing)\n\n"); printf("a = "); arb_print(a); printf("\n\n"); printf("b = "); arb_print(b); printf("\n\n"); printf("c = "); arb_print(c); printf("\n\n"); abort(); } arb_clear(a); arb_clear(b); arb_clear(c); fmpz_clear(x); } flint_randclear(state); flint_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
int main(void) { char *str; /* String for the input polynomial P */ mpoly_t P; /* Input polynomial P */ long n; /* Number of variables minus one */ long K; /* Required t-adic precision */ long N, Nw; long i, b; mat_t M; ctx_t ctxM; mon_t *rows, *cols; padic_mat_struct *C; fmpz_t p; printf("valuations... \n"); fflush(stdout); /* Example 3-1-1 */ /* str = "3 [3 0 0] [0 3 0] [0 0 3] (2 0 1)[1 1 1]"; */ /* Example 4-4-2 */ /* str = "4 [4 0 0 0] [0 4 0 0] [0 0 4 0] [0 0 0 4] (2 0 1)[3 1 0 0] (2 0 1)[1 0 1 2] (2 0 1)[0 1 0 3]"; */ /* Example 3-3-6 */ /* str = "3 [3 0 0] [0 3 0] [0 0 3] (2 0 314)[2 1 0] (2 0 42)[0 2 1] (2 0 271)[1 0 2] (2 0 -23)[1 1 1]"; */ /* Example 3-3-2 */ /* str = "3 [3 0 0] [0 3 0] [0 0 3] (2 0 1)[2 1 0] (2 0 1)[0 2 1] (2 0 1)[1 0 2]"; */ /* Example ... */ /* str = "4 [4 0 0 0] [0 4 0 0] [0 0 4 0] [0 0 0 4] (2 0 1)[1 1 1 1]"; */ /* Cubic surface from AKR */ str = "4 (1 3)[0 3 0 0] (2 0 3)[0 1 2 0] " "(2 0 -1)[1 1 1 0] (2 0 3)[1 1 0 1] " "(2 0 -1)[2 1 0 0] [0 0 3 0] (2 0 -1)[1 0 2 0] " "(1 2)[0 0 0 3] [3 0 0 0]"; n = atoi(str) - 1; N = 10; Nw = 22; K = 616; ctx_init_fmpz_poly_q(ctxM); mpoly_init(P, n + 1, ctxM); mpoly_set_str(P, str, ctxM); printf("P = "), mpoly_print(P, ctxM), printf("\n"); b = gmc_basis_size(n, mpoly_degree(P, -1, ctxM)); mat_init(M, b, b, ctxM); gmc_compute(M, &rows, &cols, P, ctxM); mat_print(M, ctxM); printf("\n"); fmpz_init(p); fmpz_set_ui(p, 5); gmde_solve(&C, K, p, N, Nw, M, ctxM); printf("Valuations\n"); for (i = 0; i < K; i++) { long v = padic_mat_val(C + i); if (v < LONG_MAX) printf(" i = %ld val = %ld val/log(i) = %f\n", i, v, (i > 1) ? (double) v / log(i) : 0); else printf(" i = %ld val = +infty\n", i); } fmpz_clear(p); mpoly_clear(P, ctxM); mat_clear(M, ctxM); for (i = 0; i < K; i++) padic_mat_clear(C + i); free(C); ctx_clear(ctxM); return EXIT_SUCCESS; }
void frob(const mpoly_t P, const ctx_t ctxFracQt, const qadic_t t1, const qadic_ctx_t Qq, prec_t *prec, const prec_t *prec_in, int verbose) { const padic_ctx_struct *Qp = &Qq->pctx; const fmpz *p = Qp->p; const long a = qadic_ctx_degree(Qq); const long n = P->n - 1; const long d = mpoly_degree(P, -1, ctxFracQt); const long b = gmc_basis_size(n, d); long i, j, k; /* Diagonal fibre */ padic_mat_t F0; /* Gauss--Manin Connection */ mat_t M; mon_t *bR, *bC; fmpz_poly_t r; /* Local solution */ fmpz_poly_mat_t C, Cinv; long vC, vCinv; /* Frobenius */ fmpz_poly_mat_t F; long vF; fmpz_poly_mat_t F1; long vF1; fmpz_poly_t cp; clock_t c0, c1; double c; if (verbose) { printf("Input:\n"); printf(" P = "), mpoly_print(P, ctxFracQt), printf("\n"); printf(" p = "), fmpz_print(p), printf("\n"); printf(" t1 = "), qadic_print_pretty(t1, Qq), printf("\n"); printf("\n"); fflush(stdout); } /* Step 1 {M, r} *********************************************************/ c0 = clock(); mat_init(M, b, b, ctxFracQt); fmpz_poly_init(r); gmc_compute(M, &bR, &bC, P, ctxFracQt); { fmpz_poly_t t; fmpz_poly_init(t); fmpz_poly_set_ui(r, 1); for (i = 0; i < M->m; i++) for (j = 0; j < M->n; j++) { fmpz_poly_lcm(t, r, fmpz_poly_q_denref( (fmpz_poly_q_struct *) mat_entry(M, i, j, ctxFracQt))); fmpz_poly_swap(r, t); } fmpz_poly_clear(t); } c1 = clock(); c = (double) (c1 - c0) / CLOCKS_PER_SEC; if (verbose) { printf("Gauss-Manin connection:\n"); printf(" r(t) = "), fmpz_poly_print_pretty(r, "t"), printf("\n"); printf(" Time = %f\n", c); printf("\n"); fflush(stdout); } { qadic_t t; qadic_init2(t, 1); fmpz_poly_evaluate_qadic(t, r, t1, Qq); if (qadic_is_zero(t)) { printf("Exception (deformation_frob).\n"); printf("The resultant r evaluates to zero (mod p) at t1.\n"); abort(); } qadic_clear(t); } /* Precisions ************************************************************/ if (prec_in != NULL) { *prec = *prec_in; } else { deformation_precisions(prec, p, a, n, d, fmpz_poly_degree(r)); } if (verbose) { printf("Precisions:\n"); printf(" N0 = %ld\n", prec->N0); printf(" N1 = %ld\n", prec->N1); printf(" N2 = %ld\n", prec->N2); printf(" N3 = %ld\n", prec->N3); printf(" N3i = %ld\n", prec->N3i); printf(" N3w = %ld\n", prec->N3w); printf(" N3iw = %ld\n", prec->N3iw); printf(" N4 = %ld\n", prec->N4); printf(" m = %ld\n", prec->m); printf(" K = %ld\n", prec->K); printf(" r = %ld\n", prec->r); printf(" s = %ld\n", prec->s); printf("\n"); fflush(stdout); } /* Initialisation ********************************************************/ padic_mat_init2(F0, b, b, prec->N4); fmpz_poly_mat_init(C, b, b); fmpz_poly_mat_init(Cinv, b, b); fmpz_poly_mat_init(F, b, b); vF = 0; fmpz_poly_mat_init(F1, b, b); vF1 = 0; fmpz_poly_init(cp); /* Step 2 {F0} ***********************************************************/ { padic_ctx_t pctx_F0; fmpz *t; padic_ctx_init(pctx_F0, p, FLINT_MIN(prec->N4 - 10, 0), prec->N4, PADIC_VAL_UNIT); t = _fmpz_vec_init(n + 1); c0 = clock(); mpoly_diagonal_fibre(t, P, ctxFracQt); diagfrob(F0, t, n, d, prec->N4, pctx_F0, 0); padic_mat_transpose(F0, F0); c1 = clock(); c = (double) (c1 - c0) / CLOCKS_PER_SEC; if (verbose) { printf("Diagonal fibre:\n"); printf(" P(0) = {"), _fmpz_vec_print(t, n + 1), printf("}\n"); printf(" Time = %f\n", c); printf("\n"); fflush(stdout); } _fmpz_vec_clear(t, n + 1); padic_ctx_clear(pctx_F0); } /* Step 3 {C, Cinv} ******************************************************/ /* Compute C as a matrix over Z_p[[t]]. A is the same but as a series of matrices over Z_p. Mt is the matrix -M^t, and Cinv is C^{-1}^t, the local solution of the differential equation replacing M by Mt. */ c0 = clock(); { const long K = prec->K; padic_mat_struct *A; gmde_solve(&A, K, p, prec->N3, prec->N3w, M, ctxFracQt); gmde_convert_soln(C, &vC, A, K, p); for(i = 0; i < K; i++) padic_mat_clear(A + i); free(A); } c1 = clock(); c = (double) (c1 - c0) / CLOCKS_PER_SEC; if (verbose) { printf("Local solution:\n"); printf(" Time for C = %f\n", c); fflush(stdout); } c0 = clock(); { const long K = (prec->K + (*p) - 1) / (*p); mat_t Mt; padic_mat_struct *Ainv; mat_init(Mt, b, b, ctxFracQt); mat_transpose(Mt, M, ctxFracQt); mat_neg(Mt, Mt, ctxFracQt); gmde_solve(&Ainv, K, p, prec->N3i, prec->N3iw, Mt, ctxFracQt); gmde_convert_soln(Cinv, &vCinv, Ainv, K, p); fmpz_poly_mat_transpose(Cinv, Cinv); fmpz_poly_mat_compose_pow(Cinv, Cinv, *p); for(i = 0; i < K; i++) padic_mat_clear(Ainv + i); free(Ainv); mat_clear(Mt, ctxFracQt); } c1 = clock(); c = (double) (c1 - c0) / CLOCKS_PER_SEC; if (verbose) { printf(" Time for C^{-1} = %f\n", c); printf("\n"); fflush(stdout); } /* Step 4 {F(t) := C(t) F(0) C(t^p)^{-1}} ********************************/ /* Computes the product C(t) F(0) C(t^p)^{-1} modulo (p^{N_2}, t^K). This is done by first computing the unit part of the product exactly over the integers modulo t^K. */ c0 = clock(); { fmpz_t pN; fmpz_poly_mat_t T; fmpz_init(pN); fmpz_poly_mat_init(T, b, b); for (i = 0; i < b; i++) { /* Find the unique k s.t. F0(i,k) is non-zero */ for (k = 0; k < b; k++) if (!fmpz_is_zero(padic_mat_entry(F0, i, k))) break; if (k == b) { printf("Exception (frob). F0 is singular.\n\n"); abort(); } for (j = 0; j < b; j++) { fmpz_poly_scalar_mul_fmpz(fmpz_poly_mat_entry(T, i, j), fmpz_poly_mat_entry(Cinv, k, j), padic_mat_entry(F0, i, k)); } } fmpz_poly_mat_mul(F, C, T); fmpz_poly_mat_truncate(F, prec->K); vF = vC + padic_mat_val(F0) + vCinv; /* Canonicalise (F, vF) */ { long v = fmpz_poly_mat_ord_p(F, p); if (v == LONG_MAX) { printf("ERROR (deformation_frob). F(t) == 0.\n"); abort(); } else if (v > 0) { fmpz_pow_ui(pN, p, v); fmpz_poly_mat_scalar_divexact_fmpz(F, F, pN); vF = vF + v; } } /* Reduce (F, vF) modulo p^{N2} */ fmpz_pow_ui(pN, p, prec->N2 - vF); fmpz_poly_mat_scalar_mod_fmpz(F, F, pN); fmpz_clear(pN); fmpz_poly_mat_clear(T); } c1 = clock(); c = (double) (c1 - c0) / CLOCKS_PER_SEC; if (verbose) { printf("Matrix for F(t):\n"); printf(" Time = %f\n", c); printf("\n"); fflush(stdout); } /* Step 5 {G = r(t)^m F(t)} **********************************************/ c0 = clock(); { fmpz_t pN; fmpz_poly_t t; fmpz_init(pN); fmpz_poly_init(t); fmpz_pow_ui(pN, p, prec->N2 - vF); /* Compute r(t)^m mod p^{N2-vF} */ if (prec->denR == NULL) { fmpz_mod_poly_t _t; fmpz_mod_poly_init(_t, pN); fmpz_mod_poly_set_fmpz_poly(_t, r); fmpz_mod_poly_pow(_t, _t, prec->m); fmpz_mod_poly_get_fmpz_poly(t, _t); fmpz_mod_poly_clear(_t); } else { /* TODO: We don't really need a copy */ fmpz_poly_set(t, prec->denR); } fmpz_poly_mat_scalar_mul_fmpz_poly(F, F, t); fmpz_poly_mat_scalar_mod_fmpz(F, F, pN); /* TODO: This should not be necessary? */ fmpz_poly_mat_truncate(F, prec->K); fmpz_clear(pN); fmpz_poly_clear(t); } c1 = clock(); c = (double) (c1 - c0) / CLOCKS_PER_SEC; if (verbose) { printf("Analytic continuation:\n"); printf(" Time = %f\n", c); printf("\n"); fflush(stdout); } /* Steps 6 and 7 *********************************************************/ if (a == 1) { /* Step 6 {F(1) = r(t_1)^{-m} G(t_1)} ********************************/ c0 = clock(); { const long N = prec->N2 - vF; fmpz_t f, g, t, pN; fmpz_init(f); fmpz_init(g); fmpz_init(t); fmpz_init(pN); fmpz_pow_ui(pN, p, N); /* f := \hat{t_1}, g := r(\hat{t_1})^{-m} */ _padic_teichmuller(f, t1->coeffs + 0, p, N); if (prec->denR == NULL) { _fmpz_mod_poly_evaluate_fmpz(g, r->coeffs, r->length, f, pN); fmpz_powm_ui(t, g, prec->m, pN); } else { _fmpz_mod_poly_evaluate_fmpz(t, prec->denR->coeffs, prec->denR->length, f, pN); } _padic_inv(g, t, p, N); /* F1 := g G(\hat{t_1}) */ for (i = 0; i < b; i++) for (j = 0; j < b; j++) { const fmpz_poly_struct *poly = fmpz_poly_mat_entry(F, i, j); const long len = poly->length; if (len == 0) { fmpz_poly_zero(fmpz_poly_mat_entry(F1, i, j)); } else { fmpz_poly_fit_length(fmpz_poly_mat_entry(F1, i, j), 1); _fmpz_mod_poly_evaluate_fmpz(t, poly->coeffs, len, f, pN); fmpz_mul(fmpz_poly_mat_entry(F1, i, j)->coeffs + 0, g, t); fmpz_mod(fmpz_poly_mat_entry(F1, i, j)->coeffs + 0, fmpz_poly_mat_entry(F1, i, j)->coeffs + 0, pN); _fmpz_poly_set_length(fmpz_poly_mat_entry(F1, i, j), 1); _fmpz_poly_normalise(fmpz_poly_mat_entry(F1, i, j)); } } vF1 = vF; fmpz_poly_mat_canonicalise(F1, &vF1, p); fmpz_clear(f); fmpz_clear(g); fmpz_clear(t); fmpz_clear(pN); } c1 = clock(); c = (double) (c1 - c0) / CLOCKS_PER_SEC; if (verbose) { printf("Evaluation:\n"); printf(" Time = %f\n", c); printf("\n"); fflush(stdout); } } else { /* Step 6 {F(1) = r(t_1)^{-m} G(t_1)} ********************************/ c0 = clock(); { const long N = prec->N2 - vF; fmpz_t pN; fmpz *f, *g, *t; fmpz_init(pN); f = _fmpz_vec_init(a); g = _fmpz_vec_init(2 * a - 1); t = _fmpz_vec_init(2 * a - 1); fmpz_pow_ui(pN, p, N); /* f := \hat{t_1}, g := r(\hat{t_1})^{-m} */ _qadic_teichmuller(f, t1->coeffs, t1->length, Qq->a, Qq->j, Qq->len, p, N); if (prec->denR == NULL) { fmpz_t e; fmpz_init_set_ui(e, prec->m); _fmpz_mod_poly_compose_smod(g, r->coeffs, r->length, f, a, Qq->a, Qq->j, Qq->len, pN); _qadic_pow(t, g, a, e, Qq->a, Qq->j, Qq->len, pN); fmpz_clear(e); } else { _fmpz_mod_poly_reduce(prec->denR->coeffs, prec->denR->length, Qq->a, Qq->j, Qq->len, pN); _fmpz_poly_normalise(prec->denR); _fmpz_mod_poly_compose_smod(t, prec->denR->coeffs, prec->denR->length, f, a, Qq->a, Qq->j, Qq->len, pN); } _qadic_inv(g, t, a, Qq->a, Qq->j, Qq->len, p, N); /* F1 := g G(\hat{t_1}) */ for (i = 0; i < b; i++) for (j = 0; j < b; j++) { const fmpz_poly_struct *poly = fmpz_poly_mat_entry(F, i, j); const long len = poly->length; fmpz_poly_struct *poly2 = fmpz_poly_mat_entry(F1, i, j); if (len == 0) { fmpz_poly_zero(poly2); } else { _fmpz_mod_poly_compose_smod(t, poly->coeffs, len, f, a, Qq->a, Qq->j, Qq->len, pN); fmpz_poly_fit_length(poly2, 2 * a - 1); _fmpz_poly_mul(poly2->coeffs, g, a, t, a); _fmpz_mod_poly_reduce(poly2->coeffs, 2 * a - 1, Qq->a, Qq->j, Qq->len, pN); _fmpz_poly_set_length(poly2, a); _fmpz_poly_normalise(poly2); } } /* Now the matrix for p^{-1} F_p at t=t_1 is (F1, vF1). */ vF1 = vF; fmpz_poly_mat_canonicalise(F1, &vF1, p); fmpz_clear(pN); _fmpz_vec_clear(f, a); _fmpz_vec_clear(g, 2 * a - 1); _fmpz_vec_clear(t, 2 * a - 1); } c1 = clock(); c = (double) (c1 - c0) / CLOCKS_PER_SEC; if (verbose) { printf("Evaluation:\n"); printf(" Time = %f\n", c); printf("\n"); fflush(stdout); } /* Step 7 {Norm} *****************************************************/ /* Computes the matrix for $q^{-1} F_q$ at $t = t_1$ as the product $F \sigma(F) \dotsm \sigma^{a-1}(F)$ up appropriate transpositions because our convention of columns vs rows is the opposite of that used by Gerkmann. Note that, in any case, transpositions do not affect the characteristic polynomial. */ c0 = clock(); { const long N = prec->N1 - a * vF1; fmpz_t pN; fmpz_poly_mat_t T; fmpz_init(pN); fmpz_poly_mat_init(T, b, b); fmpz_pow_ui(pN, p, N); fmpz_poly_mat_frobenius(T, F1, 1, p, N, Qq); _qadic_mat_mul(F1, F1, T, pN, Qq); for (i = 2; i < a; i++) { fmpz_poly_mat_frobenius(T, T, 1, p, N, Qq); _qadic_mat_mul(F1, F1, T, pN, Qq); } vF1 = a * vF1; fmpz_poly_mat_canonicalise(F1, &vF1, p); fmpz_clear(pN); fmpz_poly_mat_clear(T); } c1 = clock(); c = (double) (c1 - c0) / CLOCKS_PER_SEC; if (verbose) { printf("Norm:\n"); printf(" Time = %f\n", c); printf("\n"); fflush(stdout); } } /* Step 8 {Reverse characteristic polynomial} ****************************/ c0 = clock(); deformation_revcharpoly(cp, F1, vF1, n, d, prec->N0, prec->r, prec->s, Qq); c1 = clock(); c = (double) (c1 - c0) / CLOCKS_PER_SEC; if (verbose) { printf("Reverse characteristic polynomial:\n"); printf(" p(T) = "), fmpz_poly_print_pretty(cp, "T"), printf("\n"); printf(" Time = %f\n", c); printf("\n"); fflush(stdout); } /* Clean up **************************************************************/ padic_mat_clear(F0); mat_clear(M, ctxFracQt); free(bR); free(bC); fmpz_poly_clear(r); fmpz_poly_mat_clear(C); fmpz_poly_mat_clear(Cinv); fmpz_poly_mat_clear(F); fmpz_poly_mat_clear(F1); fmpz_poly_clear(cp); }
int main(void) { int i, result; FLINT_TEST_INIT(state); flint_printf("resultant_div...."); fflush(stdout); for (i = 0; i < 50; i++) { fmpq_poly_t f, g, h, p; fmpq_t x, y, z, zz; fmpz_t den; slong nbits; fmpq_poly_init(f); fmpq_poly_init(g); fmpq_poly_init(p); fmpq_poly_init(h); fmpq_init(x); fmpq_init(y); fmpq_init(z); fmpq_init(zz); fmpz_init(den); fmpq_poly_randtest(f, state, n_randint(state, 50), 100); fmpq_poly_randtest(g, state, n_randint(state, 50), 100); fmpq_poly_randtest(h, state, n_randint(state, 50), 100); fmpz_set(den, fmpq_poly_denref(f)); fmpq_poly_scalar_mul_fmpz(f, f, den); fmpz_set(den, fmpq_poly_denref(g)); fmpq_poly_scalar_mul_fmpz(g, g, den); fmpz_set(den, fmpq_poly_denref(h)); fmpq_poly_scalar_mul_fmpz(h, h, den); fmpq_poly_mul(p, f, g); fmpq_poly_resultant(x, f, h); if (!fmpz_is_one(fmpq_denref(x))) { flint_printf("FAIL resultant not integral\n"); flint_printf("f = "), fmpq_poly_print(f), flint_printf("\n\n"); flint_printf("g = "), fmpq_poly_print(g), flint_printf("\n\n"); flint_printf("y = "), fmpq_print(y), flint_printf("\n\n"); abort(); } fmpq_poly_resultant(y, g, h); if (!fmpz_is_one(fmpq_denref(y))) { flint_printf("FAIL resultant not integral\n"); flint_printf("h = "), fmpq_poly_print(f), flint_printf("\n\n"); flint_printf("g = "), fmpq_poly_print(g), flint_printf("\n\n"); flint_printf("z = "), fmpq_print(y), flint_printf("\n\n"); abort(); } fmpq_poly_resultant(z, p, h); if (!fmpz_is_one(fmpq_denref(z))) { flint_printf("FAIL resultant not integral\n"); flint_printf("p = "), fmpq_poly_print(f), flint_printf("\n\n"); flint_printf("g = "), fmpq_poly_print(g), flint_printf("\n\n"); flint_printf("y = "), fmpq_print(y), flint_printf("\n\n"); abort(); } if (fmpq_is_zero(z)) { fmpq_poly_clear(f); fmpq_poly_clear(g); fmpq_poly_clear(h); fmpq_poly_clear(p); fmpq_clear(x); fmpq_clear(y); fmpq_clear(z); fmpq_clear(zz); fmpz_clear(den); continue; } nbits = (slong)fmpz_bits(fmpq_numref(y)) + 1; fmpq_poly_resultant_div(z, p, h, fmpq_numref(x), nbits); fmpq_poly_resultant(zz, p, h); result = fmpq_equal(z, y); if (!result) { flint_printf("FAIL (res(p, g)/div == res(p, g)/div:\n"); flint_printf("p = "), fmpq_poly_print_pretty(p, "x"), flint_printf("\n\n"); flint_printf("h = "), fmpq_poly_print_pretty(h, "x"), flint_printf("\n\n"); flint_printf("res(p, h) = "), fmpq_print(zz), flint_printf("\n\n"); flint_printf("res(p, h) = "), fmpq_print(x), flint_printf(" * "), fmpq_print(y), flint_printf("\n\n"); flint_printf("supplied divisor = "), fmpq_print(x), flint_printf("\n\n"); flint_printf("nbits = %wu\n\n", nbits); flint_printf("divisor found = "), fmpq_print(z), flint_printf("\n\n"); flint_printf("correct result = "), fmpq_print(y), flint_printf("\n\n"); abort(); } fmpq_poly_clear(f); fmpq_poly_clear(g); fmpq_poly_clear(h); fmpq_poly_clear(p); fmpq_clear(x); fmpq_clear(y); fmpq_clear(z); fmpq_clear(zz); fmpz_clear(den); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int arf_root(arf_ptr z, arf_srcptr x, ulong k, slong prec, arf_rnd_t rnd) { mp_size_t xn, zn, val; mp_srcptr xptr; mp_ptr tmp, zptr; mpfr_t xf, zf; fmpz_t q, r; int inexact; if (k == 0) { arf_nan(z); return 0; } if (k == 1) return arf_set_round(z, x, prec, rnd); if (k == 2) return arf_sqrt(z, x, prec, rnd); if (arf_is_special(x)) { if (arf_is_neg_inf(x)) arf_nan(z); else arf_set(z, x); return 0; } if (ARF_SGNBIT(x)) { arf_nan(z); return 0; } fmpz_init(q); fmpz_init(r); /* x = m * 2^e where e = qk + r */ /* x^(1/k) = (m * 2^(qk+r))^(1/k) */ /* x^(1/k) = (m * 2^r)^(1/k) * 2^q */ fmpz_set_ui(r, k); fmpz_fdiv_qr(q, r, ARF_EXPREF(x), r); ARF_GET_MPN_READONLY(xptr, xn, x); zn = (prec + FLINT_BITS - 1) / FLINT_BITS; zf->_mpfr_d = tmp = flint_malloc(zn * sizeof(mp_limb_t)); zf->_mpfr_prec = prec; zf->_mpfr_sign = 1; zf->_mpfr_exp = 0; xf->_mpfr_d = (mp_ptr) xptr; xf->_mpfr_prec = xn * FLINT_BITS; xf->_mpfr_sign = 1; xf->_mpfr_exp = fmpz_get_ui(r); inexact = mpfr_root(zf, xf, k, arf_rnd_to_mpfr(rnd)); inexact = (inexact != 0); val = 0; while (tmp[val] == 0) val++; ARF_GET_MPN_WRITE(zptr, zn - val, z); flint_mpn_copyi(zptr, tmp + val, zn - val); fmpz_add_si(ARF_EXPREF(z), q, zf->_mpfr_exp); flint_free(tmp); fmpz_clear(q); fmpz_clear(r); return inexact; }
int main() { slong iter, iter2; flint_rand_t state; flint_printf("mul_fmpz...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { arf_t x, z, v; fmpz_t y; slong prec, r1, r2; arf_rnd_t rnd; arf_init(x); arf_init(z); arf_init(v); fmpz_init(y); for (iter2 = 0; iter2 < 100; iter2++) { arf_randtest_special(x, state, 2000, 10); fmpz_randtest(y, state, 2000); prec = 2 + n_randint(state, 2000); if (n_randint(state, 10)) prec = ARF_PREC_EXACT; switch (n_randint(state, 5)) { case 0: rnd = ARF_RND_DOWN; break; case 1: rnd = ARF_RND_UP; break; case 2: rnd = ARF_RND_FLOOR; break; case 3: rnd = ARF_RND_CEIL; break; default: rnd = ARF_RND_NEAR; break; } switch (n_randint(state, 2)) { case 0: r1 = arf_mul_fmpz(z, x, y, prec, rnd); r2 = arf_mul_fmpz_naive(v, x, y, prec, rnd); if (!arf_equal(z, v) || r1 != r2) { flint_printf("FAIL!\n"); flint_printf("prec = %wd, rnd = %d\n\n", prec, rnd); flint_printf("x = "); arf_print(x); flint_printf("\n\n"); flint_printf("y = "); fmpz_print(y); flint_printf("\n\n"); flint_printf("z = "); arf_print(z); flint_printf("\n\n"); flint_printf("v = "); arf_print(v); flint_printf("\n\n"); flint_printf("r1 = %wd, r2 = %wd\n", r1, r2); abort(); } break; default: r2 = arf_mul_fmpz_naive(v, x, y, prec, rnd); r1 = arf_mul_fmpz(x, x, y, prec, rnd); if (!arf_equal(x, v) || r1 != r2) { flint_printf("FAIL (aliasing)!\n"); flint_printf("prec = %wd, rnd = %d\n\n", prec, rnd); flint_printf("x = "); arf_print(x); flint_printf("\n\n"); flint_printf("y = "); fmpz_print(y); flint_printf("\n\n"); flint_printf("v = "); arf_print(v); flint_printf("\n\n"); flint_printf("r1 = %wd, r2 = %wd\n", r1, r2); abort(); } break; } } arf_clear(x); arf_clear(z); arf_clear(v); fmpz_clear(y); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main(void) { int i, result; padic_ctx_t ctx; fmpz_t p; slong N; FLINT_TEST_INIT(state); flint_printf("mul... "); fflush(stdout); /* Check aliasing of a and b */ for (i = 0; i < 1000; i++) { padic_poly_t a, b, c; fmpz_init_set_ui(p, n_randtest_prime(state, 0)); N = n_randint(state, PADIC_TEST_PREC_MAX - PADIC_TEST_PREC_MIN) + PADIC_TEST_PREC_MIN; padic_ctx_init(ctx, p, FLINT_MAX(0, N-10), FLINT_MAX(0, N+10), PADIC_SERIES); padic_poly_init2(a, 0, N); padic_poly_init2(b, 0, N); padic_poly_init2(c, 0, N); padic_poly_randtest(b, state, n_randint(state, 50), ctx); padic_poly_randtest(c, state, n_randint(state, 50), ctx); padic_poly_mul(a, b, c, ctx); padic_poly_mul(b, b, c, ctx); result = (padic_poly_equal(a, b) && padic_poly_is_reduced(a, ctx)); if (!result) { flint_printf("FAIL (aliasing a and b):\n"); padic_poly_print(a, ctx), flint_printf("\n\n"); padic_poly_print(b, ctx), flint_printf("\n\n"); abort(); } padic_poly_clear(a); padic_poly_clear(b); padic_poly_clear(c); padic_ctx_clear(ctx); fmpz_clear(p); } /* Check aliasing of a and c */ for (i = 0; i < 1000; i++) { padic_poly_t a, b, c; fmpz_init_set_ui(p, n_randtest_prime(state, 0)); N = n_randint(state, PADIC_TEST_PREC_MAX - PADIC_TEST_PREC_MIN) + PADIC_TEST_PREC_MIN; padic_ctx_init(ctx, p, FLINT_MAX(0, N-10), FLINT_MAX(0, N+10), PADIC_SERIES); padic_poly_init2(a, 0, N); padic_poly_init2(b, 0, N); padic_poly_init2(c, 0, N); padic_poly_randtest(b, state, n_randint(state, 50), ctx); padic_poly_randtest(c, state, n_randint(state, 50), ctx); padic_poly_mul(a, b, c, ctx); padic_poly_mul(c, b, c, ctx); result = (padic_poly_equal(a, c) && padic_poly_is_reduced(a, ctx)); if (!result) { flint_printf("FAIL (aliasing a and c):\n"); padic_poly_print(a, ctx), flint_printf("\n\n"); padic_poly_print(c, ctx), flint_printf("\n\n"); abort(); } padic_poly_clear(a); padic_poly_clear(b); padic_poly_clear(c); padic_ctx_clear(ctx); fmpz_clear(p); } /* Check (b * c) + (b * d) = b * (c + d) */ for (i = 0; i < 1000; i++) { padic_poly_t a1, a2, b, c, d, t; slong v; fmpz_init_set_ui(p, n_randtest_prime(state, 0)); N = n_randint(state, PADIC_TEST_PREC_MAX - PADIC_TEST_PREC_MIN) + PADIC_TEST_PREC_MIN; padic_ctx_init(ctx, p, FLINT_MAX(0, N-10), FLINT_MAX(0, N+10), PADIC_SERIES); padic_poly_init2(b, 0, N); padic_poly_init2(c, 0, N); padic_poly_init2(d, 0, N); padic_poly_init2(t, 0, N); padic_poly_randtest(b, state, n_randint(state, 100), ctx); padic_poly_randtest(c, state, n_randint(state, 100), ctx); padic_poly_randtest(d, state, n_randint(state, 100), ctx); v = FLINT_MIN(b->val, c->val); v = FLINT_MIN(v, d->val); v = FLINT_MIN(v, 0); if (v >= 0 || -v < N) /* Otherwise, no precision left */ { slong N2 = (v >= 0) ? N : N + v; padic_poly_init2(a1, 0, N2); padic_poly_init2(a2, 0, N2); padic_poly_mul(a1, b, c, ctx); padic_poly_mul(t, b, d, ctx); padic_poly_add(a1, a1, t, ctx); /* Lower precision */ padic_poly_add(t, c, d, ctx); padic_poly_mul(a2, b, t, ctx); /* Lower precision */ result = (padic_poly_equal(a1, a2) && padic_poly_is_reduced(a1, ctx)); if (!result) { flint_printf("FAIL (distributivity):\n"); flint_printf("p = "), fmpz_print(ctx->p), flint_printf("\n\n"); flint_printf("N = %wd\n\n", N); flint_printf("b = "), padic_poly_print(b, ctx), flint_printf("\n\n"); flint_printf("c = "), padic_poly_print(c, ctx), flint_printf("\n\n"); flint_printf("d = "), padic_poly_print(d, ctx), flint_printf("\n\n"); flint_printf("a1 = "), padic_poly_print(a1, ctx), flint_printf("\n\n"); flint_printf("a2 = "), padic_poly_print(a2, ctx), flint_printf("\n\n"); abort(); } padic_poly_clear(a1); padic_poly_clear(a2); } padic_poly_clear(b); padic_poly_clear(c); padic_poly_clear(d); padic_ctx_clear(ctx); fmpz_clear(p); } /* Compare with Q */ for (i = 0; i < 10000; i++) { padic_poly_t a, b, c, d; fmpq_poly_t x, y, z; fmpz_init_set_ui(p, n_randtest_prime(state, 0)); N = n_randint(state, PADIC_TEST_PREC_MAX - PADIC_TEST_PREC_MIN) + PADIC_TEST_PREC_MIN; padic_ctx_init(ctx, p, FLINT_MAX(0, N-10), FLINT_MAX(0, N+10), PADIC_SERIES); padic_poly_init2(a, 0, N); padic_poly_init2(b, 0, N); padic_poly_init2(c, 0, N); padic_poly_init2(d, 0, N); fmpq_poly_init(x); fmpq_poly_init(y); fmpq_poly_init(z); padic_poly_randtest(b, state, n_randint(state, 50), ctx); padic_poly_randtest(c, state, n_randint(state, 50), ctx); padic_poly_mul(a, b, c, ctx); padic_poly_get_fmpq_poly(y, b, ctx); padic_poly_get_fmpq_poly(z, c, ctx); fmpq_poly_mul(x, y, z); padic_poly_set_fmpq_poly(d, x, ctx); result = (padic_poly_equal(a, d) && padic_poly_is_reduced(a, ctx)); if (!result) { flint_printf("FAIL (cmp with Q):\n"); flint_printf("N = %wd, val(b) = %wd, val(c) = %wd\n", N, b->val, c->val); padic_poly_print(c, ctx), flint_printf("\n\n"); padic_poly_print(d, ctx), flint_printf("\n\n"); abort(); } padic_poly_clear(a); padic_poly_clear(b); padic_poly_clear(c); padic_poly_clear(d); fmpq_poly_clear(x); fmpq_poly_clear(y); fmpq_poly_clear(z); padic_ctx_clear(ctx); fmpz_clear(p); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return EXIT_SUCCESS; }
void gamma_rising_fmprb_ui_delta(fmprb_t y, const fmprb_t x, ulong n, ulong m, long prec) { fmprb_ptr xs; fmprb_t t, u, v; ulong i, k, rem; fmpz_t c, h; fmpz *s, *d; long wp; if (n == 0) { fmprb_one(y); return; } if (n == 1) { fmprb_set_round(y, x, prec); return; } wp = FMPR_PREC_ADD(prec, FLINT_BIT_COUNT(n)); fmprb_init(t); fmprb_init(u); fmprb_init(v); fmpz_init(c); fmpz_init(h); if (m == 0) { ulong m1, m2; m1 = 0.2 * pow(wp, 0.4); m2 = n_sqrt(n); m = FLINT_MIN(m1, m2); } m = FLINT_MIN(m, n); m = FLINT_MAX(m, 1); xs = _fmprb_vec_init(m + 1); d = _fmpz_vec_init(m * m); s = _fmpz_vec_init(m + 1); _fmprb_vec_set_powers(xs, x, m + 1, wp); rising_difference_polynomial(s, d, m); /* tail */ rem = m; while (rem + m <= n) rem += m; fmprb_one(y); for (k = rem; k < n; k++) { fmprb_add_ui(t, xs + 1, k, wp); fmprb_mul(y, y, t, wp); } /* initial rising factorial */ fmprb_zero(t); for (i = 1; i <= m; i++) fmprb_addmul_fmpz(t, xs + i, s + i, wp); fmprb_mul(y, y, t, wp); /* the leading coefficient is always the same */ fmprb_mul_fmpz(xs + m - 1, xs + m - 1, d + m - 1 + 0, wp); for (k = 0; k + 2 * m <= n; k += m) { for (i = 0; i < m - 1; i++) { fmpz_set_ui(h, k); _fmpz_poly_evaluate_horner_fmpz(c, d + i * m, m - i, h); if (i == 0) fmprb_add_fmpz(t, t, c, wp); else fmprb_addmul_fmpz(t, xs + i, c, wp); } fmprb_add(t, t, xs + m - 1, wp); fmprb_mul(y, y, t, wp); } fmprb_set_round(y, y, prec); fmprb_clear(t); fmprb_clear(u); fmprb_clear(v); _fmprb_vec_clear(xs, m + 1); _fmpz_vec_clear(d, m * m); _fmpz_vec_clear(s, m + 1); fmpz_clear(c); fmpz_clear(h); }
int _fmpz_mat_solve_cramer_3x3(fmpz_mat_t X, fmpz_t den, const fmpz_mat_t A, const fmpz_mat_t B) { fmpz_t t15, t16, t17; int success; fmpz_init(t15); fmpz_init(t16); fmpz_init(t17); fmpz_mul(t17, AA(1,0), AA(2,1)); fmpz_submul(t17, AA(1,1), AA(2,0)); fmpz_mul(t16, AA(1,2), AA(2,0)); fmpz_submul(t16, AA(1,0), AA(2,2)); fmpz_mul(t15, AA(1,1), AA(2,2)); fmpz_submul(t15, AA(1,2), AA(2,1)); fmpz_mul (den, t15, AA(0,0)); fmpz_addmul(den, t16, AA(0,1)); fmpz_addmul(den, t17, AA(0,2)); success = !fmpz_is_zero(den); if (success) { fmpz_t t12, t13, t14, x0, x1, x2; long i, n = fmpz_mat_ncols(B); fmpz_init(t12); fmpz_init(t13); fmpz_init(t14); fmpz_init(x0); fmpz_init(x1); fmpz_init(x2); for (i = 0; i < n; i++) { fmpz_mul(t14, AA(2,0), BB(1,i)); fmpz_submul(t14, AA(1,0), BB(2,i)); fmpz_mul(t13, AA(2,1), BB(1,i)); fmpz_submul(t13, AA(1,1), BB(2,i)); fmpz_mul(t12, AA(2,2), BB(1,i)); fmpz_submul(t12, AA(1,2), BB(2,i)); fmpz_mul (x0, t15, BB(0,i)); fmpz_addmul(x0, t13, AA(0,2)); fmpz_submul(x0, t12, AA(0,1)); fmpz_mul (x1, t16, BB(0,i)); fmpz_addmul(x1, t12, AA(0,0)); fmpz_submul(x1, t14, AA(0,2)); fmpz_mul (x2, t17, BB(0,i)); fmpz_addmul(x2, t14, AA(0,1)); fmpz_submul(x2, t13, AA(0,0)); fmpz_swap(XX(0,i), x0); fmpz_swap(XX(1,i), x1); fmpz_swap(XX(2,i), x2); } fmpz_clear(t12); fmpz_clear(t13); fmpz_clear(t14); fmpz_clear(x0); fmpz_clear(x1); fmpz_clear(x2); } fmpz_clear(t15); fmpz_clear(t16); fmpz_clear(t17); return success; }
int main(void) { int i, result; flint_rand_t state; printf("divexact_ui...."); fflush(stdout); flint_randinit(state); for (i = 0; i < 100000; i++) { fmpz_t a, c; mpz_t e, f, g; ulong n; fmpz_init(a); fmpz_init(c); mpz_init(e); mpz_init(f); mpz_init(g); fmpz_randtest(a, state, 200); n = n_randtest_not_zero(state); fmpz_mul_ui(c, a, n); fmpz_get_mpz(e, c); fmpz_divexact_ui(a, c, n); mpz_divexact_ui(f, e, n); fmpz_get_mpz(g, a); result = (mpz_cmp(f, g) == 0); if (!result) { printf("FAIL1\n"); gmp_printf("n = %lu, e = %Zd, f = %Zd, g = %Zd\n", n, e, f, g); abort(); } fmpz_clear(a); fmpz_clear(c); mpz_clear(e); mpz_clear(f); mpz_clear(g); } /* Test aliasing of a and c */ for (i = 0; i < 100000; i++) { fmpz_t a, c; mpz_t d, f, g; ulong n; fmpz_init(a); fmpz_init(c); mpz_init(d); mpz_init(f); mpz_init(g); fmpz_randtest(a, state, 200); n = n_randtest_not_zero(state); fmpz_mul_ui(c, a, n); fmpz_get_mpz(d, c); fmpz_divexact_ui(c, c, n); mpz_divexact_ui(f, d, n); fmpz_get_mpz(g, c); result = (mpz_cmp(f, g) == 0); if (!result) { printf("FAIL:\n"); gmp_printf("d = %Zd, n = %lu, f = %Zd, g = %Zd\n", d, n, f, g); abort(); } fmpz_clear(a); fmpz_clear(c); mpz_clear(d); mpz_clear(f); mpz_clear(g); } flint_randclear(state); _fmpz_cleanup(); printf("PASS\n"); return 0; }
void _fmpq_poly_divrem(fmpz * Q, fmpz_t q, fmpz * R, fmpz_t r, const fmpz * A, const fmpz_t a, slong lenA, const fmpz * B, const fmpz_t b, slong lenB, const fmpz_preinvn_t inv) { slong lenQ = lenA - lenB + 1; slong lenR = lenB - 1; ulong d; const fmpz * lead = B + (lenB - 1); if (lenB == 1) { _fmpq_poly_scalar_div_fmpq(Q, q, A, a, lenA, B, b); fmpz_one(r); return; } /* From pseudo division over Z we have lead^d * A = Q * B + R and thus {A, a} = {b * Q, a * lead^d} * {B, b} + {R, a * lead^d}. */ _fmpz_poly_pseudo_divrem(Q, R, &d, A, lenA, B, lenB, inv); /* Determine the actual length of R */ for ( ; lenR != 0 && fmpz_is_zero(R + (lenR - 1)); lenR--) ; /* 1. lead^d == +-1. {Q, q} = {b Q, a}, {R, r} = {R, a} up to sign */ if (d == UWORD(0) || *lead == WORD(1) || *lead == WORD(-1)) { fmpz_one(q); _fmpq_poly_scalar_mul_fmpz(Q, q, Q, q, lenQ, b); _fmpq_poly_scalar_div_fmpz(Q, q, Q, q, lenQ, a); fmpz_one(r); if (lenR > 0) _fmpq_poly_scalar_div_fmpz(R, r, R, r, lenR, a); if (*lead == WORD(-1) && d % UWORD(2)) { _fmpz_vec_neg(Q, Q, lenQ); _fmpz_vec_neg(R, R, lenR); } } /* 2. lead^d != +-1. {Q, q} = {b Q, a lead^d}, {R, r} = {R, a lead^d} */ else { /* TODO: Improve this. Clearly we do not need to compute den = a lead^d in many cases, but can determine the GCD from lead alone already. */ fmpz_t den; fmpz_init(den); fmpz_pow_ui(den, lead, d); fmpz_mul(den, a, den); fmpz_one(q); _fmpq_poly_scalar_mul_fmpz(Q, q, Q, q, lenQ, b); _fmpq_poly_scalar_div_fmpz(Q, q, Q, q, lenQ, den); fmpz_one(r); if (lenR > 0) _fmpq_poly_scalar_div_fmpz(R, r, R, r, lenR, den); fmpz_clear(den); } }
int main() { slong iter; flint_rand_t state; flint_printf("set_round_ui_2exp_fmpz...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 100000; iter++) { slong prec, ret1, ret2; fmpz_t man, exp; fmpr_t x, y; mp_limb_t lo; fmpr_rnd_t rnd; int negative; fmpz_init(man); fmpz_init(exp); fmpr_init(x); fmpr_init(y); prec = 2 + n_randint(state, 1000); if (n_randint(state, 10) == 0) prec = FMPR_PREC_EXACT; negative = n_randint(state, 2); lo = n_randtest(state); fmpz_randtest(exp, state, 1 + n_randint(state, 100)); if (negative) fmpz_neg_ui(man, lo); else fmpz_set_ui(man, lo); switch (n_randint(state, 4)) { case 0: rnd = FMPR_RND_DOWN; break; case 1: rnd = FMPR_RND_UP; break; case 2: rnd = FMPR_RND_FLOOR; break; default: rnd = FMPR_RND_CEIL; break; } ret1 = fmpr_set_round_ui_2exp_fmpz(x, lo, exp, negative, prec, rnd); fmpr_set_fmpz_2exp(y, man, exp); ret2 = fmpr_set_round(y, y, prec, rnd); if (!fmpr_equal(x, y) || ret1 != ret2 || !fmpr_check_ulp(x, ret1, prec) || !fmpr_check_ulp(y, ret2, prec)) { flint_printf("FAIL\n\n"); flint_printf("prec: %wd\n", prec); flint_printf("man = "); fmpz_print(man); flint_printf("\n\n"); flint_printf("exp = "); fmpz_print(exp); flint_printf("\n\n"); flint_printf("x = "); fmpr_print(x); flint_printf("\n\n"); flint_printf("y = "); fmpr_print(y); flint_printf("\n\n"); flint_printf("ret1 = %wd, ret2 = %wd\n\n", ret1, ret2); abort(); } fmpz_clear(man); fmpz_clear(exp); fmpr_clear(x); fmpr_clear(y); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int arb_get_unique_fmpz(fmpz_t z, const arb_t x) { if (!arb_is_finite(x)) { return 0; } else if (arb_is_exact(x)) { /* x = b*2^e, e >= 0 */ if (arf_is_int(arb_midref(x))) { /* arf_get_fmpz aborts on overflow */ arf_get_fmpz(z, arb_midref(x), ARF_RND_DOWN); return 1; } else { return 0; } } /* if the radius is >= 1, there are at least two integers */ else if (mag_cmp_2exp_si(arb_radref(x), 0) >= 0) { return 0; } /* there are 0 or 1 integers if the radius is < 1 */ else { fmpz_t a, b, exp; int res; /* if the midpoint is exactly an integer, it is what we want */ if (arf_is_int(arb_midref(x))) { /* arf_get_fmpz aborts on overflow */ arf_get_fmpz(z, arb_midref(x), ARF_RND_DOWN); return 1; } fmpz_init(a); fmpz_init(b); fmpz_init(exp); /* if the radius is tiny, it can't be an integer */ arf_bot(a, arb_midref(x)); if (fmpz_cmp(a, MAG_EXPREF(arb_radref(x))) > 0) { res = 0; } else { arb_get_interval_fmpz_2exp(a, b, exp, x); if (COEFF_IS_MPZ(*exp)) { flint_printf("arb_get_unique_fmpz: input too large\n"); abort(); } if (*exp >= 0) { res = fmpz_equal(a, b); if (res) { fmpz_mul_2exp(a, a, *exp); fmpz_mul_2exp(b, b, *exp); } } else { fmpz_cdiv_q_2exp(a, a, -(*exp)); fmpz_fdiv_q_2exp(b, b, -(*exp)); res = fmpz_equal(a, b); } if (res) fmpz_set(z, a); } fmpz_clear(a); fmpz_clear(b); fmpz_clear(exp); return res; } }
int main() { slong iter; flint_rand_t state; flint_printf("is_int_2exp_si...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { arf_t x, y; fmpz_t t; slong e; int res1, res2; arf_init(x); arf_init(y); fmpz_init(t); arf_randtest_special(x, state, 2000, 100); e = n_randtest(state); arf_mul_2exp_si(y, x, e); res1 = arf_is_int(x); res2 = arf_is_int_2exp_si(y, e); if (res1 != res2) { flint_printf("FAIL! (1)\n"); flint_printf("x = "); arf_print(x); flint_printf("\n\n"); flint_printf("y = "); arf_print(y); flint_printf("\n\n"); flint_printf("res1 = %d, res2 = %d\n\n", res1, res2); abort(); } if (res1) { if (n_randint(state, 2)) arf_floor(y, x); else arf_ceil(y, x); if (!arf_equal(x, y) || !arf_is_finite(x)) { flint_printf("FAIL! (2)\n"); flint_printf("x = "); arf_print(x); flint_printf("\n\n"); flint_printf("y = "); arf_print(y); flint_printf("\n\n"); flint_printf("res1 = %d\n\n", res1); abort(); } } if (arf_is_finite(x) && !arf_is_zero(x)) { arf_bot(t, x); fmpz_neg(t, t); arf_mul_2exp_fmpz(x, x, t); res1 = arf_is_int(x); arf_mul_2exp_si(y, x, -1); res2 = arf_is_int(y); if (!arf_is_int(x) || arf_is_int(y)) { flint_printf("FAIL! (3)\n"); flint_printf("x = "); arf_print(x); flint_printf("\n\n"); flint_printf("y = "); arf_print(y); flint_printf("\n\n"); flint_printf("res1 = %d, res2 = %d\n\n", res1, res2); abort(); } } arf_clear(x); arf_clear(y); fmpz_clear(t); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
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; }
static void _qadic_exp_bsplit_series(fmpz *P, fmpz_t Q, fmpz *T, const fmpz *x, slong len, slong lo, slong hi, const fmpz *a, const slong *j, slong lena) { const slong d = j[lena - 1]; if (hi - lo == 1) { _fmpz_vec_set(P, x, len); _fmpz_vec_zero(P + len, 2*d - 1 - len); fmpz_set_si(Q, lo); _fmpz_vec_set(T, P, 2*d - 1); } else if (hi - lo == 2) { _fmpz_poly_sqr(P, x, len); _fmpz_vec_zero(P + (2*len - 1), d - (2*len - 1)); _fmpz_poly_reduce(P, 2*len - 1, a, j, lena); fmpz_set_si(Q, lo); fmpz_mul_si(Q, Q, lo + 1); _fmpz_vec_scalar_mul_si(T, x, len, lo + 1); _fmpz_vec_zero(T + len, d - len); _fmpz_vec_add(T, T, P, d); } else { const slong m = (lo + hi) / 2; fmpz *PR, *TR, *W; fmpz_t QR; PR = _fmpz_vec_init(2*d - 1); TR = _fmpz_vec_init(2*d - 1); W = _fmpz_vec_init(2*d - 1); fmpz_init(QR); _qadic_exp_bsplit_series(P, Q, T, x, len, lo, m, a, j, lena); _qadic_exp_bsplit_series(PR, QR, TR, x, len, m, hi, a, j, lena); _fmpz_poly_mul(W, TR, d, P, d); _fmpz_poly_reduce(W, 2*d - 1, a, j, lena); _fmpz_vec_scalar_mul_fmpz(T, T, d, QR); _fmpz_vec_add(T, T, W, d); _fmpz_poly_mul(W, P, d, PR, d); _fmpz_poly_reduce(W, 2*d - 1, a, j, lena); _fmpz_vec_swap(P, W, d); fmpz_mul(Q, Q, QR); _fmpz_vec_clear(PR, 2*d - 1); _fmpz_vec_clear(TR, 2*d - 1); _fmpz_vec_clear(W, 2*d - 1); fmpz_clear(QR); } }
int main(void) { int i, j, result; ulong cflags = UWORD(0); mpq_t n1, n2; FLINT_TEST_INIT(state); flint_printf("get/set_coeff_fmpz...."); fflush(stdout); mpq_init(n1); mpq_init(n2); for (i = 0; i < 100 * flint_test_multiplier(); i++) { fmpq_poly_t a; fmpz_t x1, x2; slong coeff, len; fmpq_poly_init(a); fmpz_init(x1); fmpz_init(x2); len = (slong) (n_randint(state, 100) + 1); for (j = 0; j < 100; j++) { fmpz_randtest(x1, state, 200); fmpz_get_mpz(mpq_numref(n1), x1); flint_mpz_set_si(mpq_denref(n1), 1); coeff = (slong) n_randint(state, len); fmpq_poly_set_coeff_fmpz(a, coeff, x1); fmpq_poly_get_coeff_mpq(n2, a, coeff); cflags |= fmpq_poly_is_canonical(a) ? 0 : 1; result = (mpq_equal(n1, n2) && !cflags); if (!result) { flint_printf("FAIL:\n\n"); flint_printf("a = "), fmpq_poly_debug(a), flint_printf("\n\n"); flint_printf("coeff = %wd\n\n", coeff); flint_printf("len = %wd\n\n", len); flint_printf("cflags = %wu\n\n", cflags); gmp_printf("n1 = %Qd\n\n", n1); gmp_printf("n2 = %Qd\n\n", n2); abort(); } } fmpz_clear(x1); fmpz_clear(x2); fmpq_poly_clear(a); } mpq_clear(n1); mpq_clear(n2); FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
void _acb_poly_zeta_em_tail_naive(acb_ptr sum, const acb_t s, const acb_t Na, acb_srcptr Nasx, slong M, slong d, slong prec) { acb_ptr u, term; acb_t Na2, splus, rec; arb_t x; fmpz_t c; int aint; slong r; BERNOULLI_ENSURE_CACHED(2 * M); u = _acb_vec_init(d); term = _acb_vec_init(d); acb_init(splus); acb_init(rec); acb_init(Na2); arb_init(x); fmpz_init(c); _acb_vec_zero(sum, d); /* u = 1/2 * Nasx */ _acb_vec_scalar_mul_2exp_si(u, Nasx, d, -WORD(1)); /* term = u * (s+x) / (N+a) */ _acb_poly_mullow_cpx(u, u, d, s, d, prec); _acb_vec_scalar_div(term, u, d, Na, prec); /* (N+a)^2 or 1/(N+a)^2 */ acb_mul(Na2, Na, Na, prec); aint = acb_is_int(Na2); if (!aint) acb_inv(Na2, Na2, prec); for (r = 1; r <= M; r++) { /* flint_printf("sum 2: %wd %wd\n", r, M); */ /* sum += bernoulli number * term */ arb_set_round_fmpz(x, fmpq_numref(bernoulli_cache + 2 * r), prec); arb_div_fmpz(x, x, fmpq_denref(bernoulli_cache + 2 * r), prec); _acb_vec_scalar_mul_arb(u, term, d, x, prec); _acb_vec_add(sum, sum, u, d, prec); /* multiply term by ((s+x)+2r-1)((s+x)+2r) / ((N+a)^2 * (2*r+1)*(2*r+2)) */ acb_set(splus, s); arb_add_ui(acb_realref(splus), acb_realref(splus), 2*r-1, prec); _acb_poly_mullow_cpx(term, term, d, splus, d, prec); arb_add_ui(acb_realref(splus), acb_realref(splus), 1, prec); _acb_poly_mullow_cpx(term, term, d, splus, d, prec); /* TODO: combine with previous multiplication? */ if (aint) { arb_mul_ui(x, acb_realref(Na2), 2*r+1, prec); arb_mul_ui(x, x, 2*r+2, prec); _acb_vec_scalar_div_arb(term, term, d, x, prec); } else { fmpz_set_ui(c, 2*r+1); fmpz_mul_ui(c, c, 2*r+2); acb_div_fmpz(rec, Na2, c, prec); _acb_vec_scalar_mul(term, term, d, rec, prec); } } _acb_vec_clear(u, d); _acb_vec_clear(term, d); acb_clear(splus); acb_clear(rec); acb_clear(Na2); arb_clear(x); fmpz_clear(c); }
/* evaluates the truncated Taylor series (assumes no aliasing) */ void _arb_mat_exp_taylor(arb_mat_t S, const arb_mat_t A, slong N, slong prec) { if (N == 1) { arb_mat_one(S); } else if (N == 2) { arb_mat_one(S); arb_mat_add(S, S, A, prec); } else if (N == 3) { arb_mat_t T; arb_mat_init(T, arb_mat_nrows(A), arb_mat_nrows(A)); arb_mat_mul(T, A, A, prec); arb_mat_scalar_mul_2exp_si(T, T, -1); arb_mat_add(S, A, T, prec); arb_mat_one(T); arb_mat_add(S, S, T, prec); arb_mat_clear(T); } else { slong i, lo, hi, m, w, dim; arb_mat_struct * pows; arb_mat_t T, U; fmpz_t c, f; dim = arb_mat_nrows(A); m = n_sqrt(N); w = (N + m - 1) / m; fmpz_init(c); fmpz_init(f); pows = flint_malloc(sizeof(arb_mat_t) * (m + 1)); arb_mat_init(T, dim, dim); arb_mat_init(U, dim, dim); for (i = 0; i <= m; i++) { arb_mat_init(pows + i, dim, dim); if (i == 0) arb_mat_one(pows + i); else if (i == 1) arb_mat_set(pows + i, A); else arb_mat_mul(pows + i, pows + i - 1, A, prec); } arb_mat_zero(S); fmpz_one(f); for (i = w - 1; i >= 0; i--) { lo = i * m; hi = FLINT_MIN(N - 1, lo + m - 1); arb_mat_zero(T); fmpz_one(c); while (hi >= lo) { arb_mat_scalar_addmul_fmpz(T, pows + hi - lo, c, prec); if (hi != 0) fmpz_mul_ui(c, c, hi); hi--; } arb_mat_mul(U, pows + m, S, prec); arb_mat_scalar_mul_fmpz(S, T, f, prec); arb_mat_add(S, S, U, prec); fmpz_mul(f, f, c); } arb_mat_scalar_div_fmpz(S, S, f, prec); fmpz_clear(c); fmpz_clear(f); for (i = 0; i <= m; i++) arb_mat_clear(pows + i); flint_free(pows); arb_mat_clear(T); arb_mat_clear(U); } }
int main(void) { int i, result; flint_rand_t state; printf("sqrt... "); fflush(stdout); flint_randinit(state); /* PRIME p = 2 ***************************************************************/ /* Check aliasing: a = sqrt(a) */ for (i = 0; i < 10000; i++) { fmpz_t p; long N; padic_ctx_t ctx; int ans1, ans2; padic_t a, d; fmpz_init(p); fmpz_set_ui(p, 2); N = z_randint(state, 100); padic_ctx_init(ctx, p, N, PADIC_SERIES); padic_init(a, ctx); padic_init(d, ctx); padic_randtest(a, state, ctx); ans1 = padic_sqrt(d, a, ctx); ans2 = padic_sqrt(a, a, ctx); result = ((ans1 == ans2) && (!ans1 || padic_equal(a, d, ctx))); if (!result) { printf("FAIL (aliasing):\n\n"); printf("p = "), fmpz_print(p), printf("\n"); printf("a = "), _padic_print(a, ctx), printf("\n"); printf("d = "), _padic_print(d, ctx), printf("\n"); abort(); } padic_clear(a, ctx); padic_clear(d, ctx); fmpz_clear(p); padic_ctx_clear(ctx); } /* Test random elements */ for (i = 0; i < 10000; i++) { fmpz_t p; long N; padic_ctx_t ctx; int ans; padic_t a, b, d; fmpz_init(p); fmpz_set_ui(p, 2); N = z_randint(state, 100); padic_ctx_init(ctx, p, N, PADIC_SERIES); padic_init(a, ctx); padic_init(b, ctx); padic_init(d, ctx); padic_randtest(a, state, ctx); ans = padic_sqrt(b, a, ctx); padic_mul(d, b, b, ctx); if (ans && padic_val(a) < 0) { padic_ctx_t ctx2; padic_t a2, d2; padic_ctx_init(ctx2, p, N + padic_val(a), PADIC_SERIES); padic_init(a2, ctx2); padic_init(d2, ctx2); padic_set(a2, a, ctx2); padic_set(d2, d, ctx2); padic_reduce(a2, ctx2); padic_reduce(d2, ctx2); result = (padic_equal(a2, d2, ctx2)); if (!result) { printf("FAIL (random elements):\n\n"); printf("a = "), padic_print(a, ctx), printf("\n"); printf("b = "), padic_print(b, ctx), printf("\n"); printf("d = "), padic_print(d, ctx), printf("\n"); printf("a2 = "), padic_print(a2, ctx2), printf("\n"); printf("d2 = "), padic_print(d2, ctx2), printf("\n"); printf("p = "), fmpz_print(p), printf("\n"); printf("ans = %d\n", ans); abort(); } padic_clear(a2, ctx2); padic_clear(d2, ctx2); padic_ctx_clear(ctx2); } else { result = (!ans || padic_equal(a, d, ctx)); if (!result) { printf("FAIL (random elements):\n\n"); printf("a = "), padic_print(a, ctx), printf("\n"); printf("b = "), padic_print(b, ctx), printf("\n"); printf("d = "), padic_print(d, ctx), printf("\n"); printf("p = "), fmpz_print(p), printf("\n"); printf("ans = %d\n", ans); abort(); } } padic_clear(a, ctx); padic_clear(b, ctx); padic_clear(d, ctx); fmpz_clear(p); padic_ctx_clear(ctx); } /* Test random squares */ for (i = 0; i < 10000; i++) { fmpz_t p; long N; padic_ctx_t ctx; int ans; padic_t a, b, c, d; fmpz_init(p); fmpz_set_ui(p, 2); N = z_randint(state, 100); padic_ctx_init(ctx, p, N, PADIC_SERIES); padic_init(a, ctx); padic_init(b, ctx); padic_init(c, ctx); padic_init(d, ctx); padic_randtest(b, state, ctx); padic_mul(a, b, b, ctx); ans = padic_sqrt(c, a, ctx); padic_mul(d, c, c, ctx); if (ans && padic_val(a) < 0) { padic_ctx_t ctx2; padic_t a2, d2; padic_ctx_init(ctx2, p, N + padic_val(a), PADIC_SERIES); padic_init(a2, ctx2); padic_init(d2, ctx2); padic_set(a2, a, ctx2); padic_set(d2, d, ctx2); padic_reduce(a2, ctx2); padic_reduce(d2, ctx2); result = (padic_equal(a2, d2, ctx2)); if (!result) { printf("FAIL (random elements):\n\n"); printf("a = "), padic_print(a, ctx), printf("\n"); printf("b = "), padic_print(b, ctx), printf("\n"); printf("c = "), padic_print(c, ctx), printf("\n"); printf("d = "), padic_print(d, ctx), printf("\n"); printf("a2 = "), padic_print(a2, ctx2), printf("\n"); printf("d2 = "), padic_print(d2, ctx2), printf("\n"); printf("p = "), fmpz_print(p), printf("\n"); printf("ans = %d\n", ans); abort(); } padic_clear(a2, ctx2); padic_clear(d2, ctx2); padic_ctx_clear(ctx2); } else { result = (ans && padic_equal(a, d, ctx)); if (!result) { printf("FAIL (random squares):\n\n"); printf("a = "), padic_print(a, ctx), printf("\n"); printf("b = "), padic_print(b, ctx), printf("\n"); printf("c = "), padic_print(c, ctx), printf("\n"); printf("d = "), padic_print(d, ctx), printf("\n"); printf("p = "), fmpz_print(p), printf("\n"); printf("ans = %d\n", ans); abort(); } } padic_clear(a, ctx); padic_clear(b, ctx); padic_clear(c, ctx); padic_clear(d, ctx); fmpz_clear(p); padic_ctx_clear(ctx); } /* PRIME p > 2 ***************************************************************/ /* Check aliasing: a = sqrt(a) */ for (i = 0; i < 10000; i++) { fmpz_t p; long N; padic_ctx_t ctx; int ans1, ans2; padic_t a, d; fmpz_init(p); fmpz_set_ui(p, n_randprime(state, 5, 1)); N = z_randint(state, 100); padic_ctx_init(ctx, p, N, PADIC_SERIES); padic_init(a, ctx); padic_init(d, ctx); padic_randtest(a, state, ctx); ans1 = padic_sqrt(d, a, ctx); ans2 = padic_sqrt(a, a, ctx); result = ((ans1 == ans2) && (!ans1 || padic_equal(a, d, ctx))); if (!result) { printf("FAIL (aliasing):\n\n"); printf("a = "), _padic_print(a, ctx), printf("\n"); printf("d = "), _padic_print(d, ctx), printf("\n"); abort(); } padic_clear(a, ctx); padic_clear(d, ctx); fmpz_clear(p); padic_ctx_clear(ctx); } /* Test random elements */ for (i = 0; i < 10000; i++) { fmpz_t p; long N; padic_ctx_t ctx; int ans; padic_t a, b, d; fmpz_init(p); fmpz_set_ui(p, n_randprime(state, 5, 1)); N = z_randint(state, 100); padic_ctx_init(ctx, p, N, PADIC_SERIES); padic_init(a, ctx); padic_init(b, ctx); padic_init(d, ctx); padic_randtest(a, state, ctx); ans = padic_sqrt(b, a, ctx); padic_mul(d, b, b, ctx); if (ans && padic_val(a) < 0) { padic_ctx_t ctx2; padic_t a2, d2; padic_ctx_init(ctx2, p, N + padic_val(a), PADIC_SERIES); padic_init(a2, ctx2); padic_init(d2, ctx2); padic_set(a2, a, ctx2); padic_set(d2, d, ctx2); padic_reduce(a2, ctx2); padic_reduce(d2, ctx2); result = (padic_equal(a2, d2, ctx2)); if (!result) { printf("FAIL (random elements):\n\n"); printf("a = "), padic_print(a, ctx), printf("\n"); printf("b = "), padic_print(b, ctx), printf("\n"); printf("d = "), padic_print(d, ctx), printf("\n"); printf("a2 = "), padic_print(a2, ctx2), printf("\n"); printf("d2 = "), padic_print(d2, ctx2), printf("\n"); printf("p = "), fmpz_print(p), printf("\n"); printf("ans = %d\n", ans); abort(); } padic_clear(a2, ctx2); padic_clear(d2, ctx2); padic_ctx_clear(ctx2); } else { result = (!ans || padic_equal(a, d, ctx)); if (!result) { printf("FAIL (random elements):\n\n"); printf("a = "), padic_print(a, ctx), printf("\n"); printf("b = "), padic_print(b, ctx), printf("\n"); printf("d = "), padic_print(d, ctx), printf("\n"); printf("p = "), fmpz_print(p), printf("\n"); printf("ans = %d\n", ans); abort(); } } padic_clear(a, ctx); padic_clear(b, ctx); padic_clear(d, ctx); fmpz_clear(p); padic_ctx_clear(ctx); } /* Test random squares */ for (i = 0; i < 10000; i++) { fmpz_t p; long N; padic_ctx_t ctx; int ans; padic_t a, b, c, d; fmpz_init(p); fmpz_set_ui(p, n_randprime(state, 5, 1)); N = z_randint(state, 100); padic_ctx_init(ctx, p, N, PADIC_SERIES); padic_init(a, ctx); padic_init(b, ctx); padic_init(c, ctx); padic_init(d, ctx); padic_randtest(b, state, ctx); padic_mul(a, b, b, ctx); ans = padic_sqrt(c, a, ctx); padic_mul(d, c, c, ctx); if (ans && padic_val(a) < 0) { padic_ctx_t ctx2; padic_t a2, d2; padic_ctx_init(ctx2, p, N + padic_val(a), PADIC_SERIES); padic_init(a2, ctx2); padic_init(d2, ctx2); padic_set(a2, a, ctx2); padic_set(d2, d, ctx2); padic_reduce(a2, ctx2); padic_reduce(d2, ctx2); result = (padic_equal(a2, d2, ctx2)); if (!result) { printf("FAIL (random elements):\n\n"); printf("a = "), padic_print(a, ctx), printf("\n"); printf("b = "), padic_print(b, ctx), printf("\n"); printf("c = "), padic_print(c, ctx), printf("\n"); printf("d = "), padic_print(d, ctx), printf("\n"); printf("a2 = "), padic_print(a2, ctx2), printf("\n"); printf("d2 = "), padic_print(d2, ctx2), printf("\n"); printf("p = "), fmpz_print(p), printf("\n"); printf("ans = %d\n", ans); abort(); } padic_clear(a2, ctx2); padic_clear(d2, ctx2); padic_ctx_clear(ctx2); } else { result = (ans && padic_equal(a, d, ctx)); if (!result) { printf("FAIL (random squares):\n\n"); printf("a = "), padic_print(a, ctx), printf("\n"); printf("b = "), padic_print(b, ctx), printf("\n"); printf("c = "), padic_print(c, ctx), printf("\n"); printf("d = "), padic_print(d, ctx), printf("\n"); printf("p = "), fmpz_print(p), printf("\n"); printf("ans = %d\n", ans); abort(); } } padic_clear(a, ctx); padic_clear(b, ctx); padic_clear(c, ctx); padic_clear(d, ctx); fmpz_clear(p); padic_ctx_clear(ctx); } flint_randclear(state); _fmpz_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
int main(void) { int i, result; FLINT_TEST_INIT(state); flint_printf("remove...."); fflush(stdout); /* Compare with MPIR, random input */ for (i = 0; i < 1000 * flint_test_multiplier(); i++) { fmpz_t a, b, c; mpz_t d, e, f, g; slong x, y; fmpz_init(a); fmpz_init(b); fmpz_init(c); mpz_init(d); mpz_init(e); mpz_init(f); mpz_init(g); fmpz_randtest_not_zero(a, state, 200); do { fmpz_randtest_not_zero(b, state, 200); fmpz_abs(b, b); } while (fmpz_is_one(b)); fmpz_get_mpz(d, a); fmpz_get_mpz(e, b); x = fmpz_remove(c, a, b); y = mpz_remove(f, d, e); fmpz_get_mpz(g, c); result = ((x == y) && (mpz_cmp(f, g) == 0)); if (!result) { flint_printf("FAIL:\n"); gmp_printf("d = %Zd, e = %Zd, f = %Zd, g = %Zd\n", d, e, f, g); abort(); } fmpz_clear(a); fmpz_clear(b); fmpz_clear(c); mpz_clear(d); mpz_clear(e); mpz_clear(f); mpz_clear(g); } /* Compare with MPIR, random input but ensure that factors exist */ for (i = 0; i < 1000 * flint_test_multiplier(); i++) { fmpz_t a, b, c, pow; mpz_t d, e, f, g; slong x, y; ulong n; fmpz_init(a); fmpz_init(b); fmpz_init(c); fmpz_init(pow); mpz_init(d); mpz_init(e); mpz_init(f); mpz_init(g); fmpz_randtest_not_zero(a, state, 200); do { fmpz_randtest_not_zero(b, state, 200); fmpz_abs(b, b); } while (fmpz_is_one(b)); n = n_randint(state, 10); fmpz_pow_ui(pow, b, n); fmpz_mul(a, a, pow); fmpz_get_mpz(d, a); fmpz_get_mpz(e, b); x = fmpz_remove(c, a, b); y = mpz_remove(f, d, e); fmpz_get_mpz(g, c); result = ((x == y) && (x >= n) && (mpz_cmp(f, g) == 0)); if (!result) { flint_printf("FAIL:\n"); gmp_printf("d = %Zd, e = %Zd, f = %Zd, g = %Zd\n", d, e, f, g); abort(); } fmpz_clear(a); fmpz_clear(b); fmpz_clear(c); fmpz_clear(pow); mpz_clear(d); mpz_clear(e); mpz_clear(f); mpz_clear(g); } /* Check aliasing of a and b */ for (i = 0; i < 100 * flint_test_multiplier(); i++) { fmpz_t a, c; slong x; fmpz_init(a); fmpz_init(c); do { fmpz_randtest_not_zero(a, state, 200); fmpz_abs(a, a); } while (fmpz_is_one(a)); x = fmpz_remove(c, a, a); result = ((x == 1) && (fmpz_cmp_ui(c, 1) == 0)); if (!result) { flint_printf("FAIL:\n"); fmpz_print(a), flint_printf("\n"); fmpz_print(c), flint_printf("\n"); abort(); } fmpz_clear(a); fmpz_clear(c); } /* Check aliasing of a and c */ for (i = 0; i < 100 * flint_test_multiplier(); i++) { fmpz_t a, b, c; slong x, y; fmpz_init(a); fmpz_init(b); fmpz_init(c); fmpz_randtest_not_zero(a, state, 200); do { fmpz_randtest_not_zero(b, state, 200); fmpz_abs(b, b); } while (fmpz_is_one(b)); x = fmpz_remove(c, a, b); y = fmpz_remove(a, a, b); result = ((x == y) && fmpz_equal(a, c)); if (!result) { flint_printf("FAIL:\n"); fmpz_print(a), flint_printf("\n"); fmpz_print(b), flint_printf("\n"); fmpz_print(c), flint_printf("\n"); abort(); } fmpz_clear(a); fmpz_clear(b); fmpz_clear(c); } /* Check aliasing of b and c */ for (i = 0; i < 100 * flint_test_multiplier(); i++) { fmpz_t a, b, c; slong x, y; fmpz_init(a); fmpz_init(b); fmpz_init(c); fmpz_randtest_not_zero(a, state, 200); do { fmpz_randtest_not_zero(b, state, 200); fmpz_abs(b, b); } while (fmpz_is_one(b)); x = fmpz_remove(c, a, b); y = fmpz_remove(b, a, b); result = ((x == y) && fmpz_equal(b, c)); if (!result) { flint_printf("FAIL:\n"); fmpz_print(a), flint_printf("\n"); fmpz_print(b), flint_printf("\n"); fmpz_print(c), flint_printf("\n"); abort(); } fmpz_clear(a); fmpz_clear(b); fmpz_clear(c); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
~FlintZZ() { fmpz_clear(value); }
static void bsplit_recursive_fmprb(fmprb_t P, fmprb_t Q, fmprb_t B, fmprb_t T, const hypgeom_t hyp, long a, long b, int cont, long prec) { if (b - a < 4) { fmpz_t PP, QQ, BB, TT; fmpz_init(PP); fmpz_init(QQ); fmpz_init(BB); fmpz_init(TT); bsplit_recursive_fmpz(PP, QQ, BB, TT, hyp, a, b, cont); fmprb_set_fmpz(P, PP); fmprb_set_fmpz(Q, QQ); fmprb_set_fmpz(B, BB); fmprb_set_fmpz(T, TT); fmpz_clear(PP); fmpz_clear(QQ); fmpz_clear(BB); fmpz_clear(TT); } else { long m; fmprb_t P2, Q2, B2, T2; m = (a + b) / 2; fmprb_init(P2); fmprb_init(Q2); fmprb_init(B2); fmprb_init(T2); bsplit_recursive_fmprb(P, Q, B, T, hyp, a, m, 1, prec); bsplit_recursive_fmprb(P2, Q2, B2, T2, hyp, m, b, 1, prec); if (fmprb_is_one(B) && fmprb_is_one(B2)) { fmprb_mul(T, T, Q2, prec); fmprb_addmul(T, P, T2, prec); } else { fmprb_mul(T, T, B2, prec); fmprb_mul(T, T, Q2, prec); fmprb_mul(T2, T2, B, prec); fmprb_addmul(T, P, T2, prec); } fmprb_mul(B, B, B2, prec); fmprb_mul(Q, Q, Q2, prec); if (cont) fmprb_mul(P, P, P2, prec); fmprb_clear(P2); fmprb_clear(Q2); fmprb_clear(B2); fmprb_clear(T2); } }
int main(void) { int i, j, result; ulong count = UWORD(0); gmp_randstate_t st; FLINT_TEST_INIT(state); gmp_randinit_default(st); flint_printf("factor_pp1...."); fflush(stdout); for (i = 0; i < 50 * flint_test_multiplier(); i++) /* Test random numbers */ { mp_bitcnt_t bits; mpz_t m, n; fmpz_t n1, n2, r; mpz_init(n); mpz_init(m); fmpz_init(n1); fmpz_init(n2); fmpz_init(r); do { mpz_urandomb(n, st, n_randint(state, 128) + 2); } while (flint_mpz_cmp_ui(n, 2) < 0); do { mpz_urandomb(m, st, n_randint(state, 50) + 2); } while (!mpz_probab_prime_p(m, 20)); mpz_mul(n, n, m); fmpz_set_mpz(n1, n); bits = FLINT_MIN(fmpz_bits(n1), FLINT_BITS); for (j = 0; j < 20; j++) { fmpz_factor_pp1(n2, n1, 10000, 10000, n_randbits(state, bits - 2) + 3); if (fmpz_cmp_ui(n2, 1) > 0) break; } if (fmpz_cmp_ui(n2, 1) > 0) { count++; fmpz_mod(r, n1, n2); result = (fmpz_is_zero(r)); if (!result) { flint_printf("FAIL:\n"); flint_printf("n1 = "); fmpz_print(n1); flint_printf(", n2 = "); fmpz_print(n2); flint_printf("\n"); fmpz_print(r); flint_printf("\n"); abort(); } } fmpz_clear(n1); fmpz_clear(n2); fmpz_clear(r); mpz_clear(m); mpz_clear(n); } if (count < 49 * flint_test_multiplier()) { flint_printf("FAIL:\n"); flint_printf("Only %wu numbers factored\n", count); abort(); } gmp_randclear(st); FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int j, i, result; fq_zech_ctx_t ctx; FLINT_TEST_INIT(state); flint_printf("mul_fmpz... "); fflush(stdout); for (j = 0; j < 50; j++) { fq_zech_ctx_randtest(ctx, state); for (i = 0; i < 200; i++) { fmpz_t x; fq_nmod_t aa, bb; fq_zech_t a, b, c; fq_nmod_init(aa, ctx->fq_nmod_ctx); fq_nmod_init(bb, ctx->fq_nmod_ctx); fmpz_init(x); fmpz_randtest_mod_signed(x, state, fq_zech_ctx_prime(ctx)); fq_nmod_randtest(aa, state, ctx->fq_nmod_ctx); fq_zech_set_fq_nmod(a, aa, ctx); fq_nmod_mul_fmpz(bb, aa, x, ctx->fq_nmod_ctx); fq_zech_set_fq_nmod(b, bb, ctx); fq_zech_mul_fmpz(c, a, x, ctx); result = (fq_zech_equal(b, c, ctx)); if (!result) { flint_printf("FAIL:\n\n"); fq_zech_ctx_print(ctx); flint_printf("\n"); flint_printf("aa = "); fq_nmod_print_pretty(aa, ctx->fq_nmod_ctx); flint_printf("\n"); flint_printf("a = "); fq_zech_print_pretty(a, ctx); flint_printf("\n"); flint_printf("b = "); fq_zech_print_pretty(b, ctx); flint_printf("\n"); flint_printf("c = "); fq_zech_print_pretty(c, ctx); flint_printf("\n"); abort(); } fmpz_clear(x); fq_nmod_clear(bb, ctx->fq_nmod_ctx); fq_nmod_clear(aa, ctx->fq_nmod_ctx); } for (i = 0; i < 200; i++) { fmpz_t x; fq_nmod_t aa, bb; fq_zech_t a, b; fq_nmod_init(aa, ctx->fq_nmod_ctx); fq_nmod_init(bb, ctx->fq_nmod_ctx); fmpz_init(x); fmpz_randtest_mod_signed(x, state, fq_zech_ctx_prime(ctx)); fq_nmod_randtest(aa, state, ctx->fq_nmod_ctx); fq_zech_set_fq_nmod(a, aa, ctx); fq_nmod_mul_fmpz(bb, aa, x, ctx->fq_nmod_ctx); fq_zech_set_fq_nmod(b, bb, ctx); fq_zech_mul_fmpz(a, a, x, ctx); result = (fq_zech_equal(b, a, ctx)); if (!result) { flint_printf("FAIL:\n\n"); fq_zech_ctx_print(ctx); flint_printf("\n"); flint_printf("aa = "); fq_nmod_print_pretty(aa, ctx->fq_nmod_ctx); flint_printf("\n"); flint_printf("a = "); fq_zech_print_pretty(a, ctx); flint_printf("\n"); flint_printf("b = "); fq_zech_print_pretty(b, ctx); flint_printf("\n"); abort(); } fmpz_clear(x); fq_nmod_clear(bb, ctx->fq_nmod_ctx); fq_nmod_clear(aa, ctx->fq_nmod_ctx); } fq_zech_ctx_clear(ctx); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return EXIT_SUCCESS; }
void _fmpz_poly_resultant(fmpz_t res, const fmpz * poly1, long len1, const fmpz * poly2, long len2) { if (len2 == 1) { fmpz_pow_ui(res, poly2, len1 - 1); } else { fmpz_t a, b, g, h, t; fmpz *A, *B, *W; const long alloc = len1 + len2; long sgn = 1; fmpz_init(a); fmpz_init(b); fmpz_init(g); fmpz_init(h); fmpz_init(t); A = W = _fmpz_vec_init(alloc); B = W + len1; _fmpz_poly_content(a, poly1, len1); _fmpz_poly_content(b, poly2, len2); _fmpz_vec_scalar_divexact_fmpz(A, poly1, len1, a); _fmpz_vec_scalar_divexact_fmpz(B, poly2, len2, b); fmpz_set_ui(g, 1); fmpz_set_ui(h, 1); fmpz_pow_ui(a, a, len2 - 1); fmpz_pow_ui(b, b, len1 - 1); fmpz_mul(t, a, b); do { const long d = len1 - len2; if (!(len1 & 1L) & !(len2 & 1L)) sgn = -sgn; _fmpz_poly_pseudo_rem_cohen(A, A, len1, B, len2); for (len1--; len1 >= 0 && !A[len1]; len1--) ; len1++; if (len1 == 0) { fmpz_zero(res); goto cleanup; } { fmpz * T; long len; T = A, A = B, B = T; len = len1, len1 = len2, len2 = len; } fmpz_pow_ui(a, h, d); fmpz_mul(b, g, a); _fmpz_vec_scalar_divexact_fmpz(B, B, len2, b); fmpz_pow_ui(g, A + (len1 - 1), d); fmpz_mul(b, h, g); fmpz_divexact(h, b, a); fmpz_set(g, A + (len1 - 1)); } while (len2 > 1); fmpz_pow_ui(g, h, len1 - 1); fmpz_pow_ui(b, B + (len2 - 1), len1 - 1); fmpz_mul(a, h, b); fmpz_divexact(h, a, g); fmpz_mul(res, t, h); if (sgn < 0) fmpz_neg(res, res); cleanup: fmpz_clear(a); fmpz_clear(b); fmpz_clear(g); fmpz_clear(h); fmpz_clear(t); _fmpz_vec_clear(W, alloc); } }
int main(void) { char *str; /* String for the input polynomial P */ mpoly_t P; /* Input polynomial P */ int n; /* Number of variables minus one */ long K; /* Required t-adic precision */ long N, Nw; long b; /* Matrix dimensions */ long i, j, k; mat_t M; ctx_t ctxM; mon_t *rows, *cols; padic_mat_struct *C; fmpz_t p; fmpz_poly_mat_t B; long vB; printf("solve... \n"); fflush(stdout); /* Example 3-1-1 */ /* str = "3 [3 0 0] [0 3 0] [0 0 3] (2 0 1)[1 1 1]"; */ /* Example 3-3-2 */ /* str = "3 [3 0 0] [0 3 0] [0 0 3] (2 0 1)[2 1 0] (2 0 1)[0 2 1] (2 0 1)[1 0 2]"; */ /* Example 4-4-2 */ /* str = "4 [4 0 0 0] [0 4 0 0] [0 0 4 0] [0 0 0 4] (2 0 1)[3 1 0 0] (2 0 1)[1 0 1 2] (2 0 1)[0 1 0 3]"; */ /* Example ... */ /* str = "4 [4 0 0 0] [0 4 0 0] [0 0 4 0] [0 0 0 4] (2 0 1)[1 1 1 1]"; */ /* Example from AKR */ str = "4 (1 3)[0 3 0 0] (2 0 3)[0 1 2 0] " "(2 0 -1)[1 1 1 0] (2 0 3)[1 1 0 1] " "(2 0 -1)[2 1 0 0] [0 0 3 0] (2 0 -1)[1 0 2 0] " "(1 2)[0 0 0 3] [3 0 0 0]"; n = atoi(str) - 1; K = 616; N = 10; Nw = 22; fmpz_init(p); fmpz_set_ui(p, 5); ctx_init_fmpz_poly_q(ctxM); ctxM->print = &__fmpz_poly_q_print_pretty; mpoly_init(P, n + 1, ctxM); mpoly_set_str(P, str, ctxM); printf("P = "), mpoly_print(P, ctxM), printf("\n"); b = gmc_basis_size(n, mpoly_degree(P, -1, ctxM)); mat_init(M, b, b, ctxM); fmpz_poly_mat_init(B, b, b); vB = 0; gmc_compute(M, &rows, &cols, P, ctxM); mat_print(M, ctxM); printf("\n"); gmde_solve(&C, K, p, N, Nw, M, ctxM); gmde_convert_soln(B, &vB, C, K, p); printf("Solution to (d/dt + M) C = 0:\n"); fmpz_poly_mat_print(B, "t"); printf("vB = %ld\n", vB); gmde_check_soln(B, vB, p, N, K, M, ctxM); mpoly_clear(P, ctxM); mat_clear(M, ctxM); free(rows); free(cols); fmpz_poly_mat_clear(B); ctx_clear(ctxM); fmpz_clear(p); for (i = 0; i < K; i++) padic_mat_clear(C + i); free(C); _fmpz_cleanup(); return EXIT_SUCCESS; }
void acb_pow_fmpz_binexp(acb_t y, const acb_t b, const fmpz_t e, long prec) { long i, wp, bits; if (-2L <= *e && *e <= 4L) { if (*e == 0L) { acb_one(y); } else if (*e == 1L) { acb_set_round(y, b, prec); } else if (*e == -1L) { acb_inv(y, b, prec); } else if (*e == 2L) { acb_mul(y, b, b, prec); } else if (*e == 3L) { acb_cube(y, b, prec); } else if (*e == 4L) { acb_mul(y, b, b, prec); acb_mul(y, y, y, prec); } else { acb_inv(y, b, prec); acb_mul(y, y, y, prec); } return; } if (fmpz_sgn(e) < 0) { fmpz_t f; fmpz_init(f); fmpz_neg(f, e); acb_pow_fmpz_binexp(y, b, f, prec + 2); acb_inv(y, y, prec); fmpz_clear(f); return; } if (!COEFF_IS_MPZ(*e) && ((*e) % 3 == 0)) { fmpz e3 = (*e) / 3; acb_pow_fmpz_binexp(y, b, &e3, prec); acb_cube(y, y, prec); return; } if (y == b) { acb_t t; acb_init(t); acb_set(t, b); acb_pow_fmpz_binexp(y, t, e, prec); acb_clear(t); return; } acb_set(y, b); bits = fmpz_bits(e); wp = ARF_PREC_ADD(prec, bits); for (i = bits - 2; i >= 0; i--) { acb_mul(y, y, y, wp); if (fmpz_tstbit(e, i)) acb_mul(y, y, b, wp); } }
int main(void) { int i, result; FLINT_TEST_INIT(state); flint_printf("pseudo_div...."); fflush(stdout); /* Check r = a - q * b has small degree, no aliasing */ for (i = 0; i < 200 * flint_test_multiplier(); i++) { fmpz_poly_t a, b, q, r, prod; fmpz_t p; ulong d; fmpz_init(p); fmpz_poly_init(a); fmpz_poly_init(b); fmpz_poly_init(q); fmpz_poly_init(r); fmpz_poly_init(prod); fmpz_poly_randtest(a, state, n_randint(state, 100), 50); fmpz_poly_randtest_not_zero(b, state, n_randint(state, 100) + 1, 50); fmpz_poly_pseudo_div(q, &d, a, b); fmpz_poly_mul(prod, q, b); fmpz_pow_ui(p, b->coeffs + b->length - 1, d); fmpz_poly_scalar_mul_fmpz(a, a, p); fmpz_poly_sub(r, a, prod); result = (fmpz_poly_length(r) < fmpz_poly_length(b)); if (!result) { flint_printf("FAIL:\n"); fmpz_poly_print(a), flint_printf("\n\n"); fmpz_poly_print(prod), flint_printf("\n\n"); fmpz_poly_print(q), flint_printf("\n\n"); fmpz_poly_print(r), flint_printf("\n\n"); abort(); } fmpz_clear(p); fmpz_poly_clear(a); fmpz_poly_clear(b); fmpz_poly_clear(q); fmpz_poly_clear(r); fmpz_poly_clear(prod); } /* Check q and a alias */ for (i = 0; i < 50 * flint_test_multiplier(); i++) { fmpz_poly_t a, b, q; ulong d; fmpz_poly_init(a); fmpz_poly_init(b); fmpz_poly_init(q); fmpz_poly_randtest(a, state, n_randint(state, 100), 50); fmpz_poly_randtest_not_zero(b, state, n_randint(state, 100) + 1, 50); fmpz_poly_pseudo_div(q, &d, a, b); fmpz_poly_pseudo_div(a, &d, a, b); result = (fmpz_poly_equal(a, q)); if (!result) { flint_printf("FAIL:\n"); fmpz_poly_print(a), flint_printf("\n\n"); fmpz_poly_print(q), flint_printf("\n\n"); abort(); } fmpz_poly_clear(a); fmpz_poly_clear(b); fmpz_poly_clear(q); } /* Check q and b alias */ for (i = 0; i < 50 * flint_test_multiplier(); i++) { fmpz_poly_t a, b, q; ulong d; fmpz_poly_init(a); fmpz_poly_init(b); fmpz_poly_init(q); fmpz_poly_randtest(a, state, n_randint(state, 100), 50); fmpz_poly_randtest_not_zero(b, state, n_randint(state, 100) + 1, 50); fmpz_poly_pseudo_div(q, &d, a, b); fmpz_poly_pseudo_div(b, &d, a, b); result = (fmpz_poly_equal(b, q)); if (!result) { flint_printf("FAIL:\n"); fmpz_poly_print(a), flint_printf("\n\n"); fmpz_poly_print(q), flint_printf("\n\n"); abort(); } fmpz_poly_clear(a); fmpz_poly_clear(b); fmpz_poly_clear(q); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }