int main() { slong iter; flint_rand_t state; flint_printf("atan...."); fflush(stdout); flint_randinit(state); /* Compare with MPFR */ for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { arb_t a, b; fmpq_t q; mpfr_t t; slong prec = 2 + n_randint(state, 200); arb_init(a); arb_init(b); fmpq_init(q); mpfr_init2(t, prec + 100); arb_randtest(a, state, 1 + n_randint(state, 200), 3); arb_randtest(b, state, 1 + n_randint(state, 200), 3); arb_get_rand_fmpq(q, state, a, 1 + n_randint(state, 200)); fmpq_get_mpfr(t, q, MPFR_RNDN); mpfr_atan(t, t, MPFR_RNDN); arb_atan(b, a, prec); if (!arb_contains_mpfr(b, 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_abort(); } arb_atan(a, a, prec); if (!arb_equal(a, b)) { flint_printf("FAIL: aliasing\n\n"); flint_abort(); } arb_clear(a); arb_clear(b); fmpq_clear(q); mpfr_clear(t); } /* Check large arguments. */ for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { arb_t a, b, c, d; slong prec1, prec2; prec1 = 2 + n_randint(state, 1000); prec2 = prec1 + 30; arb_init(a); arb_init(b); arb_init(c); arb_init(d); arb_randtest_precise(a, state, 1 + n_randint(state, 1000), 100); arb_atan(b, a, prec1); arb_atan(c, a, prec2); if (!arb_overlaps(b, c)) { flint_printf("FAIL: overlap\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_abort(); } /* check tan(atan(x)) = x */ arb_sin_cos(c, d, b, prec1); arb_div(c, c, d, prec1); if (!arb_contains(c, a)) { flint_printf("FAIL: functional equation\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"); flint_abort(); } arb_clear(a); arb_clear(b); arb_clear(c); arb_clear(d); } /* Compare with MPFR, higher precision. */ for (iter = 0; iter < 200 * arb_test_multiplier(); iter++) { arb_t a, b; fmpq_t q; mpfr_t t; slong prec = 2 + n_randint(state, 5000); arb_init(a); arb_init(b); fmpq_init(q); mpfr_init2(t, prec + 100); arb_randtest(a, state, 1 + n_randint(state, 5000), 8); arb_randtest(b, state, 1 + n_randint(state, 5000), 8); arb_get_rand_fmpq(q, state, a, 1 + n_randint(state, 200)); fmpq_get_mpfr(t, q, MPFR_RNDN); mpfr_atan(t, t, MPFR_RNDN); arb_atan(b, a, prec); if (!arb_contains_mpfr(b, t)) { flint_printf("FAIL: containment\n\n"); flint_printf("a = "); arb_print(a); flint_printf("\n\n"); flint_printf("a = "); arb_printd(a, 50); flint_printf("\n\n"); flint_printf("a = "); arb_print(a); flint_printf("\n\n"); flint_printf("b = "); arb_printd(b, 50); flint_printf("\n\n"); flint_abort(); } arb_atan(a, a, prec); if (!arb_equal(a, b)) { flint_printf("FAIL: aliasing\n\n"); flint_abort(); } arb_clear(a); arb_clear(b); fmpq_clear(q); mpfr_clear(t); } /* Higher precision + large arguments. */ for (iter = 0; iter < 2000 * arb_test_multiplier(); iter++) { arb_t a, b, c, d; slong prec1, prec2; prec1 = 2 + n_randint(state, 5000); prec2 = prec1 + 30; arb_init(a); arb_init(b); arb_init(c); arb_init(d); arb_randtest_precise(a, state, 1 + n_randint(state, 5000), 100); arb_atan(b, a, prec1); arb_atan(c, a, prec2); if (!arb_overlaps(b, c)) { flint_printf("FAIL: overlap\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_abort(); } /* check tan(atan(x)) = x */ arb_sin_cos(c, d, b, prec1); arb_div(c, c, d, prec1); if (!arb_contains(c, a)) { flint_printf("FAIL: functional equation\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"); flint_abort(); } arb_clear(a); arb_clear(b); arb_clear(c); arb_clear(d); } /* Check wide arguments. */ for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++) { arb_t a, b, c, d; arb_init(a); arb_init(b); arb_init(c); arb_init(d); arb_randtest_precise(a, state, 1 + n_randint(state, 1000), 100); arb_randtest_precise(b, state, 1 + n_randint(state, 1000), 100); if (n_randint(state, 2)) arb_add(a, a, b, 2 + n_randint(state, 1000)); arb_union(d, a, b, 2 + n_randint(state, 1000)); arb_atan(a, a, 2 + n_randint(state, 2000)); arb_atan(b, b, 2 + n_randint(state, 2000)); arb_atan(c, d, 2 + n_randint(state, 2000)); if (!arb_overlaps(c, a) || !arb_overlaps(c, b)) { flint_printf("FAIL: overlap\n\n"); flint_printf("d = "); arb_print(d); flint_printf("\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_abort(); } arb_clear(a); arb_clear(b); arb_clear(c); arb_clear(d); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main(void) { int i; FLINT_TEST_INIT(state); flint_printf("reconstruct_fmpz_2...."); fflush(stdout); for (i = 0; i < 10000; i++) { int result; int modresult; int special_case; fmpq_t x, y; fmpz_t mod, res, N, D, t; mpz_t tmp; fmpq_init(x); fmpq_init(y); fmpz_init(mod); fmpz_init(res); fmpz_init(N); fmpz_init(D); fmpz_init(t); mpz_init(tmp); fmpq_randtest(x, state, 100); fmpz_abs(N, fmpq_numref(x)); fmpz_set(D, fmpq_denref(x)); /* Randomly generate larger bounds */ if (n_randint(state, 2)) { fmpz_randtest_not_zero(t, state, 100); fmpz_abs(t, t); fmpz_mul(N, N, t); } if (n_randint(state, 2)) { fmpz_randtest_not_zero(t, state, 100); fmpz_abs(t, t); fmpz_mul(D, D, t); } fmpz_mul(mod, N, D); fmpz_mul_ui(mod, mod, UWORD(2)); /* Next prime greater than or equal */ fmpz_get_mpz(tmp, mod); flint_mpz_sub_ui(tmp, tmp, UWORD(1)); mpz_nextprime(tmp, tmp); fmpz_set_mpz(mod, tmp); modresult = fmpq_mod_fmpz(res, x, mod); result = fmpq_reconstruct_fmpz_2(y, res, mod, N, D); /* Special case: both 1 and -1 have residue 1 mod 2. There's probably no particular reason to disallow this. */ special_case = (fmpz_cmp_ui(mod, UWORD(2)) == 0 && fmpz_get_si(&x->num) == WORD(-1) && fmpz_cmp_ui(&x->den, UWORD(1)) == 0); if (special_case) { if (!modresult || !result || !fmpz_is_one(&y->num) || !fmpz_is_one(&y->den)) { flint_printf("FAIL: special case: -1 mod 2\n"); abort(); } } else if (!modresult || !result || !fmpq_equal(x, y)) { flint_printf("FAIL: reconstruction failed\n"); flint_printf("input = "); fmpq_print(x); flint_printf("\nmodulus = "); fmpz_print(mod); flint_printf("\nresidue = "); fmpz_print(res); flint_printf("\nreconstructed = "); fmpq_print(y); flint_printf("\nfmpq_mod_fmpz return value = %d", modresult); flint_printf("\nfmpq_reconstruct_fmpz return value = %d", result); flint_printf("\n"); abort(); } fmpq_clear(x); fmpq_clear(y); fmpz_clear(mod); fmpz_clear(res); fmpz_clear(N); fmpz_clear(D); fmpz_clear(t); mpz_clear(tmp); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main() { long iter; flint_rand_t state; printf("contains_arf...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000; iter++) { arb_t a; arf_t b; fmpq_t am, ar, bm, t; int c1, c2; arb_init(a); arf_init(b); fmpq_init(am); fmpq_init(ar); fmpq_init(bm); fmpq_init(t); arb_randtest(a, state, 1 + n_randint(state, 500), 14); arf_randtest(b, state, 1 + n_randint(state, 500), 14); arf_get_fmpq(am, arb_midref(a)); mag_get_fmpq(ar, arb_radref(a)); arf_get_fmpq(bm, b); c1 = arb_contains_arf(a, b); fmpq_sub(t, am, ar); c2 = fmpq_cmp(t, bm) <= 0; fmpq_add(t, am, ar); c2 = c2 && (fmpq_cmp(t, bm) >= 0); if (c1 != c2) { printf("FAIL:\n\n"); printf("a = "); arb_print(a); printf("\n\n"); printf("b = "); arf_print(b); printf("\n\n"); printf("am = "); fmpq_print(am); printf("\n\n"); printf("ar = "); fmpq_print(ar); printf("\n\n"); printf("bm = "); fmpq_print(bm); printf("\n\n"); printf("t = "); fmpq_print(t); printf("\n\n"); printf("c1 = %d, c2 = %d\n\n", c1, c2); abort(); } arb_clear(a); arf_clear(b); fmpq_clear(am); fmpq_clear(ar); fmpq_clear(bm); fmpq_clear(t); } flint_randclear(state); flint_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("exp_sum_bs_powtab...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 10000; iter++) { slong N; fmpz_t x, T, Q; fmpq_t S, V; mp_bitcnt_t Qexp, r; fmpz_init(x); fmpz_init(T); fmpz_init(Q); fmpq_init(S); fmpq_init(V); N = 1 + n_randint(state, 300); r = n_randint(state, 10); fmpz_randtest(x, state, 80); _arb_exp_sum_bs_simple(T, Q, &Qexp, x, r, N); fmpq_set_fmpz_frac(S, T, Q); fmpq_div_2exp(S, S, Qexp); _arb_exp_sum_bs_powtab(T, Q, &Qexp, x, r, N); fmpq_set_fmpz_frac(V, T, Q); fmpq_div_2exp(V, V, Qexp); if (!fmpq_equal(S, V)) { flint_printf("FAIL\n\n"); flint_printf("N = %wd\n\n", N); flint_printf("r = %wu\n\n", r); flint_printf("x = "); fmpz_print(x); flint_printf("\n\n"); flint_printf("T = "); fmpz_print(T); flint_printf("\n\n"); flint_printf("Q = "); fmpz_print(T); flint_printf("\n\n"); flint_printf("V = "); fmpq_print(V); flint_printf("\n\n"); flint_printf("S = "); fmpq_print(S); flint_printf("\n\n"); abort(); } fmpz_clear(x); fmpz_clear(T); fmpz_clear(Q); fmpq_clear(S); fmpq_clear(V); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("interpolate_fast...."); 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; acb_poly_t R, S; fmpq_t t, u; acb_ptr xs, ys; fmpq_poly_init(P); acb_poly_init(R); acb_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 = _acb_vec_init(n); ys = _acb_vec_init(n); acb_poly_set_fmpq_poly(R, P, rbits1); if (n > 0) { fmpq_randtest(t, state, qbits2); acb_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); acb_set_fmpq(xs + i, t, rbits2); } } for (i = 0; i < n; i++) acb_poly_evaluate(ys + i, R, xs + i, rbits2); acb_poly_interpolate_fast(S, xs, ys, n, rbits3); if (!acb_poly_contains_fmpq_poly(S, P)) { flint_printf("FAIL:\n"); flint_printf("P = "); fmpq_poly_print(P); flint_printf("\n\n"); flint_printf("R = "); acb_poly_printd(R, 15); flint_printf("\n\n"); flint_printf("S = "); acb_poly_printd(S, 15); flint_printf("\n\n"); flint_abort(); } fmpq_poly_clear(P); acb_poly_clear(R); acb_poly_clear(S); fmpq_clear(t); fmpq_clear(u); _acb_vec_clear(xs, n); _acb_vec_clear(ys, n); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter, iter2; flint_rand_t state; flint_printf("addmul...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++) { arb_t a, b, c; fmpq_t x, y, z; arb_init(a); arb_init(b); arb_init(c); fmpq_init(x); fmpq_init(y); fmpq_init(z); arb_randtest(a, state, 1 + n_randint(state, 200), 10); arb_randtest(b, state, 1 + n_randint(state, 200), 10); arb_randtest(c, state, 1 + n_randint(state, 200), 10); arb_get_rand_fmpq(x, state, a, 1 + n_randint(state, 200)); arb_get_rand_fmpq(y, state, b, 1 + n_randint(state, 200)); arb_get_rand_fmpq(z, state, c, 1 + n_randint(state, 200)); arb_addmul(c, a, b, 2 + n_randint(state, 200)); fmpq_addmul(z, x, y); if (!arb_contains_fmpq(c, z)) { flint_printf("FAIL: containment\n\n"); flint_printf("a = "); arb_print(a); flint_printf("\n\n"); flint_printf("x = "); fmpq_print(x); flint_printf("\n\n"); flint_printf("b = "); arb_print(b); flint_printf("\n\n"); flint_printf("y = "); fmpq_print(y); flint_printf("\n\n"); flint_printf("c = "); arb_print(c); flint_printf("\n\n"); flint_printf("z = "); fmpq_print(z); flint_printf("\n\n"); abort(); } arb_clear(a); arb_clear(b); arb_clear(c); fmpq_clear(x); fmpq_clear(y); fmpq_clear(z); } /* aliasing of c and a */ for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { arb_t a, b; fmpq_t x, y, z; arb_init(a); arb_init(b); fmpq_init(x); fmpq_init(y); fmpq_init(z); arb_randtest(a, state, 1 + n_randint(state, 200), 10); arb_randtest(b, state, 1 + n_randint(state, 200), 10); arb_get_rand_fmpq(x, state, a, 1 + n_randint(state, 200)); arb_get_rand_fmpq(y, state, b, 1 + n_randint(state, 200)); fmpq_set(z, x); arb_addmul(a, a, b, 2 + n_randint(state, 200)); fmpq_addmul(z, x, y); if (!arb_contains_fmpq(a, z)) { flint_printf("FAIL: aliasing (c, a)\n\n"); flint_printf("a = "); arb_print(a); flint_printf("\n\n"); flint_printf("x = "); fmpq_print(x); flint_printf("\n\n"); flint_printf("b = "); arb_print(b); flint_printf("\n\n"); flint_printf("y = "); fmpq_print(y); flint_printf("\n\n"); flint_printf("z = "); fmpq_print(z); flint_printf("\n\n"); abort(); } arb_clear(a); arb_clear(b); fmpq_clear(x); fmpq_clear(y); fmpq_clear(z); } /* aliasing of c and b */ for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { arb_t a, b; fmpq_t x, y, z; arb_init(a); arb_init(b); fmpq_init(x); fmpq_init(y); fmpq_init(z); arb_randtest(a, state, 1 + n_randint(state, 200), 10); arb_randtest(b, state, 1 + n_randint(state, 200), 10); arb_get_rand_fmpq(x, state, a, 1 + n_randint(state, 200)); arb_get_rand_fmpq(y, state, b, 1 + n_randint(state, 200)); fmpq_set(z, y); arb_addmul(b, a, b, 2 + n_randint(state, 200)); fmpq_addmul(z, x, y); if (!arb_contains_fmpq(b, z)) { flint_printf("FAIL: aliasing (c, b)\n\n"); flint_printf("a = "); arb_print(a); flint_printf("\n\n"); flint_printf("x = "); fmpq_print(x); flint_printf("\n\n"); flint_printf("b = "); arb_print(b); flint_printf("\n\n"); flint_printf("y = "); fmpq_print(y); flint_printf("\n\n"); flint_printf("z = "); fmpq_print(z); flint_printf("\n\n"); abort(); } arb_clear(a); arb_clear(b); fmpq_clear(x); fmpq_clear(y); fmpq_clear(z); } /* main test */ for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { arb_t x, y, z, v; slong prec; arb_init(x); arb_init(y); arb_init(z); arb_init(v); for (iter2 = 0; iter2 < 100; iter2++) { arb_randtest_special(x, state, n_randint(state,2) ? 2000 : 200, 200); arb_randtest_special(y, state, n_randint(state,2) ? 2000 : 200, 200); arb_randtest_special(z, state, n_randint(state,2) ? 2000 : 200, 200); prec = 2 + n_randint(state, 2000); switch (n_randint(state, 5)) { case 0: arb_set(v, z); arb_addmul(z, x, y, prec); arb_addmul_naive(v, x, y, prec); if (!arf_equal(arb_midref(z), arb_midref(v)) || !mag_close(arb_radref(z), arb_radref(v))) { flint_printf("FAIL!\n"); flint_printf("x = "); arb_print(x); flint_printf("\n\n"); flint_printf("y = "); arb_print(y); flint_printf("\n\n"); flint_printf("z = "); arb_print(z); flint_printf("\n\n"); flint_printf("v = "); arb_print(v); flint_printf("\n\n"); abort(); } break; case 1: arb_set(y, x); arb_set(z, v); arb_addmul(z, x, y, prec); arb_addmul(v, x, x, prec); if (!arf_equal(arb_midref(z), arb_midref(v)) || !mag_close(arb_radref(z), arb_radref(v))) { flint_printf("FAIL (aliasing 1)!\n"); flint_printf("x = "); arb_print(x); flint_printf("\n\n"); flint_printf("z = "); arb_print(z); flint_printf("\n\n"); flint_printf("v = "); arb_print(v); flint_printf("\n\n"); abort(); } break; case 2: arb_set(v, x); arb_addmul(v, x, x, prec); arb_addmul(x, x, x, prec); if (!arf_equal(arb_midref(x), arb_midref(v)) || !mag_close(arb_radref(x), arb_radref(v))) { flint_printf("FAIL (aliasing 2)!\n"); flint_printf("x = "); arb_print(x); flint_printf("\n\n"); flint_printf("v = "); arb_print(v); flint_printf("\n\n"); abort(); } break; case 3: arb_set(v, x); arb_addmul(v, x, y, prec); arb_addmul(x, x, y, prec); if (!arf_equal(arb_midref(x), arb_midref(v)) || !mag_close(arb_radref(x), arb_radref(v))) { flint_printf("FAIL (aliasing 3)!\n"); flint_printf("x = "); arb_print(x); flint_printf("\n\n"); flint_printf("y = "); arb_print(y); flint_printf("\n\n"); flint_printf("v = "); arb_print(v); flint_printf("\n\n"); abort(); } break; default: arb_set(v, x); arb_addmul(v, x, y, prec); arb_addmul(x, y, x, prec); if (!arf_equal(arb_midref(x), arb_midref(v)) || !mag_close(arb_radref(x), arb_radref(v))) { flint_printf("FAIL (aliasing 4)!\n"); flint_printf("x = "); arb_print(x); flint_printf("\n\n"); flint_printf("y = "); arb_print(y); flint_printf("\n\n"); flint_printf("v = "); arb_print(v); flint_printf("\n\n"); abort(); } break; } } arb_clear(x); arb_clear(y); arb_clear(z); arb_clear(v); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main() { slong iter; flint_rand_t state; flint_printf("exp...."); fflush(stdout); flint_randinit(state); /* check large arguments + compare with exp_simple */ for (iter = 0; iter < 100000 *arb_test_multiplier(); iter++) { arb_t a, b, c, d; slong prec0, prec1, prec2, acc1, acc2; if (iter % 10 == 0) prec0 = 10000; else prec0 = 1000; prec1 = 2 + n_randint(state, prec0); prec2 = 2 + n_randint(state, prec0); arb_init(a); arb_init(b); arb_init(c); arb_init(d); arb_randtest_special(a, state, 1 + n_randint(state, prec0), 100); arb_randtest_special(b, state, 1 + n_randint(state, prec0), 100); arb_exp(b, a, prec1); arb_exp(c, a, prec2); arb_exp_simple(d, a, prec1); if (!arb_overlaps(b, c) || !arb_overlaps(b, d) || !arb_overlaps(c, d)) { flint_printf("FAIL: overlap\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"); flint_abort(); } /* compare accuracy with exp_simple */ acc1 = arb_rel_accuracy_bits(b); acc2 = arb_rel_accuracy_bits(d); if (acc2 > 0 && acc1 < acc2 - 1) { flint_printf("FAIL: accuracy\n\n"); flint_printf("prec1 = %wd, acc1 = %wd, acc2 = %wd\n\n", prec1, acc1, acc2); flint_printf("a = "); arb_printd(a, 50); flint_printf("\n\n"); flint_printf("b = "); arb_printd(b, 50); flint_printf("\n\n"); flint_printf("d = "); arb_printd(d, 50); flint_printf("\n\n"); flint_abort(); } arb_randtest_special(b, state, 1 + n_randint(state, prec0), 100); /* check exp(a)*exp(b) = exp(a+b) */ arb_exp(c, a, prec1); arb_exp(d, b, prec1); arb_mul(c, c, d, prec1); arb_add(d, a, b, prec1); arb_exp(d, d, prec1); if (!arb_overlaps(c, d)) { flint_printf("FAIL: functional equation\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"); flint_abort(); } arb_clear(a); arb_clear(b); arb_clear(c); arb_clear(d); } /* test union */ for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++) { arb_t a, b, c, d, e; slong prec0, prec1, prec2, prec3, prec4; if (iter % 10 == 0) prec0 = 10000; else prec0 = 1000; prec1 = 2 + n_randint(state, prec0); prec2 = 2 + n_randint(state, prec0); prec3 = 2 + n_randint(state, prec0); prec4 = 2 + n_randint(state, prec0); arb_init(a); arb_init(b); arb_init(c); arb_init(d); arb_init(e); arb_randtest_special(a, state, 1 + n_randint(state, prec0), 200); arb_randtest_special(b, state, 1 + n_randint(state, prec0), 200); arb_randtest_special(c, state, 1 + n_randint(state, prec0), 200); arb_randtest_special(d, state, 1 + n_randint(state, prec0), 200); arb_randtest_special(e, state, 1 + n_randint(state, prec0), 200); arb_exp(c, a, prec1); arb_exp(d, b, prec2); arb_union(e, a, b, prec3); arb_exp(e, e, prec4); if (!arb_overlaps(e, c) || !arb_overlaps(e, d)) { flint_printf("FAIL: union\n\n"); flint_printf("a = "); arb_printn(a, 1000, 0); flint_printf("\n\n"); flint_printf("b = "); arb_printn(b, 1000, 0); flint_printf("\n\n"); flint_printf("c = "); arb_printn(c, 1000, 0); flint_printf("\n\n"); flint_printf("d = "); arb_printn(d, 1000, 0); flint_printf("\n\n"); flint_printf("e = "); arb_printn(e, 1000, 0); flint_printf("\n\n"); flint_abort(); } arb_clear(a); arb_clear(b); arb_clear(c); arb_clear(d); arb_clear(e); } /* comparison with mpfr */ for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++) { arb_t a, b; fmpq_t q; mpfr_t t; slong prec0, prec; prec0 = 400; if (iter % 100 == 0) prec0 = 10000; prec = 2 + n_randint(state, prec0); arb_init(a); arb_init(b); fmpq_init(q); mpfr_init2(t, prec + 100); arb_randtest(a, state, 1 + n_randint(state, prec0), 4); arb_randtest(b, state, 1 + n_randint(state, prec0), 4); arb_get_rand_fmpq(q, state, a, 1 + n_randint(state, prec0)); fmpq_get_mpfr(t, q, MPFR_RNDN); mpfr_exp(t, t, MPFR_RNDN); arb_exp(b, a, prec); if (!arb_contains_mpfr(b, t)) { flint_printf("FAIL: containment\n\n"); flint_printf("iter = %wd, prec = %wd\n\n", iter, prec); flint_printf("a = "); arb_print(a); flint_printf("\n\n"); flint_printf("b = "); arb_print(b); flint_printf("\n\n"); flint_abort(); } arb_exp(a, a, prec); if (!arb_equal(a, b)) { flint_printf("FAIL: aliasing\n\n"); flint_printf("iter = %wd, prec = %wd\n\n", iter, prec); flint_printf("a = "); arb_print(a); flint_printf("\n\n"); flint_printf("b = "); arb_print(b); flint_printf("\n\n"); flint_abort(); } arb_clear(a); arb_clear(b); fmpq_clear(q); mpfr_clear(t); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
int main(void) { int i; FLINT_TEST_INIT(state); flint_printf("solve_dixon...."); fflush(stdout); /* Solve nonsingular systems */ for (i = 0; i < 100 * flint_test_multiplier(); i++) { fmpq_mat_t A, B, X, AX; fmpq_t d; int success; slong n, m, bits; n = n_randint(state, 10); m = n_randint(state, 10); bits = 1 + n_randint(state, 100); fmpq_mat_init(A, n, n); fmpq_mat_init(B, n, m); fmpq_mat_init(X, n, m); fmpq_mat_init(AX, n, m); fmpq_init(d); /* XXX: replace with a randtest function */ do { fmpq_mat_randtest(A, state, bits); fmpq_mat_det(d, A); } while (fmpq_is_zero(d)); fmpq_clear(d); fmpq_mat_randtest(B, state, bits); success = fmpq_mat_solve_dixon(X, A, B); fmpq_mat_mul(AX, A, X); if (!fmpq_mat_equal(AX, B) || !success) { flint_printf("FAIL!\n"); flint_printf("success: %d\n", success); flint_printf("A:\n"); fmpq_mat_print(A); flint_printf("B:\n"); fmpq_mat_print(B); flint_printf("X:\n"); fmpq_mat_print(X); flint_printf("AX:\n"); fmpq_mat_print(AX); abort(); } fmpq_mat_clear(A); fmpq_mat_clear(B); fmpq_mat_clear(X); fmpq_mat_clear(AX); } /* Check singular systems */ for (i = 0; i < 100 * flint_test_multiplier(); i++) { fmpq_mat_t A, B, X; fmpz_mat_t M; fmpz_t den; slong n, m, bits; int success; n = 1 + n_randint(state, 10); m = 1 + n_randint(state, 10); bits = 1 + n_randint(state, 100); fmpz_init(den); fmpz_mat_init(M, n, n); fmpz_mat_randrank(M, state, n_randint(state, n), bits); if (i % 2) fmpz_mat_randops(M, state, n_randint(state, 2*m*n + 1)); fmpz_randtest_not_zero(den, state, bits); fmpq_mat_init(A, n, n); fmpq_mat_set_fmpz_mat_div_fmpz(A, M, den); fmpq_mat_init(B, n, m); fmpq_mat_randtest(B, state, bits); fmpq_mat_init(X, n, m); success = fmpq_mat_solve_dixon(X, A, B); if (success != 0) { flint_printf("FAIL!\n"); flint_printf("Expected success = 0\n"); fmpq_mat_print(A); flint_printf("\n"); abort(); } fmpq_mat_clear(A); fmpq_mat_clear(B); fmpq_mat_clear(X); fmpz_mat_clear(M); fmpz_clear(den); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int fmpq_poly_check_unique_real_root(const fmpq_poly_t pol, const arb_t a, slong prec) { if (pol->length < 2) return 0; else if (pol->length == 2) { /* linear polynomial */ fmpq_t root; int ans; fmpq_init(root); fmpq_set_fmpz_frac(root, fmpq_poly_numref(pol), fmpq_poly_numref(pol) + 1); fmpq_neg(root, root); ans = arb_contains_fmpq(a, root); fmpq_clear(root); return ans; } else { arb_t b, c; arf_t l, r; fmpz * der; int lsign, rsign; fmpz_poly_t pol2; slong n; /* 1 - cheap test: */ /* - sign(left) * sign(right) = -1 */ /* - no zero of the derivative */ arb_init(b); arb_init(c); arf_init(l); arf_init(r); arb_get_interval_arf(l, r, a, prec); arb_set_arf(b, l); _fmpz_poly_evaluate_arb(c, pol->coeffs, pol->length, b, 2*prec); lsign = arb_sgn2(c); arb_set_arf(b, r); _fmpz_poly_evaluate_arb(c, pol->coeffs, pol->length, b, 2*prec); rsign = arb_sgn2(c); arb_clear(c); if (lsign * rsign == -1) { der = _fmpz_vec_init(pol->length - 1); _fmpz_poly_derivative(der, pol->coeffs, pol->length); _fmpz_poly_evaluate_arb(b, der, pol->length - 1, a, prec); _fmpz_vec_clear(der, pol->length - 1); if (!arb_contains_zero(b)) { arf_clear(l); arf_clear(r); arb_clear(b); return 1; } } else return 0; arb_clear(b); /* 2 - expensive testing */ fmpq_t ql, qr; fmpq_init(ql); fmpq_init(qr); arf_get_fmpq(ql, l); arf_get_fmpq(qr, r); fmpz_poly_init(pol2); fmpz_poly_fit_length(pol2, pol->length); _fmpz_vec_set(pol2->coeffs, pol->coeffs, pol->length); pol2->length = pol->length; _fmpz_poly_scale_0_1_fmpq(pol2->coeffs, pol2->length, ql, qr); n = fmpz_poly_num_real_roots_0_1(pol2); fmpz_poly_clear(pol2); fmpq_clear(ql); fmpq_clear(qr); return (n == 1); } }
int main() { long iter; flint_rand_t state; printf("agm...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 100000; iter++) { fmprb_t a, b, c; fmpq_t q, r; mpfr_t t, u; long prec = 2 + n_randint(state, 200); fmprb_init(a); fmprb_init(b); fmprb_init(c); fmpq_init(q); fmpq_init(r); mpfr_init2(t, prec + 100); mpfr_init2(u, prec + 100); fmprb_randtest(a, state, 1 + n_randint(state, 200), 3); fmprb_randtest(b, state, 1 + n_randint(state, 200), 3); fmprb_randtest(c, state, 1 + n_randint(state, 200), 3); fmprb_agm(c, a, b, prec); if (fmprb_equal(a, b)) { if (!fmprb_contains(c, a)) { printf("FAIL: containment (identity)\n\n"); printf("a = "); fmprb_print(a); printf("\n\n"); printf("b = "); fmprb_print(b); printf("\n\n"); printf("c = "); fmprb_print(c); printf("\n\n"); abort(); } } else { fmprb_get_rand_fmpq(q, state, a, 1 + n_randint(state, 200)); fmprb_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 (!fmprb_contains_mpfr(c, t)) { printf("FAIL: containment\n\n"); printf("a = "); fmprb_print(a); printf("\n\n"); printf("b = "); fmprb_print(b); printf("\n\n"); printf("c = "); fmprb_print(c); printf("\n\n"); abort(); } } fmprb_clear(a); fmprb_clear(b); fmprb_clear(c); fmpq_clear(q); fmpq_clear(r); mpfr_clear(t); mpfr_clear(u); } flint_randclear(state); flint_cleanup(); printf("PASS\n"); return EXIT_SUCCESS; }
int main(void) { int i, result; ulong cflags = UWORD(0); FLINT_TEST_INIT(state); flint_printf("scalar_mul_fmpq...."); fflush(stdout); /* Check aliasing of a and b */ for (i = 0; i < 1000 * flint_test_multiplier(); i++) { fmpq_poly_t a, b; fmpq_t z; fmpq_init(z); fmpq_randtest(z, state, 100); fmpq_poly_init(a); fmpq_poly_init(b); fmpq_poly_randtest(a, state, n_randint(state, 100), 200); fmpq_poly_scalar_mul_fmpq(b, a, z); fmpq_poly_scalar_mul_fmpq(a, a, z); cflags |= fmpq_poly_is_canonical(a) ? 0 : 1; cflags |= fmpq_poly_is_canonical(b) ? 0 : 2; result = (fmpq_poly_equal(a, b) && !cflags); if (!result) { flint_printf("FAIL (aliasing):\n\n"); flint_printf("a = "), fmpq_poly_debug(a), flint_printf("\n\n"); flint_printf("b = "), fmpq_poly_debug(b), flint_printf("\n\n"); flint_printf("z = "), fmpq_print(z), flint_printf("\n\n"); gmp_printf("z = %Qd\n\n", z); flint_printf("cflags = %wu\n\n", cflags); abort(); } fmpq_clear(z); fmpq_poly_clear(a); fmpq_poly_clear(b); } /* Check that (a * n1) * n2 == a * (n1 * n2) */ for (i = 0; i < 1000 * flint_test_multiplier(); i++) { fmpq_poly_t a, lhs, rhs; fmpq_t z1, z2, z; fmpq_init(z1); fmpq_init(z2); fmpq_init(z); fmpq_randtest(z1, state, 100); fmpq_randtest(z2, state, 100); fmpq_mul(z, z1, z2); fmpq_poly_init(a); fmpq_poly_init(lhs); fmpq_poly_init(rhs); fmpq_poly_randtest(a, state, n_randint(state, 100), 200); fmpq_poly_scalar_mul_fmpq(lhs, a, z1); fmpq_poly_scalar_mul_fmpq(lhs, lhs, z2); fmpq_poly_scalar_mul_fmpq(rhs, a, z); cflags |= fmpq_poly_is_canonical(lhs) ? 0 : 1; cflags |= fmpq_poly_is_canonical(rhs) ? 0 : 2; result = (fmpq_poly_equal(lhs, rhs) && !cflags); if (!result) { flint_printf("FAIL (a * n1 * n2):\n"); fmpq_poly_debug(a), flint_printf("\n\n"); flint_printf("z1 = "), fmpq_print(z1), flint_printf("\n\n"); flint_printf("z2 = "), fmpq_print(z2), flint_printf("\n\n"); flint_printf("z = "), fmpq_print(z), flint_printf("\n\n"); fmpq_poly_debug(lhs), flint_printf("\n\n"); fmpq_poly_debug(rhs), flint_printf("\n\n"); flint_printf("cflags = %wu\n\n", cflags); abort(); } fmpq_clear(z1); fmpq_clear(z2); fmpq_clear(z); fmpq_poly_clear(a); fmpq_poly_clear(lhs); fmpq_poly_clear(rhs); } /* Check that (a + b) * n == a*n + b*n */ for (i = 0; i < 1000 * flint_test_multiplier(); i++) { fmpq_poly_t a, b, lhs, rhs; fmpq_t z; fmpq_init(z); fmpq_randtest(z, state, 100); fmpq_poly_init(a); fmpq_poly_init(b); fmpq_poly_init(lhs); fmpq_poly_init(rhs); fmpq_poly_randtest(a, state, n_randint(state, 100), 200); fmpq_poly_randtest(b, state, n_randint(state, 100), 200); fmpq_poly_scalar_mul_fmpq(lhs, a, z); fmpq_poly_scalar_mul_fmpq(rhs, b, z); fmpq_poly_add(rhs, lhs, rhs); fmpq_poly_add(lhs, a, b); fmpq_poly_scalar_mul_fmpq(lhs, lhs, z); cflags |= fmpq_poly_is_canonical(lhs) ? 0 : 1; cflags |= fmpq_poly_is_canonical(rhs) ? 0 : 2; result = (fmpq_poly_equal(lhs, rhs) && !cflags); if (!result) { flint_printf("FAIL ((a + b) / n):\n"); fmpq_poly_debug(a), flint_printf("\n\n"); fmpq_poly_debug(b), flint_printf("\n\n"); flint_printf("z = "), fmpq_print(z), flint_printf("\n\n"); fmpq_poly_debug(lhs), flint_printf("\n\n"); fmpq_poly_debug(rhs), flint_printf("\n\n"); flint_printf("cflags = %wu\n\n", cflags); abort(); } fmpq_clear(z); fmpq_poly_clear(a); fmpq_poly_clear(b); fmpq_poly_clear(lhs); fmpq_poly_clear(rhs); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main(void) { int i; flint_rand_t state; flint_randinit(state); printf("bsplit_sum_abpq...."); fflush(stdout); for (i = 0; i < 10000; i++) { fmpq *ab, *pq; fmpq_t s1, s2, t, pqp; fmpq_bsplit_t sum; long k, n; n = n_randint(state, 40); ab = _fmpq_vec_init(n); pq = _fmpq_vec_init(n); fmpq_init(s1); fmpq_init(s2); fmpq_init(pqp); fmpq_init(t); for (k = 0; k < n; k++) fmpq_randtest(ab + k, state, 10); for (k = 0; k < n; k++) fmpq_randtest(pq + k, state, 10); fmpq_bsplit_init(sum); fmpq_bsplit_sum_abpq(sum, ab, pq, 0, n); fmpq_bsplit_get_fmpq(s1, sum); fmpq_zero(s2); fmpq_one(pqp); for (k = 0; k < n; k++) { fmpq_mul(pqp, pqp, pq + k); fmpq_mul(t, pqp, ab + k); fmpq_add(s2, s2, t); } if (!fmpq_is_canonical(s1) || !fmpq_equal(s1, s2)) { printf("FAIL\n"); printf("(a/b) = "); for (k = 0; k < n; k++) fmpq_print(ab+k), printf(" "); printf("\n"); printf("(p/q) = "); for (k = 0; k < n; k++) fmpq_print(pq+k), printf(" "); printf("\n"); printf("s1: "); fmpq_print(s1); printf("\n"); printf("s2: "); fmpq_print(s2); printf("\n"); abort(); } /* Check numerical evaluation */ { mpfr_t f1, f2; mpfr_prec_t prec; prec = 5 + n_randint(state, 1000); mpfr_init2(f1, prec); mpfr_init2(f2, prec); fmpq_bsplit_get_mpfr(f1, sum); fmpq_get_mpfr(f2, s1, MPFR_RNDN); mpfr_sub(f1, f1, f2, MPFR_RNDN); if (!mpfr_zero_p(f1) && !(mpfr_get_exp(f1) <= mpfr_get_exp(f2) - prec + 3)) { printf("FAIL: numerical evaluation\n"); printf("%ld, %ld, %ld\n", prec, mpfr_get_exp(f1), mpfr_get_exp(f2) - prec + 3); abort(); } mpfr_clear(f1); mpfr_clear(f2); } fmpq_bsplit_clear(sum); fmpq_clear(s1); fmpq_clear(s2); fmpq_clear(pqp); fmpq_clear(t); _fmpq_vec_clear(ab, n); _fmpq_vec_clear(pq, n); } flint_randclear(state); _fmpz_cleanup(); printf("PASS\n"); return 0; }
int main(void) { int i; FLINT_TEST_INIT(state); flint_printf("add...."); fflush(stdout); /* x = y + z */ for (i = 0; i < 10000; i++) { fmpq_t x, y, z; mpq_t X, Y, Z; fmpq_init(x); fmpq_init(y); fmpq_init(z); mpq_init(X); mpq_init(Y); mpq_init(Z); fmpq_randtest(x, state, 200); fmpq_randtest(y, state, 200); fmpq_randtest(z, state, 200); fmpq_get_mpq(X, x); fmpq_get_mpq(Y, y); fmpq_get_mpq(Z, z); fmpq_add(x, y, z); if (!fmpq_is_canonical(x)) { flint_printf("FAIL: result not canonical!\n"); abort(); } mpq_add(X, Y, Z); fmpq_get_mpq(Y, x); if (!mpq_equal(X, Y)) { flint_printf("FAIL: fmpq_add(x,y,z) != mpq_add(X,Y,Z)\n"); flint_printf("x = "); fmpq_print(x); flint_printf("\ny = "); fmpq_print(y); flint_printf("\nz = "); fmpq_print(z); flint_printf("\n"); abort(); } fmpq_clear(x); fmpq_clear(y); fmpq_clear(z); mpq_clear(X); mpq_clear(Y); mpq_clear(Z); } /* x = x + y */ for (i = 0; i < 10000; i++) { fmpq_t x, y; mpq_t X, Y; fmpq_init(x); fmpq_init(y); mpq_init(X); mpq_init(Y); fmpq_randtest(x, state, 200); fmpq_randtest(y, state, 200); fmpq_get_mpq(X, x); fmpq_get_mpq(Y, y); fmpq_add(x, x, y); if (!fmpq_is_canonical(x)) { flint_printf("FAIL: result not canonical!\n"); abort(); } mpq_add(X, X, Y); fmpq_get_mpq(Y, x); if (!mpq_equal(X, Y)) { flint_printf("FAIL: fmpq_add(x,x,y) != mpq_add(X,X,Y)\n"); flint_printf("x = "); fmpq_print(x); flint_printf("\ny = "); fmpq_print(y); flint_printf("\n"); abort(); } fmpq_clear(x); fmpq_clear(y); mpq_clear(X); mpq_clear(Y); } /* x = y + x */ for (i = 0; i < 10000; i++) { fmpq_t x, y; mpq_t X, Y; fmpq_init(x); fmpq_init(y); mpq_init(X); mpq_init(Y); fmpq_randtest(x, state, 200); fmpq_randtest(y, state, 200); fmpq_get_mpq(X, x); fmpq_get_mpq(Y, y); fmpq_add(x, y, x); if (!fmpq_is_canonical(x)) { flint_printf("FAIL: result not canonical!\n"); abort(); } mpq_add(X, Y, X); fmpq_get_mpq(Y, x); if (!mpq_equal(X, Y)) { flint_printf("FAIL: fmpq_add(x,y,x) != mpq_add(X,Y,X)\n"); flint_printf("x = "); fmpq_print(x); flint_printf("\ny = "); fmpq_print(y); flint_printf("\n"); abort(); } fmpq_clear(x); fmpq_clear(y); mpq_clear(X); mpq_clear(Y); } FLINT_TEST_CLEANUP(state); flint_printf("PASS\n"); return 0; }
int main() { slong iter; flint_rand_t state; flint_printf("atan2...."); fflush(stdout); flint_randinit(state); for (iter = 0; iter < 100000; 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_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_atan2(t, u, t, MPFR_RNDN); arb_atan2(c, b, a, prec); 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("trace...."); fflush(stdout); flint_randinit(state); /* check that the acb trace contains the fmpq trace */ for (iter = 0; iter < 10000; iter++) { fmpq_mat_t Q; fmpq_t Qtrace; acb_mat_t A; acb_t Atrace; slong n, qbits, prec; n = n_randint(state, 8); qbits = 1 + n_randint(state, 100); prec = 2 + n_randint(state, 200); fmpq_mat_init(Q, n, n); fmpq_init(Qtrace); acb_mat_init(A, n, n); acb_init(Atrace); fmpq_mat_randtest(Q, state, qbits); fmpq_mat_trace(Qtrace, Q); acb_mat_set_fmpq_mat(A, Q, prec); acb_mat_trace(Atrace, A, prec); if (!acb_contains_fmpq(Atrace, Qtrace)) { 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("Qtrace = \n"); fmpq_print(Qtrace); flint_printf("\n\n"); flint_printf("A = \n"); acb_mat_printd(A, 15); flint_printf("\n\n"); flint_printf("Atrace = \n"); acb_printd(Atrace, 15); flint_printf("\n\n"); flint_printf("Atrace = \n"); acb_print(Atrace); flint_printf("\n\n"); abort(); } fmpq_mat_clear(Q); fmpq_clear(Qtrace); acb_mat_clear(A); acb_clear(Atrace); } /* check trace(A*B) = trace(B*A) */ for (iter = 0; iter < 10000; iter++) { slong m, n, prec; acb_mat_t a, b, ab, ba; acb_t trab, trba; prec = 2 + n_randint(state, 200); m = n_randint(state, 10); n = n_randint(state, 10); acb_mat_init(a, m, n); acb_mat_init(b, n, m); acb_mat_init(ab, m, m); acb_mat_init(ba, n, n); acb_init(trab); acb_init(trba); acb_mat_randtest(a, state, 2 + n_randint(state, 100), 10); acb_mat_randtest(b, state, 2 + n_randint(state, 100), 10); acb_mat_mul(ab, a, b, prec); acb_mat_mul(ba, b, a, prec); acb_mat_trace(trab, ab, prec); acb_mat_trace(trba, ba, prec); if (!acb_overlaps(trab, trba)) { flint_printf("FAIL (overlap, iter = %wd)\n", iter); flint_printf("m = %wd, n = %wd, prec = %wd\n", m, n, prec); flint_printf("\n"); flint_printf("a = \n"); acb_mat_printd(a, 15); flint_printf("\n\n"); flint_printf("b = \n"); acb_mat_printd(b, 15); flint_printf("\n\n"); flint_printf("ab = \n"); acb_mat_printd(ab, 15); flint_printf("\n\n"); flint_printf("ba = \n"); acb_mat_printd(ba, 15); flint_printf("\n\n"); flint_printf("trace(ab) = \n"); acb_printd(trab, 15); flint_printf("\n\n"); flint_printf("trace(ba) = \n"); acb_printd(trba, 15); flint_printf("\n\n"); } acb_clear(trab); acb_clear(trba); acb_mat_clear(a); acb_mat_clear(b); acb_mat_clear(ab); acb_mat_clear(ba); } flint_randclear(state); flint_cleanup(); flint_printf("PASS\n"); return EXIT_SUCCESS; }
void init_set(ElementType& result, const ElementType& a) const { fmpq_init(&result); fmpq_set(&result, &a); }
int main(void) { long i; flint_rand_t state; printf("trace...."); fflush(stdout); flint_randinit(state); /* Test trace(AB) = trace(BA) */ for (i = 0; i < 1000; i++) { fmpq_mat_t A, B, AB, BA; fmpq_t trab, trba; long m, n; m = n_randint(state, 10); n = n_randint(state, 10); fmpq_mat_init(A, m, n); fmpq_mat_init(B, n, m); fmpq_mat_init(AB, m, m); fmpq_mat_init(BA, n, n); fmpq_init(trab); fmpq_init(trba); fmpq_mat_randtest(A, state, 1 + n_randint(state, 100)); fmpq_mat_randtest(B, state, 1 + n_randint(state, 100)); fmpq_mat_mul(AB, A, B); fmpq_mat_mul(BA, B, A); fmpq_mat_trace(trab, AB); fmpq_mat_trace(trba, BA); if (!fmpq_equal(trab, trba)) { printf("FAIL:\n"); fmpq_mat_print(A), printf("\n"); fmpq_mat_print(B), printf("\n"); fmpq_mat_print(AB), printf("\n"); fmpq_mat_print(BA), printf("\n"); printf("tr(AB): "), fmpq_print(trab), printf("\n"); printf("tr(BA): "), fmpq_print(trba), printf("\n"); abort(); } fmpq_mat_clear(A); fmpq_mat_clear(B); fmpq_mat_clear(AB); fmpq_mat_clear(BA); fmpq_clear(trab); fmpq_clear(trba); } flint_randclear(state); _fmpz_cleanup(); printf("PASS\n"); return 0; }