int main() { slong iter; flint_rand_t state; flint_printf("acos_series...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { slong m, n, qbits, rbits1, rbits2; fmpq_poly_t A; arb_poly_t a, b, c, d; qbits = 2 + n_randint(state, 200); rbits1 = 2 + n_randint(state, 200); rbits2 = 2 + n_randint(state, 200); m = 1 + n_randint(state, 30); n = 1 + n_randint(state, 30); fmpq_poly_init(A); arb_poly_init(a); arb_poly_init(b); arb_poly_init(c); arb_poly_init(d); fmpq_poly_randtest(A, state, m, qbits); arb_poly_set_fmpq_poly(a, A, rbits1); arb_poly_randtest(b, state, 1 + n_randint(state, 30), rbits1, 5); arb_poly_acos_series(b, a, n, rbits2); /* Check cos(acos(x)) = x */ arb_poly_sin_cos_series_basecase(d, c, b, n, rbits2, 0); fmpq_poly_truncate(A, n); if (!arb_poly_contains_fmpq_poly(c, A)) { flint_printf("FAIL\n\n"); flint_printf("bits2 = %wd\n", rbits2); flint_printf("A = "); fmpq_poly_print(A); flint_printf("\n\n"); flint_printf("a = "); arb_poly_printd(a, 15); flint_printf("\n\n"); flint_printf("b = "); arb_poly_printd(b, 15); flint_printf("\n\n"); flint_printf("c = "); arb_poly_printd(c, 15); flint_printf("\n\n"); flint_printf("d = "); arb_poly_printd(d, 15); flint_printf("\n\n"); abort(); } arb_poly_acos_series(a, a, n, rbits2); if (!arb_poly_equal(a, b)) { flint_printf("FAIL (aliasing)\n\n"); abort(); } fmpq_poly_clear(A); arb_poly_clear(a); arb_poly_clear(b); arb_poly_clear(c); arb_poly_clear(d); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("theta_const_sum_rs...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 5000 * arb_test_multiplier(); iter++) { acb_t q, t2a, t2b, t3a, t3b, t4a, t4b; slong prec1, prec2, N; acb_init(q); acb_init(t2a); acb_init(t2b); acb_init(t3a); acb_init(t3b); acb_init(t4a); acb_init(t4b); prec1 = 2 + n_randint(state, 1000); prec2 = 2 + n_randint(state, 1000); N = n_randint(state, 300); acb_randtest(q, state, prec1, 3); acb_randtest(t2a, state, prec1, 3); acb_randtest(t2b, state, prec1, 3); acb_randtest(t3a, state, prec1, 3); acb_randtest(t3b, state, prec1, 3); acb_randtest(t4a, state, prec1, 3); acb_randtest(t4b, state, prec1, 3); acb_modular_theta_const_sum_basecase(t2a, t3a, t4a, q, N, prec1); acb_modular_theta_const_sum_rs(t2b, t3b, t4b, q, N, prec2); if (!acb_overlaps(t2a, t2b) || !acb_overlaps(t3a, t3b) || !acb_overlaps(t4a, t4b)) { flint_printf("FAIL (overlap) iter = %wd\n", iter); flint_printf("N = %wd\n", N); flint_printf("q = "); acb_printd(q, 50); flint_printf("\n\n"); flint_printf("t2a = "); acb_printd(t2a, 50); flint_printf("\n\n"); flint_printf("t2b = "); acb_printd(t2b, 50); flint_printf("\n\n"); flint_printf("t3a = "); acb_printd(t3a, 50); flint_printf("\n\n"); flint_printf("t3b = "); acb_printd(t3b, 50); flint_printf("\n\n"); flint_printf("t4a = "); acb_printd(t4a, 50); flint_printf("\n\n"); flint_printf("t4b = "); acb_printd(t4b, 50); flint_printf("\n\n"); abort(); } acb_clear(q); acb_clear(t2a); acb_clear(t2b); acb_clear(t3a); acb_clear(t3b); acb_clear(t4a); acb_clear(t4b); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter, iter2; flint_rand_t state; flint_printf("complex_mul...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { arf_t e1, f1, e2, f2, a, b, c, d; slong prec, r1, r2; arf_rnd_t rnd; arf_init(a); arf_init(b); arf_init(c); arf_init(d); arf_init(e1); arf_init(f1); arf_init(e2); arf_init(f2); for (iter2 = 0; iter2 < 100; iter2++) { arf_randtest_special(a, state, 3000, 100); arf_randtest_special(b, state, 3000, 100); arf_randtest_special(c, state, 3000, 100); arf_randtest_special(d, state, 3000, 100); prec = 2 + n_randint(state, 3000); 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, 5)) { case 0: r1 = arf_complex_mul(e1, f1, a, b, c, d, prec, rnd); r2 = arf_complex_mul_fallback(e2, f2, a, b, c, d, prec, rnd); if (!arf_equal(e1, e2) || !arf_equal(f1, f2) || r1 != r2) { flint_printf("FAIL!\n"); flint_printf("prec = %wd, rnd = %d\n\n", prec, rnd); flint_printf("a = "); arf_print(a); flint_printf("\n\n"); flint_printf("b = "); arf_print(b); flint_printf("\n\n"); flint_printf("c = "); arf_print(c); flint_printf("\n\n"); flint_printf("d = "); arf_print(d); flint_printf("\n\n"); flint_printf("e1 = "); arf_print(e1); flint_printf("\n\n"); flint_printf("f1 = "); arf_print(f1); flint_printf("\n\n"); flint_printf("e2 = "); arf_print(e2); flint_printf("\n\n"); flint_printf("f2 = "); arf_print(f2); flint_printf("\n\n"); flint_printf("r1 = %wd, r2 = %wd\n", r1, r2); abort(); } break; case 1: arf_set(c, a); arf_set(d, b); r1 = arf_complex_mul(e1, f1, a, b, a, b, prec, rnd); r2 = arf_complex_mul_fallback(e2, f2, a, b, c, d, prec, rnd); if (!arf_equal(e1, e2) || !arf_equal(f1, f2) || r1 != r2) { flint_printf("FAIL! (aliasing 1)\n"); flint_printf("prec = %wd, rnd = %d\n\n", prec, rnd); flint_printf("a = "); arf_print(a); flint_printf("\n\n"); flint_printf("b = "); arf_print(b); flint_printf("\n\n"); flint_printf("c = "); arf_print(c); flint_printf("\n\n"); flint_printf("d = "); arf_print(d); flint_printf("\n\n"); flint_printf("e1 = "); arf_print(e1); flint_printf("\n\n"); flint_printf("f1 = "); arf_print(f1); flint_printf("\n\n"); flint_printf("e2 = "); arf_print(e2); flint_printf("\n\n"); flint_printf("f2 = "); arf_print(f2); flint_printf("\n\n"); flint_printf("r1 = %wd, r2 = %wd\n", r1, r2); abort(); } break; case 2: r1 = arf_complex_mul_fallback(e1, f1, a, b, a, b, prec, rnd); r2 = arf_complex_mul(a, b, a, b, a, b, prec, rnd); if (!arf_equal(e1, a) || !arf_equal(f1, b) || r1 != r2) { flint_printf("FAIL! (aliasing 2)\n"); flint_printf("prec = %wd, rnd = %d\n\n", prec, rnd); flint_printf("a = "); arf_print(a); flint_printf("\n\n"); flint_printf("b = "); arf_print(b); flint_printf("\n\n"); flint_printf("e1 = "); arf_print(e1); flint_printf("\n\n"); flint_printf("f1 = "); arf_print(f1); flint_printf("\n\n"); flint_printf("r1 = %wd, r2 = %wd\n", r1, r2); abort(); } break; case 3: r1 = arf_complex_mul_fallback(e1, f1, a, b, c, d, prec, rnd); r2 = arf_complex_mul(a, b, a, b, c, d, prec, rnd); if (!arf_equal(e1, a) || !arf_equal(f1, b) || r1 != r2) { flint_printf("FAIL! (aliasing 3)\n"); flint_printf("prec = %wd, rnd = %d\n\n", prec, rnd); flint_printf("a = "); arf_print(a); flint_printf("\n\n"); flint_printf("b = "); arf_print(b); flint_printf("\n\n"); flint_printf("c = "); arf_print(c); flint_printf("\n\n"); flint_printf("d = "); arf_print(d); flint_printf("\n\n"); flint_printf("e1 = "); arf_print(e1); flint_printf("\n\n"); flint_printf("f1 = "); arf_print(f1); flint_printf("\n\n"); flint_printf("r1 = %wd, r2 = %wd\n", r1, r2); abort(); } break; default: r1 = arf_complex_mul_fallback(e1, f1, a, b, c, d, prec, rnd); r2 = arf_complex_mul(c, d, a, b, c, d, prec, rnd); if (!arf_equal(e1, c) || !arf_equal(f1, d) || r1 != r2) { flint_printf("FAIL! (aliasing 4)\n"); flint_printf("prec = %wd, rnd = %d\n\n", prec, rnd); flint_printf("a = "); arf_print(a); flint_printf("\n\n"); flint_printf("b = "); arf_print(b); flint_printf("\n\n"); flint_printf("c = "); arf_print(c); flint_printf("\n\n"); flint_printf("d = "); arf_print(d); flint_printf("\n\n"); flint_printf("e1 = "); arf_print(e1); flint_printf("\n\n"); flint_printf("f1 = "); arf_print(f1); flint_printf("\n\n"); flint_printf("r1 = %wd, r2 = %wd\n", r1, r2); abort(); } break; } } arf_clear(a); arf_clear(b); arf_clear(c); arf_clear(d); arf_clear(e1); arf_clear(f1); arf_clear(e2); arf_clear(f2); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("zeta_ui_euler_product...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { arb_t r; ulong n; mpfr_t s; slong prec, accuracy; do { n = n_randint(state, 1 << n_randint(state, 10)); } while (n < 6); prec = 2 + n_randint(state, n * FLINT_BIT_COUNT(n)); arb_init(r); mpfr_init2(s, prec + 100); arb_zeta_ui_euler_product(r, n, prec); mpfr_zeta_ui(s, n, MPFR_RNDN); if (!arb_contains_mpfr(r, s)) { flint_printf("FAIL: containment\n\n"); flint_printf("n = %wu\n\n", n); flint_printf("r = "); arb_printd(r, prec / 3.33); flint_printf("\n\n"); flint_printf("s = "); mpfr_printf("%.275Rf\n", s); flint_printf("\n\n"); flint_abort(); } accuracy = arb_rel_accuracy_bits(r); if (accuracy < prec - 4) { flint_printf("FAIL: accuracy = %wd, prec = %wd\n\n", accuracy, prec); flint_printf("n = %wu\n\n", n); flint_printf("r = "); arb_printd(r, prec / 3.33); flint_printf("\n\n"); flint_abort(); } arb_clear(r); mpfr_clear(s); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main(void) { int i, result; ulong cflags = UWORD(0); FLINT_TEST_INIT(state); flint_printf("add...."); fflush(stdout); /* Check aliasing of a and c */ for (i = 0; i < 1000 * flint_test_multiplier(); i++) { fmpq_poly_t a, b, c; fmpq_poly_init(a); fmpq_poly_init(b); fmpq_poly_init(c); fmpq_poly_randtest(a, state, n_randint(state, 100), 200); fmpq_poly_randtest(b, state, n_randint(state, 100), 200); fmpq_poly_add(c, a, b); fmpq_poly_add(a, a, b); cflags |= fmpq_poly_is_canonical(a) ? 0 : 1; cflags |= fmpq_poly_is_canonical(c) ? 0 : 2; result = (fmpq_poly_equal(a, c) && !cflags); if (!result) { flint_printf("FAIL:\n"); fmpq_poly_debug(a), flint_printf("\n\n"); fmpq_poly_debug(b), flint_printf("\n\n"); fmpq_poly_debug(c), flint_printf("\n\n"); flint_printf("cflags = %wu\n\n", cflags); abort(); } fmpq_poly_clear(a); fmpq_poly_clear(b); fmpq_poly_clear(c); } /* Check aliasing of b and c */ for (i = 0; i < 1000 * flint_test_multiplier(); i++) { fmpq_poly_t a, b, c; fmpq_poly_init(a); fmpq_poly_init(b); fmpq_poly_init(c); fmpq_poly_randtest(a, state, n_randint(state, 100), 200); fmpq_poly_randtest(b, state, n_randint(state, 100), 200); fmpq_poly_add(c, a, b); fmpq_poly_add(b, a, b); cflags |= fmpq_poly_is_canonical(b) ? 0 : 1; cflags |= fmpq_poly_is_canonical(c) ? 0 : 2; result = (fmpq_poly_equal(b, c) && !cflags); if (!result) { flint_printf("FAIL:\n"); fmpq_poly_debug(a), flint_printf("\n\n"); fmpq_poly_debug(b), flint_printf("\n\n"); fmpq_poly_debug(c), flint_printf("\n\n"); flint_printf("cflags = %wu\n\n", cflags); abort(); } fmpq_poly_clear(a); fmpq_poly_clear(b); fmpq_poly_clear(c); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int i, result; FLINT_TEST_INIT(state); flint_printf("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 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 i, result; FLINT_TEST_INIT(state); flint_printf("revert_series_lagrange_fast...."); fflush(stdout); /* Check aliasing */ for (i = 0; i < 10 * flint_test_multiplier(); i++) { fmpz_poly_t f, g; slong n; fmpz_poly_init(f); fmpz_poly_init(g); fmpz_poly_randtest(g, state, n_randint(state, 50), 1+n_randint(state,100)); fmpz_poly_set_coeff_ui(g, 0, 0); fmpz_poly_set_coeff_ui(g, 1, 1); if (n_randlimb(state) % 2) fmpz_poly_neg(g, g); /* get -x term */ n = n_randint(state, 50); fmpz_poly_revert_series_lagrange_fast(f, g, n); fmpz_poly_revert_series_lagrange_fast(g, g, n); result = (fmpz_poly_equal(f, g)); if (!result) { flint_printf("FAIL (aliasing):\n"); fmpz_poly_print(f), flint_printf("\n\n"); fmpz_poly_print(g), flint_printf("\n\n"); abort(); } fmpz_poly_clear(f); fmpz_poly_clear(g); } /* Check f(f^(-1)) = id */ for (i = 0; i < 10 * flint_test_multiplier(); i++) { fmpz_poly_t f, g, h; slong n; fmpz_poly_init(f); fmpz_poly_init(g); fmpz_poly_init(h); fmpz_poly_randtest(g, state, n_randint(state, 50), 1+n_randint(state,100)); fmpz_poly_set_coeff_ui(g, 0, 0); fmpz_poly_set_coeff_ui(g, 1, 1); if (n_randlimb(state) % 2) fmpz_poly_neg(g, g); /* get -x term */ n = n_randint(state, 50); fmpz_poly_revert_series_lagrange_fast(f, g, n); fmpz_poly_compose_series(h, g, f, n); result = ((n <= 1 && fmpz_poly_is_zero(h)) || (h->length == 2 && fmpz_is_zero(h->coeffs + 0) && fmpz_is_one(h->coeffs + 1))); if (!result) { flint_printf("FAIL (comparison):\n"); fmpz_poly_print(f), flint_printf("\n\n"); fmpz_poly_print(g), flint_printf("\n\n"); fmpz_poly_print(h), flint_printf("\n\n"); abort(); } fmpz_poly_clear(f); fmpz_poly_clear(g); fmpz_poly_clear(h); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main() { slong iter; flint_rand_t state; flint_printf("union...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 100000; iter++) { fmprb_t x, y, z; slong prec; int alias; fmprb_init(x); fmprb_init(y); fmprb_init(z); fmprb_randtest_special(x, state, 200, 10); fmprb_randtest_special(y, state, 200, 10); fmprb_randtest_special(z, state, 200, 10); prec = 2 + n_randint(state, 200); fmprb_union(z, x, y, prec); if (!fmprb_contains(z, x) || !fmprb_contains(z, y)) { flint_printf("FAIL:\n\n"); flint_printf("x = "); fmprb_print(x); flint_printf("\n\n"); flint_printf("y = "); fmprb_print(y); flint_printf("\n\n"); flint_printf("z = "); fmprb_print(z); flint_printf("\n\n"); abort(); } if (n_randint(state, 2)) { fmprb_union(x, x, y, prec); alias = fmprb_equal(x, z); } else { fmprb_union(y, x, y, prec); alias = fmprb_equal(y, z); } if (!alias) { flint_printf("FAIL (aliasing):\n\n"); flint_printf("x = "); fmprb_print(x); flint_printf("\n\n"); flint_printf("y = "); fmprb_print(y); flint_printf("\n\n"); flint_printf("z = "); fmprb_print(z); flint_printf("\n\n"); abort(); } fmprb_clear(x); fmprb_clear(y); fmprb_clear(z); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("sqrt_series...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 5000; iter++) { slong m, n, qbits, rbits1, rbits2; fmpq_poly_t A; acb_poly_t a, b, c; qbits = 2 + n_randint(state, 200); rbits1 = 2 + n_randint(state, 200); rbits2 = 2 + n_randint(state, 200); m = 1 + n_randint(state, 30); n = 1 + n_randint(state, 30); fmpq_poly_init(A); acb_poly_init(a); acb_poly_init(b); acb_poly_init(c); fmpq_poly_randtest_not_zero(A, state, m, qbits); acb_poly_set_fmpq_poly(a, A, rbits1); acb_poly_sqrt_series(b, a, n, rbits2); /* Check sqrt(a)^2 = a */ acb_poly_mullow(c, b, b, n, rbits2); fmpq_poly_truncate(A, n); if (!acb_poly_contains_fmpq_poly(c, A)) { flint_printf("FAIL\n\n"); flint_printf("bits2 = %wd\n", rbits2); flint_printf("A = "); fmpq_poly_print(A); flint_printf("\n\n"); flint_printf("a = "); acb_poly_printd(a, 15); flint_printf("\n\n"); flint_printf("b = "); acb_poly_printd(b, 15); flint_printf("\n\n"); flint_printf("c = "); acb_poly_printd(c, 15); flint_printf("\n\n"); abort(); } acb_poly_sqrt_series(a, a, n, rbits2); if (!acb_poly_equal(a, b)) { flint_printf("FAIL (aliasing)\n\n"); abort(); } fmpq_poly_clear(A); acb_poly_clear(a); acb_poly_clear(b); acb_poly_clear(c); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("interpolate_barycentric...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { slong i, n, qbits1, qbits2, rbits1, rbits2, rbits3; fmpq_poly_t P; arb_poly_t R, S; fmpq_t t, u; arb_ptr xs, ys; fmpq_poly_init(P); arb_poly_init(R); arb_poly_init(S); fmpq_init(t); fmpq_init(u); qbits1 = 2 + n_randint(state, 200); qbits2 = 2 + n_randint(state, 5); rbits1 = 2 + n_randint(state, 200); rbits2 = 2 + n_randint(state, 200); rbits3 = 2 + n_randint(state, 200); fmpq_poly_randtest(P, state, 1 + n_randint(state, 20), qbits1); n = P->length; xs = _arb_vec_init(n); ys = _arb_vec_init(n); arb_poly_set_fmpq_poly(R, P, rbits1); if (n > 0) { fmpq_randtest(t, state, qbits2); arb_set_fmpq(xs, t, rbits2); for (i = 1; i < n; i++) { fmpq_randtest_not_zero(u, state, qbits2); fmpq_abs(u, u); fmpq_add(t, t, u); arb_set_fmpq(xs + i, t, rbits2); } } for (i = 0; i < n; i++) arb_poly_evaluate(ys + i, R, xs + i, rbits2); arb_poly_interpolate_barycentric(S, xs, ys, n, rbits3); if (!arb_poly_contains_fmpq_poly(S, P)) { flint_printf("FAIL:\n"); flint_printf("P = "); fmpq_poly_print(P); flint_printf("\n\n"); flint_printf("R = "); arb_poly_printd(R, 15); flint_printf("\n\n"); flint_printf("S = "); arb_poly_printd(S, 15); flint_printf("\n\n"); flint_abort(); } fmpq_poly_clear(P); arb_poly_clear(R); arb_poly_clear(S); fmpq_clear(t); fmpq_clear(u); _arb_vec_clear(xs, n); _arb_vec_clear(ys, n); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main(void) { int iter; flint_rand_t state; flint_printf("set_trunc_round...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++) { arb_poly_t a, b, c, d, e; slong n, prec; arb_poly_init(a); arb_poly_init(b); arb_poly_init(c); arb_poly_init(d); arb_poly_init(e); arb_poly_randtest(a, state, n_randint(state, 10), 2 + n_randint(state, 200), 10); arb_poly_randtest(b, state, n_randint(state, 10), 2 + n_randint(state, 200), 10); arb_poly_randtest(c, state, n_randint(state, 10), 2 + n_randint(state, 200), 10); arb_poly_randtest(d, state, n_randint(state, 10), 2 + n_randint(state, 200), 10); arb_poly_randtest(e, state, n_randint(state, 10), 2 + n_randint(state, 200), 10); n = n_randint(state, 10); prec = 2 + n_randint(state, 200); arb_poly_set_trunc(b, a, n); arb_poly_set_round(b, b, prec); arb_poly_set_round(c, a, prec); arb_poly_set_trunc(c, c, n); arb_poly_set_trunc_round(d, a, n, prec); arb_poly_set(e, a); arb_poly_set_trunc_round(e, e, n, prec); if (!arb_poly_equal(b, c) || !arb_poly_equal(c, d) || !arb_poly_equal(d, e)) { flint_printf("FAIL\n\n"); arb_poly_printd(a, 50), flint_printf("\n\n"); arb_poly_printd(b, 50), flint_printf("\n\n"); arb_poly_printd(c, 50), flint_printf("\n\n"); arb_poly_printd(d, 50), flint_printf("\n\n"); arb_poly_printd(e, 50), flint_printf("\n\n"); flint_abort(); } arb_poly_clear(a); arb_poly_clear(b); arb_poly_clear(c); arb_poly_clear(d); arb_poly_clear(e); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return 0; }
int main() { slong iter; flint_rand_t state; flint_printf("dlog...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 1000; iter++) { dlog_table_t table; dlog_bsgs_t bsgs; dlog_crt_t crt; dlog_precomp_t pre1, pre100; ulong p, a, k; nmod_t modp; if (iter < 10) p = n_nth_prime(iter + 2); else p = n_randprime(state, 15, 0); nmod_init(&modp, p); a = n_primitive_root_prime(p); dlog_table_init(table, a, p); dlog_bsgs_init(bsgs, a, p, p-1, dlog_bsgs_size(p, 1)); dlog_crt_init(crt, a, p, p-1, 10); dlog_precomp_n_init(pre1, a, p, p-1, 1); dlog_precomp_n_init(pre100, a, p, p-1, 100); for (k = 1; k < 100 && k < p; k++) { ulong l0, l1, l2, l3, l4, l5; l1 = dlog_table(table, k); l2 = dlog_bsgs(bsgs, k); l3 = dlog_crt(crt, k); l4 = dlog_precomp(pre1, k); l5 = dlog_precomp(pre100, k); if (iter < 50 && k <= 7) l0 = dlog_once(k, a, modp, p-1); else l0 = l1; if (l0 != l1 || l1 != l2 || l1 != l3 || l1 != l4 || l1 != l5) { flint_printf("\n\nFAIL: log(%wu,%wu) mod %wu\n\n",k,a,p); flint_printf("once: %wu\ntable: %wu\nbsgs: %wu\ncrt: %wu\nprecomp1: %wu\nprecomp100: %wu\n\n", l0, l1, l2, l3, l4, l5); abort(); } } dlog_table_clear(table); dlog_bsgs_clear(bsgs); dlog_crt_clear(crt); dlog_precomp_clear(pre1); dlog_precomp_clear(pre100); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("exp_pi_i...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { acb_t a, b, c, d; slong prec; acb_init(a); acb_init(b); acb_init(c); acb_init(d); acb_randtest(a, state, 1 + n_randint(state, 200), 3); acb_randtest(b, state, 1 + n_randint(state, 200), 3); acb_randtest(c, state, 1 + n_randint(state, 200), 3); acb_randtest(d, state, 1 + n_randint(state, 200), 3); prec = 2 + n_randint(state, 200); acb_exp_pi_i(b, a, prec); acb_const_pi(c, prec); acb_mul(c, c, a, prec); acb_mul_onei(c, c); acb_exp(d, c, prec); if (!acb_overlaps(d, b)) { flint_printf("FAIL: overlap\n\n"); flint_printf("a = "); acb_printd(a, 30); flint_printf("\n\n"); flint_printf("b = "); acb_printd(b, 30); flint_printf("\n\n"); flint_printf("c = "); acb_printd(c, 30); flint_printf("\n\n"); flint_printf("d = "); acb_printd(d, 30); flint_printf("\n\n"); abort(); } acb_set(c, a); acb_exp_pi_i(c, c, prec); if (!acb_overlaps(c, d)) { flint_printf("FAIL: aliasing\n\n"); flint_printf("a = "); acb_print(a); flint_printf("\n\n"); flint_printf("b = "); acb_print(b); flint_printf("\n\n"); flint_printf("c = "); acb_print(c); flint_printf("\n\n"); flint_printf("d = "); acb_print(d); flint_printf("\n\n"); abort(); } acb_clear(a); acb_clear(b); acb_clear(c); acb_clear(d); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("div...."); fflush(stdout); flint_randinit(state); /* test aliasing of c and a */ for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++) { acb_t a, b, c; slong prec; acb_init(a); acb_init(b); acb_init(c); acb_randtest(a, state, 1 + n_randint(state, 200), 10); acb_randtest(b, state, 1 + n_randint(state, 200), 10); acb_randtest(c, state, 1 + n_randint(state, 200), 10); prec = 2 + n_randint(state, 200); acb_div(c, a, b, prec); acb_div(a, a, b, prec); if (!acb_equal(a, c)) { flint_printf("FAIL: aliasing c, a\n\n"); flint_printf("a = "); acb_print(a); flint_printf("\n\n"); flint_printf("b = "); acb_print(b); flint_printf("\n\n"); flint_printf("c = "); acb_print(c); flint_printf("\n\n"); flint_abort(); } acb_clear(a); acb_clear(b); acb_clear(c); } /* test aliasing of c and b */ for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++) { acb_t a, b, c; slong prec; acb_init(a); acb_init(b); acb_init(c); acb_randtest(a, state, 1 + n_randint(state, 200), 10); acb_randtest(b, state, 1 + n_randint(state, 200), 10); acb_randtest(c, state, 1 + n_randint(state, 200), 10); prec = 2 + n_randint(state, 200); acb_div(c, a, b, prec); acb_div(b, a, b, prec); if (!acb_equal(b, c)) { flint_printf("FAIL: aliasing c, b\n\n"); flint_printf("a = "); acb_print(a); flint_printf("\n\n"); flint_printf("b = "); acb_print(b); flint_printf("\n\n"); flint_printf("c = "); acb_print(c); flint_printf("\n\n"); flint_abort(); } acb_clear(a); acb_clear(b); acb_clear(c); } /* test aliasing a, a */ for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++) { acb_t a, b, c, d; slong prec; acb_init(a); acb_init(b); acb_init(c); acb_init(d); acb_randtest(a, state, 1 + n_randint(state, 200), 10); acb_randtest(b, state, 1 + n_randint(state, 200), 10); acb_randtest(c, state, 1 + n_randint(state, 200), 10); prec = 2 + n_randint(state, 200); acb_set(b, a); acb_div(c, a, a, prec); acb_div(d, a, b, prec); if (!acb_overlaps(c, d)) { flint_printf("FAIL: aliasing a, a\n\n"); flint_printf("a = "); acb_print(a); flint_printf("\n\n"); flint_printf("b = "); acb_print(b); flint_printf("\n\n"); flint_printf("c = "); acb_print(c); flint_printf("\n\n"); flint_printf("d = "); acb_print(d); flint_printf("\n\n"); flint_abort(); } acb_clear(a); acb_clear(b); acb_clear(c); acb_clear(d); } /* test aliasing a, a, a */ for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++) { acb_t a, b, c; slong prec; acb_init(a); acb_init(b); acb_init(c); acb_randtest(a, state, 1 + n_randint(state, 200), 10); acb_randtest(b, state, 1 + n_randint(state, 200), 10); acb_randtest(c, state, 1 + n_randint(state, 200), 10); prec = 2 + n_randint(state, 200); acb_set(b, a); acb_div(c, a, b, prec); acb_div(a, a, a, prec); if (!acb_overlaps(a, c)) { flint_printf("FAIL: aliasing a, a, a\n\n"); flint_printf("a = "); acb_print(a); flint_printf("\n\n"); flint_printf("b = "); acb_print(b); flint_printf("\n\n"); flint_printf("c = "); acb_print(c); flint_printf("\n\n"); flint_abort(); } acb_clear(a); acb_clear(b); acb_clear(c); } /* test (a+b)/c = a/c + b/c */ for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++) { acb_t a, b, c, d, e, f; acb_init(a); acb_init(b); acb_init(c); acb_init(d); acb_init(e); acb_init(f); acb_randtest(a, state, 1 + n_randint(state, 200), 10); acb_randtest(b, state, 1 + n_randint(state, 200), 10); acb_randtest(c, state, 1 + n_randint(state, 200), 10); acb_add(d, a, b, 2 + n_randint(state, 200)); acb_div(e, d, c, 2 + n_randint(state, 200)); acb_div(d, a, c, 2 + n_randint(state, 200)); acb_div(f, b, c, 2 + n_randint(state, 200)); acb_add(f, d, f, 2 + n_randint(state, 200)); if (!acb_overlaps(e, f)) { flint_printf("FAIL: (a+b)/c = a/c + b/c\n\n"); flint_printf("a = "); acb_print(a); flint_printf("\n\n"); flint_printf("b = "); acb_print(b); flint_printf("\n\n"); flint_printf("c = "); acb_print(c); flint_printf("\n\n"); flint_printf("e = "); acb_print(e); flint_printf("\n\n"); flint_printf("f = "); acb_print(f); flint_printf("\n\n"); flint_abort(); } acb_clear(a); acb_clear(b); acb_clear(c); acb_clear(d); acb_clear(e); acb_clear(f); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("rsqrt...."); fflush(stdout); flint_randinit(state); /* check (a^(-1/2))^(-2) = a */ for (iter = 0; iter < 10000; iter++) { acb_t a, b, c; slong prec; acb_init(a); acb_init(b); acb_init(c); acb_randtest(a, state, 1 + n_randint(state, 2000), 10); acb_randtest(b, state, 1 + n_randint(state, 2000), 10); prec = 2 + n_randint(state, 2000); acb_rsqrt(b, a, prec); acb_inv(c, b, prec); acb_mul(c, c, c, prec); if (!acb_contains(c, a)) { flint_printf("FAIL: containment\n\n"); flint_printf("a = "); acb_print(a); flint_printf("\n\n"); flint_printf("b = "); acb_print(b); flint_printf("\n\n"); flint_printf("c = "); acb_print(c); flint_printf("\n\n"); abort(); } acb_rsqrt(a, a, prec); if (!acb_equal(a, b)) { flint_printf("FAIL: aliasing\n\n"); flint_printf("a = "); acb_print(a); flint_printf("\n\n"); flint_printf("b = "); acb_print(b); flint_printf("\n\n"); abort(); } acb_clear(a); acb_clear(b); acb_clear(c); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("spd_solve...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { fmpq_mat_t Q, QX, QB; arb_mat_t A, X, B; slong n, m, qbits, prec; int q_invertible, r_invertible, r_invertible2; n = n_randint(state, 8); m = n_randint(state, 8); qbits = 1 + n_randint(state, 30); prec = 2 + n_randint(state, 200); fmpq_mat_init(Q, n, n); fmpq_mat_init(QX, n, m); fmpq_mat_init(QB, n, m); arb_mat_init(A, n, n); arb_mat_init(X, n, m); arb_mat_init(B, n, m); _fmpq_mat_randtest_positive_semidefinite(Q, state, qbits); fmpq_mat_randtest(QB, state, qbits); q_invertible = fmpq_mat_solve_fraction_free(QX, Q, QB); if (!q_invertible) { arb_mat_set_fmpq_mat(A, Q, prec); r_invertible = arb_mat_spd_solve(X, A, B, prec); if (r_invertible) { flint_printf("FAIL: matrix is singular over Q but not over R\n"); flint_printf("n = %wd, prec = %wd\n", n, prec); flint_printf("\n"); flint_printf("Q = \n"); fmpq_mat_print(Q); flint_printf("\n\n"); flint_printf("QX = \n"); fmpq_mat_print(QX); flint_printf("\n\n"); flint_printf("QB = \n"); fmpq_mat_print(QB); flint_printf("\n\n"); flint_printf("A = \n"); arb_mat_printd(A, 15); flint_printf("\n\n"); flint_abort(); } } else { /* now this must converge */ while (1) { arb_mat_set_fmpq_mat(A, Q, prec); arb_mat_set_fmpq_mat(B, QB, prec); r_invertible = arb_mat_spd_solve(X, A, B, prec); if (r_invertible) { break; } else { if (prec > 10000) { flint_printf("FAIL: failed to converge at 10000 bits\n"); flint_printf("Q = \n"); fmpq_mat_print(Q); flint_printf("\n\n"); flint_printf("QX = \n"); fmpq_mat_print(QX); flint_printf("\n\n"); flint_printf("QB = \n"); fmpq_mat_print(QB); flint_printf("\n\n"); flint_printf("A = \n"); arb_mat_printd(A, 15); flint_printf("\n\n"); flint_abort(); } prec *= 2; } } if (!arb_mat_contains_fmpq_mat(X, QX)) { flint_printf("FAIL (containment, iter = %wd)\n", iter); flint_printf("n = %wd, prec = %wd\n", n, prec); flint_printf("\n"); flint_printf("Q = \n"); fmpq_mat_print(Q); flint_printf("\n\n"); flint_printf("QB = \n"); fmpq_mat_print(QB); flint_printf("\n\n"); flint_printf("QX = \n"); fmpq_mat_print(QX); flint_printf("\n\n"); flint_printf("A = \n"); arb_mat_printd(A, 15); flint_printf("\n\n"); flint_printf("B = \n"); arb_mat_printd(B, 15); flint_printf("\n\n"); flint_printf("X = \n"); arb_mat_printd(X, 15); flint_printf("\n\n"); flint_abort(); } /* test aliasing */ r_invertible2 = arb_mat_spd_solve(B, A, B, prec); if (!arb_mat_equal(X, B) || r_invertible != r_invertible2) { flint_printf("FAIL (aliasing)\n"); flint_printf("A = \n"); arb_mat_printd(A, 15); flint_printf("\n\n"); flint_printf("B = \n"); arb_mat_printd(B, 15); flint_printf("\n\n"); flint_printf("X = \n"); arb_mat_printd(X, 15); flint_printf("\n\n"); flint_abort(); } } fmpq_mat_clear(Q); fmpq_mat_clear(QB); fmpq_mat_clear(QX); arb_mat_clear(A); arb_mat_clear(B); arb_mat_clear(X); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("erfc...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { acb_t a, b, c; slong prec1, prec2, prec3, prec4; prec1 = 2 + n_randint(state, 1000); prec2 = 2 + n_randint(state, 1000); prec3 = 2 + n_randint(state, 1000); prec4 = 2 + n_randint(state, 1000); acb_init(a); acb_init(b); acb_init(c); acb_randtest_special(a, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100)); acb_randtest_special(b, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100)); acb_randtest_special(c, state, 1 + n_randint(state, 1000), 1 + n_randint(state, 100)); switch (n_randint(state, 4)) { case 0: acb_hypgeom_erf_asymp(b, a, 1, prec1, prec3); break; case 1: acb_hypgeom_erf(b, a, prec1); acb_sub_ui(b, b, 1, prec1); acb_neg(b, b); break; default: acb_hypgeom_erfc(b, a, prec1); } switch (n_randint(state, 4)) { case 0: acb_hypgeom_erf_asymp(c, a, 1, prec2, prec4); break; case 1: acb_hypgeom_erf(c, a, prec2); acb_sub_ui(c, c, 1, prec2); acb_neg(c, c); break; default: acb_hypgeom_erfc(c, a, prec2); } if (!acb_overlaps(b, c)) { flint_printf("FAIL: overlap\n\n"); flint_printf("a = "); acb_printd(a, 30); flint_printf("\n\n"); flint_printf("b = "); acb_printd(b, 30); flint_printf("\n\n"); flint_printf("c = "); acb_printd(c, 30); flint_printf("\n\n"); abort(); } acb_clear(a); acb_clear(b); acb_clear(c); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("integrate_taylor...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 150 * arb_test_multiplier(); iter++) { acb_t ans, res, a, b; arf_t inr, outr; double t; slong goal, prec; acb_init(ans); acb_init(res); acb_init(a); acb_init(b); arf_init(inr); arf_init(outr); goal = 2 + n_randint(state, 300); prec = 2 + n_randint(state, 300); acb_randtest(a, state, 1 + n_randint(state, 200), 2); acb_randtest(b, state, 1 + n_randint(state, 200), 2); acb_cos(ans, a, prec); acb_cos(res, b, prec); acb_sub(ans, ans, res, prec); t = (1 + n_randint(state, 20)) / 10.0; arf_set_d(inr, t); arf_set_d(outr, t + (1 + n_randint(state, 20)) / 5.0); acb_calc_integrate_taylor(res, sin_x, NULL, a, b, inr, outr, goal, prec); if (!acb_overlaps(res, ans)) { flint_printf("FAIL! (iter = %wd)\n", iter); flint_printf("prec = %wd, goal = %wd\n", prec, goal); flint_printf("inr = "); arf_printd(inr, 15); flint_printf("\n"); flint_printf("outr = "); arf_printd(outr, 15); flint_printf("\n"); flint_printf("a = "); acb_printd(a, 15); flint_printf("\n"); flint_printf("b = "); acb_printd(b, 15); flint_printf("\n"); flint_printf("res = "); acb_printd(res, 15); flint_printf("\n\n"); flint_printf("ans = "); acb_printd(ans, 15); flint_printf("\n\n"); abort(); } acb_clear(ans); acb_clear(res); acb_clear(a); acb_clear(b); arf_clear(inr); arf_clear(outr); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
/* Given T(K), compute bound for T(n) z^n. We need to multiply by z^n * 1/rf(K+1,m)^r * (rf(K+1,m)/rf(K+1-A,m)) * (rf(K+1-B,m)/rf(K+1-2B,m)) where m = n - K. This is equal to z^n * (K+A)! (K-2B)! (K-B+m)! ----------------------- * ((K+m)! / K!)^(1-r) (K-B)! (K-A+m)! (K-2B+m)! */ void hypgeom_term_bound(mag_t Tn, const mag_t TK, slong K, slong A, slong B, int r, const mag_t z, slong n) { mag_t t, u, num; slong m; mag_init(t); mag_init(u); mag_init(num); m = n - K; if (m < 0) { flint_printf("hypgeom term bound\n"); abort(); } /* TK * z^n */ mag_pow_ui(t, z, n); mag_mul(num, TK, t); /* numerator: (K+A)! (K-2B)! (K-B+m)! */ mag_fac_ui(t, K+A); mag_mul(num, num, t); mag_fac_ui(t, K-2*B); mag_mul(num, num, t); mag_fac_ui(t, K-B+m); mag_mul(num, num, t); /* denominator: (K-B)! (K-A+m)! (K-2B+m)! */ mag_rfac_ui(t, K-B); mag_mul(num, num, t); mag_rfac_ui(t, K-A+m); mag_mul(num, num, t); mag_rfac_ui(t, K-2*B+m); mag_mul(num, num, t); /* ((K+m)! / K!)^(1-r) */ if (r == 0) { mag_fac_ui(t, K+m); mag_mul(num, num, t); mag_rfac_ui(t, K); mag_mul(num, num, t); } else if (r != 1) { mag_fac_ui(t, K); mag_rfac_ui(u, K+m); mag_mul(t, t, u); mag_pow_ui(t, t, r-1); mag_mul(num, num, t); } mag_set(Tn, num); mag_clear(t); mag_clear(u); mag_clear(num); }
int main() { slong iter; flint_rand_t state; flint_printf("mul_fmpz...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { arb_t a, b, c, d; fmpz_t x; slong 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_mul_fmpz(c, a, x, prec); arb_mul(d, a, b, prec); if (!arb_equal(c, d)) { flint_printf("FAIL\n\n"); flint_printf("a = "); arb_print(a); flint_printf("\n\n"); flint_printf("b = "); arb_print(b); flint_printf("\n\n"); flint_printf("c = "); arb_print(c); flint_printf("\n\n"); flint_printf("d = "); arb_print(d); flint_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 * arb_test_multiplier(); iter++) { arb_t a, b, c; fmpz_t x; slong 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_mul_fmpz(c, a, x, prec); arb_mul_fmpz(a, a, x, prec); if (!arb_equal(a, c)) { flint_printf("FAIL (aliasing)\n\n"); flint_printf("a = "); arb_print(a); flint_printf("\n\n"); flint_printf("b = "); arb_print(b); flint_printf("\n\n"); flint_printf("c = "); arb_print(c); flint_printf("\n\n"); abort(); } arb_clear(a); arb_clear(b); arb_clear(c); fmpz_clear(x); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("get_interval_arf...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++) { arb_t x, y; arf_t a, b; arb_init(x); arf_init(a); arf_init(b); arb_init(y); arb_randtest_special(x, state, 200, 100); arb_get_interval_arf(a, b, x, 2 + n_randint(state, 200)); arb_set_interval_arf(y, a, b, 2 + n_randint(state, 200)); if (!arb_contains(y, x)) { flint_printf("FAIL:\n\n"); flint_printf("x = "); arb_print(x); flint_printf("\n\n"); flint_printf("a = "); arf_print(a); flint_printf("\n\n"); flint_printf("b = "); arf_print(b); flint_printf("\n\n"); flint_printf("y = "); arb_print(y); flint_printf("\n\n"); abort(); } arb_clear(x); arf_clear(a); arf_clear(b); arb_clear(y); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong i; mpfr_t tabx, logx, y1, y2; mpz_t tt; flint_printf("log_tab...."); fflush(stdout); { slong prec, bits, num; prec = ARB_LOG_TAB1_LIMBS * FLINT_BITS; bits = ARB_LOG_TAB11_BITS; num = 1 << ARB_LOG_TAB11_BITS; mpfr_init2(tabx, prec); mpfr_init2(logx, prec); mpfr_init2(y1, prec); mpfr_init2(y2, prec); for (i = 0; i < num; i++) { tt->_mp_d = (mp_ptr) arb_log_tab11[i]; tt->_mp_size = prec / FLINT_BITS; tt->_mp_alloc = tt->_mp_size; while (tt->_mp_size > 0 && tt->_mp_d[tt->_mp_size-1] == 0) tt->_mp_size--; mpfr_set_z(tabx, tt, MPFR_RNDD); mpfr_div_2ui(tabx, tabx, prec, MPFR_RNDD); mpfr_set_ui(logx, i, MPFR_RNDD); mpfr_div_2ui(logx, logx, bits, MPFR_RNDD); mpfr_add_ui(logx, logx, 1, MPFR_RNDD); mpfr_log(logx, logx, MPFR_RNDD); mpfr_mul_2ui(y1, tabx, prec, MPFR_RNDD); mpfr_floor(y1, y1); mpfr_div_2ui(y1, y1, prec, MPFR_RNDD); mpfr_mul_2ui(y2, logx, prec, MPFR_RNDD); mpfr_floor(y2, y2); mpfr_div_2ui(y2, y2, prec, MPFR_RNDD); if (!mpfr_equal_p(y1, y2)) { flint_printf("FAIL: i = %wd, bits = %wd, prec = %wd\n", i, bits, prec); mpfr_printf("y1 = %.1500Rg\n", y1); mpfr_printf("y2 = %.1500Rg\n", y2); flint_abort(); } } mpfr_clear(tabx); mpfr_clear(logx); mpfr_clear(y1); mpfr_clear(y2); } { slong prec, bits, num; prec = ARB_LOG_TAB1_LIMBS * FLINT_BITS; bits = ARB_LOG_TAB11_BITS + ARB_LOG_TAB12_BITS; num = 1 << ARB_LOG_TAB12_BITS; mpfr_init2(tabx, prec); mpfr_init2(logx, prec); mpfr_init2(y1, prec); mpfr_init2(y2, prec); for (i = 0; i < num; i++) { tt->_mp_d = (mp_ptr) arb_log_tab12[i]; tt->_mp_size = prec / FLINT_BITS; tt->_mp_alloc = tt->_mp_size; while (tt->_mp_size > 0 && tt->_mp_d[tt->_mp_size-1] == 0) tt->_mp_size--; mpfr_set_z(tabx, tt, MPFR_RNDD); mpfr_div_2ui(tabx, tabx, prec, MPFR_RNDD); mpfr_set_ui(logx, i, MPFR_RNDD); mpfr_div_2ui(logx, logx, bits, MPFR_RNDD); mpfr_add_ui(logx, logx, 1, MPFR_RNDD); mpfr_log(logx, logx, MPFR_RNDD); mpfr_mul_2ui(y1, tabx, prec, MPFR_RNDD); mpfr_floor(y1, y1); mpfr_div_2ui(y1, y1, prec, MPFR_RNDD); mpfr_mul_2ui(y2, logx, prec, MPFR_RNDD); mpfr_floor(y2, y2); mpfr_div_2ui(y2, y2, prec, MPFR_RNDD); if (!mpfr_equal_p(y1, y2)) { flint_printf("FAIL: i = %wd, bits = %wd, prec = %wd\n", i, bits, prec); mpfr_printf("y1 = %.1500Rg\n", y1); mpfr_printf("y2 = %.1500Rg\n", y2); flint_abort(); } } mpfr_clear(tabx); mpfr_clear(logx); mpfr_clear(y1); mpfr_clear(y2); } { slong prec, bits, num; prec = ARB_LOG_TAB2_LIMBS * FLINT_BITS; bits = ARB_LOG_TAB21_BITS; num = 1 << ARB_LOG_TAB21_BITS; mpfr_init2(tabx, prec); mpfr_init2(logx, prec); mpfr_init2(y1, prec); mpfr_init2(y2, prec); for (i = 0; i < num; i++) { tt->_mp_d = (mp_ptr) arb_log_tab21[i]; tt->_mp_size = prec / FLINT_BITS; tt->_mp_alloc = tt->_mp_size; while (tt->_mp_size > 0 && tt->_mp_d[tt->_mp_size-1] == 0) tt->_mp_size--; mpfr_set_z(tabx, tt, MPFR_RNDD); mpfr_div_2ui(tabx, tabx, prec, MPFR_RNDD); mpfr_set_ui(logx, i, MPFR_RNDD); mpfr_div_2ui(logx, logx, bits, MPFR_RNDD); mpfr_add_ui(logx, logx, 1, MPFR_RNDD); mpfr_log(logx, logx, MPFR_RNDD); mpfr_mul_2ui(y1, tabx, prec, MPFR_RNDD); mpfr_floor(y1, y1); mpfr_div_2ui(y1, y1, prec, MPFR_RNDD); mpfr_mul_2ui(y2, logx, prec, MPFR_RNDD); mpfr_floor(y2, y2); mpfr_div_2ui(y2, y2, prec, MPFR_RNDD); if (!mpfr_equal_p(y1, y2)) { flint_printf("FAIL: i = %wd, bits = %wd, prec = %wd\n", i, bits, prec); mpfr_printf("y1 = %.1500Rg\n", y1); mpfr_printf("y2 = %.1500Rg\n", y2); flint_abort(); } } mpfr_clear(tabx); mpfr_clear(logx); mpfr_clear(y1); mpfr_clear(y2); } { slong prec, bits, num; prec = ARB_LOG_TAB2_LIMBS * FLINT_BITS; bits = ARB_LOG_TAB21_BITS + ARB_LOG_TAB22_BITS; num = 1 << ARB_LOG_TAB22_BITS; mpfr_init2(tabx, prec); mpfr_init2(logx, prec); mpfr_init2(y1, prec); mpfr_init2(y2, prec); for (i = 0; i < num; i++) { tt->_mp_d = (mp_ptr) arb_log_tab22[i]; tt->_mp_size = prec / FLINT_BITS; tt->_mp_alloc = tt->_mp_size; while (tt->_mp_size > 0 && tt->_mp_d[tt->_mp_size-1] == 0) tt->_mp_size--; mpfr_set_z(tabx, tt, MPFR_RNDD); mpfr_div_2ui(tabx, tabx, prec, MPFR_RNDD); mpfr_set_ui(logx, i, MPFR_RNDD); mpfr_div_2ui(logx, logx, bits, MPFR_RNDD); mpfr_add_ui(logx, logx, 1, MPFR_RNDD); mpfr_log(logx, logx, MPFR_RNDD); mpfr_mul_2ui(y1, tabx, prec, MPFR_RNDD); mpfr_floor(y1, y1); mpfr_div_2ui(y1, y1, prec, MPFR_RNDD); mpfr_mul_2ui(y2, logx, prec, MPFR_RNDD); mpfr_floor(y2, y2); mpfr_div_2ui(y2, y2, prec, MPFR_RNDD); if (!mpfr_equal_p(y1, y2)) { flint_printf("FAIL: i = %wd, bits = %wd, prec = %wd\n", i, bits, prec); mpfr_printf("y1 = %.1500Rg\n", y1); mpfr_printf("y2 = %.1500Rg\n", y2); flint_abort(); } } mpfr_clear(tabx); mpfr_clear(logx); mpfr_clear(y1); mpfr_clear(y2); } flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
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; }
void _arb_sin_cos_taylor_rs(mp_ptr ysin, mp_ptr ycos, mp_limb_t * error, mp_srcptr x, mp_size_t xn, ulong N, int sinonly, int alternating) { mp_ptr s, t, xpow; mp_limb_t new_denom, old_denom, c; slong power, k, m; int cosorsin; TMP_INIT; TMP_START; if (2 * N >= FACTORIAL_TAB_SIZE - 1) { flint_printf("_arb_sin_cos_taylor_rs: N too large!\n"); abort(); } if (N <= 1) { if (N == 0) { flint_mpn_zero(ysin, xn); if (!sinonly) flint_mpn_zero(ycos, xn); error[0] = 0; } else if (N == 1) { flint_mpn_copyi(ysin, x, xn); if (!sinonly) flint_mpn_store(ycos, xn, LIMB_ONES); error[0] = 1; } } else { /* Choose m ~= sqrt(num_terms) (m must be even, >= 2) */ m = 2; while (m * m < N) m += 2; /* todo: merge allocations */ xpow = TMP_ALLOC_LIMBS((m + 1) * xn); s = TMP_ALLOC_LIMBS(xn + 2); t = TMP_ALLOC_LIMBS(2 * xn + 2); /* todo: 1 limb too much? */ /* higher index ---> */ /* | ---xn--- | */ /* xpow = | <temp> | x^m | x^(m-1) | ... | x^2 | x | */ #define XPOW_WRITE(__k) (xpow + (m - (__k)) * xn) #define XPOW_READ(__k) (xpow + (m - (__k) + 1) * xn) mpn_sqr(XPOW_WRITE(1), x, xn); mpn_sqr(XPOW_WRITE(2), XPOW_READ(1), xn); for (k = 4; k <= m; k += 2) { mpn_mul_n(XPOW_WRITE(k - 1), XPOW_READ(k / 2), XPOW_READ(k / 2 - 1), xn); mpn_sqr(XPOW_WRITE(k), XPOW_READ(k / 2), xn); } for (cosorsin = sinonly; cosorsin < 2; cosorsin++) { flint_mpn_zero(s, xn + 1); /* todo: skip one nonscalar multiplication (use x^m) when starting on x^0 */ power = (N - 1) % m; for (k = N - 1; k >= 0; k--) { c = factorial_tab_numer[2 * k + cosorsin]; new_denom = factorial_tab_denom[2 * k + cosorsin]; old_denom = factorial_tab_denom[2 * k + cosorsin + 2]; /* change denominators */ if (new_denom != old_denom && k < N - 1) { if (alternating && (k % 2 == 0)) s[xn] += old_denom; mpn_divrem_1(s, 0, s, xn + 1, old_denom); if (alternating && (k % 2 == 0)) s[xn] -= 1; } if (power == 0) { /* add c * x^0 -- only top limb is affected */ if (alternating & k) s[xn] -= c; else s[xn] += c; /* Outer polynomial evaluation: multiply by x^m */ if (k != 0) { mpn_mul(t, s, xn + 1, XPOW_READ(m), xn); flint_mpn_copyi(s, t + xn, xn + 1); } power = m - 1; } else { if (alternating & k) s[xn] -= mpn_submul_1(s, XPOW_READ(power), xn, c); else s[xn] += mpn_addmul_1(s, XPOW_READ(power), xn, c); power--; } } /* finally divide by denominator */ if (cosorsin == 0) { mpn_divrem_1(t, 0, s, xn + 1, factorial_tab_denom[0]); /* perturb down to a number < 1 if necessary. note that this does not invalidate the error bound: 1 - ulp is either 1 ulp too small or must be closer to the exact value */ if (t[xn] == 0) flint_mpn_copyi(ycos, t, xn); else flint_mpn_store(ycos, xn, LIMB_ONES); } else { mpn_divrem_1(s, 0, s, xn + 1, factorial_tab_denom[0]); mpn_mul(t, s, xn + 1, x, xn); flint_mpn_copyi(ysin, t + xn, xn); } } /* error bound (ulp) */ error[0] = 2; } TMP_END; }
int main() { slong iter; flint_rand_t state; flint_printf("agm...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++) { arb_t a, b, c; fmpq_t q, r; mpfr_t t, u; slong prec = 2 + n_randint(state, 200); arb_init(a); arb_init(b); arb_init(c); fmpq_init(q); fmpq_init(r); mpfr_init2(t, prec + 100); mpfr_init2(u, prec + 100); arb_randtest(a, state, 1 + n_randint(state, 200), 3); arb_randtest(b, state, 1 + n_randint(state, 200), 3); arb_randtest(c, state, 1 + n_randint(state, 200), 3); arb_agm(c, a, b, prec); if (arb_equal(a, b)) { if (!arb_contains(c, a)) { flint_printf("FAIL: containment (identity)\n\n"); flint_printf("a = "); arb_print(a); flint_printf("\n\n"); flint_printf("b = "); arb_print(b); flint_printf("\n\n"); flint_printf("c = "); arb_print(c); flint_printf("\n\n"); abort(); } } else { arb_get_rand_fmpq(q, state, a, 1 + n_randint(state, 200)); arb_get_rand_fmpq(r, state, b, 1 + n_randint(state, 200)); fmpq_get_mpfr(t, q, MPFR_RNDN); fmpq_get_mpfr(u, r, MPFR_RNDN); mpfr_agm(t, t, u, MPFR_RNDN); if (!arb_contains_mpfr(c, t)) { flint_printf("FAIL: containment\n\n"); flint_printf("a = "); arb_print(a); flint_printf("\n\n"); flint_printf("b = "); arb_print(b); flint_printf("\n\n"); flint_printf("c = "); arb_print(c); flint_printf("\n\n"); abort(); } } arb_clear(a); arb_clear(b); arb_clear(c); fmpq_clear(q); fmpq_clear(r); mpfr_clear(t); mpfr_clear(u); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("pow_ui...."); fflush(stdout); flint_randinit(state); /* compare with fmpz_poly */ for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { slong zbits1, rbits1, rbits2; ulong e; fmpz_poly_t A, B; arb_poly_t a, b; zbits1 = 2 + n_randint(state, 100); rbits1 = 2 + n_randint(state, 200); rbits2 = 2 + n_randint(state, 200); e = n_randint(state, 30); fmpz_poly_init(A); fmpz_poly_init(B); arb_poly_init(a); arb_poly_init(b); fmpz_poly_randtest(A, state, 1 + n_randint(state, 8), zbits1); fmpz_poly_pow(B, A, e); arb_poly_set_fmpz_poly(a, A, rbits1); arb_poly_pow_ui(b, a, e, rbits2); if (!arb_poly_contains_fmpz_poly(b, B)) { flint_printf("FAIL\n\n"); flint_printf("bits2 = %wd\n", rbits2); flint_printf("e = %wu\n", e); flint_printf("A = "); fmpz_poly_print(A); flint_printf("\n\n"); flint_printf("B = "); fmpz_poly_print(B); flint_printf("\n\n"); flint_printf("a = "); arb_poly_printd(a, 15); flint_printf("\n\n"); flint_printf("b = "); arb_poly_printd(b, 15); flint_printf("\n\n"); abort(); } arb_poly_pow_ui(a, a, e, rbits2); if (!arb_poly_equal(a, b)) { flint_printf("FAIL (aliasing)\n\n"); abort(); } fmpz_poly_clear(A); fmpz_poly_clear(B); arb_poly_clear(a); arb_poly_clear(b); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("mul...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++) { slong qbits1, qbits2, rbits1, rbits2, rbits3; fmpq_poly_t A, B, C; arb_poly_t a, b, c, d; qbits1 = 2 + n_randint(state, 200); qbits2 = 2 + n_randint(state, 200); rbits1 = 2 + n_randint(state, 200); rbits2 = 2 + n_randint(state, 200); rbits3 = 2 + n_randint(state, 200); fmpq_poly_init(A); fmpq_poly_init(B); fmpq_poly_init(C); arb_poly_init(a); arb_poly_init(b); arb_poly_init(c); arb_poly_init(d); fmpq_poly_randtest(A, state, 1 + n_randint(state, 10), qbits1); fmpq_poly_randtest(B, state, 1 + n_randint(state, 10), qbits2); fmpq_poly_mul(C, A, B); arb_poly_set_fmpq_poly(a, A, rbits1); arb_poly_set_fmpq_poly(b, B, rbits2); arb_poly_mul(c, a, b, rbits3); if (!arb_poly_contains_fmpq_poly(c, C)) { flint_printf("FAIL\n\n"); flint_printf("bits3 = %wd\n", rbits3); flint_printf("A = "); fmpq_poly_print(A); flint_printf("\n\n"); flint_printf("B = "); fmpq_poly_print(B); flint_printf("\n\n"); flint_printf("C = "); fmpq_poly_print(C); flint_printf("\n\n"); flint_printf("a = "); arb_poly_printd(a, 15); flint_printf("\n\n"); flint_printf("b = "); arb_poly_printd(b, 15); flint_printf("\n\n"); flint_printf("c = "); arb_poly_printd(c, 15); flint_printf("\n\n"); abort(); } arb_poly_set(d, a); arb_poly_mul(d, d, b, rbits3); if (!arb_poly_equal(d, c)) { flint_printf("FAIL (aliasing 1)\n\n"); abort(); } arb_poly_set(d, b); arb_poly_mul(d, a, d, rbits3); if (!arb_poly_equal(d, c)) { flint_printf("FAIL (aliasing 2)\n\n"); abort(); } /* test squaring */ arb_poly_set(b, a); arb_poly_mul(c, a, b, rbits3); arb_poly_mul(d, a, a, rbits3); if (!arb_poly_overlaps(c, d)) /* not guaranteed to be identical */ { flint_printf("FAIL (squaring)\n\n"); flint_printf("a = "); arb_poly_printd(a, 15); flint_printf("\n\n"); flint_printf("b = "); arb_poly_printd(b, 15); flint_printf("\n\n"); flint_printf("c = "); arb_poly_printd(c, 15); flint_printf("\n\n"); abort(); } arb_poly_mul(a, a, a, rbits3); if (!arb_poly_equal(d, a)) { flint_printf("FAIL (aliasing, squaring)\n\n"); flint_printf("a = "); arb_poly_printd(a, 15); flint_printf("\n\n"); flint_printf("b = "); arb_poly_printd(b, 15); flint_printf("\n\n"); flint_printf("d = "); arb_poly_printd(d, 15); flint_printf("\n\n"); abort(); } fmpq_poly_clear(A); fmpq_poly_clear(B); fmpq_poly_clear(C); arb_poly_clear(a); arb_poly_clear(b); arb_poly_clear(c); arb_poly_clear(d); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("exp_series_basecase...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { slong m, n, bits1, bits2, bits3; acb_poly_t a, b, c, d; bits1 = 2 + n_randint(state, 100); bits2 = 2 + n_randint(state, 100); bits3 = 2 + n_randint(state, 100); m = 1 + n_randint(state, 30); n = 1 + n_randint(state, 30); acb_poly_init(a); acb_poly_init(b); acb_poly_init(c); acb_poly_init(d); acb_poly_randtest(a, state, m, bits1, 5); acb_poly_randtest(b, state, m, bits1, 5); /* check exp(a+b) = exp(a) exp(b) */ acb_poly_exp_series_basecase(c, a, n, bits2); acb_poly_exp_series_basecase(d, b, n, bits2); acb_poly_mullow(c, c, d, n, bits2); acb_poly_add(d, a, b, bits3); acb_poly_exp_series_basecase(d, d, n, bits3); /* also aliasing test */ if (!acb_poly_overlaps(c, d)) { flint_printf("FAIL\n\n"); flint_printf("a = "); acb_poly_printd(a, 15); flint_printf("\n\n"); flint_printf("b = "); acb_poly_printd(b, 15); flint_printf("\n\n"); flint_printf("c = "); acb_poly_printd(c, 15); flint_printf("\n\n"); flint_printf("d = "); acb_poly_printd(d, 15); flint_printf("\n\n"); abort(); } acb_poly_clear(a); acb_poly_clear(b); acb_poly_clear(c); acb_poly_clear(d); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("solve_tril...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 2000 * arb_test_multiplier(); iter++) { arb_mat_t A, X, B, Y; slong rows, cols, prec, i, j; int unit; prec = 2 + n_randint(state, 200); if (n_randint(state, 10) == 0) { rows = n_randint(state, 60); cols = n_randint(state, 60); } else { rows = n_randint(state, 10); cols = n_randint(state, 10); } unit = n_randint(state, 2); arb_mat_init(A, rows, rows); arb_mat_init(B, rows, cols); arb_mat_init(X, rows, cols); arb_mat_init(Y, rows, cols); arb_mat_randtest(A, state, prec, 10); arb_mat_randtest(X, state, prec, 10); arb_mat_randtest(Y, state, prec, 10); for (i = 0; i < rows; i++) { if (unit) arb_one(arb_mat_entry(A, i, i)); else arb_set_ui(arb_mat_entry(A, i, i), 1 + n_randint(state, 100)); for (j = i + 1; j < rows; j++) arb_zero(arb_mat_entry(A, i, j)); } arb_mat_mul(B, A, X, prec); if (unit) /* check that diagonal entries are ignored */ { for (i = 0; i < rows; i++) arb_set_ui(arb_mat_entry(A, i, i), 1 + n_randint(state, 100)); } /* Check Y = A^(-1) * (A * X) = X */ arb_mat_solve_tril(Y, A, B, unit, prec); if (!arb_mat_overlaps(Y, X)) { flint_printf("FAIL\n"); flint_printf("A = \n"); arb_mat_printd(A, 10); flint_printf("\n\n"); flint_printf("B = \n"); arb_mat_printd(B, 10); flint_printf("\n\n"); flint_printf("X = \n"); arb_mat_printd(X, 10); flint_printf("\n\n"); flint_printf("Y = \n"); arb_mat_printd(Y, 10); flint_printf("\n\n"); flint_abort(); } /* Check aliasing */ arb_mat_solve_tril(B, A, B, unit, prec); if (!arb_mat_equal(B, Y)) { flint_printf("FAIL (aliasing)\n"); flint_printf("A = \n"); arb_mat_printd(A, 10); flint_printf("\n\n"); flint_printf("B = \n"); arb_mat_printd(B, 10); flint_printf("\n\n"); flint_printf("X = \n"); arb_mat_printd(X, 10); flint_printf("\n\n"); flint_printf("Y = \n"); arb_mat_printd(Y, 10); flint_printf("\n\n"); flint_abort(); } arb_mat_clear(A); arb_mat_clear(B); arb_mat_clear(X); arb_mat_clear(Y); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }