void
arb_mul_naive(arb_t z, const arb_t x, const arb_t y, slong prec)
{
arf_t zm_exact, zm_rounded, zr, t, u;
arf_init(zm_exact);
arf_init(zm_rounded);
arf_init(zr);
arf_init(t);
arf_init(u);
arf_mul(zm_exact, arb_midref(x), arb_midref(y), ARF_PREC_EXACT, ARF_RND_DOWN);
arf_set_round(zm_rounded, zm_exact, prec, ARB_RND);
/* rounding error */
if (arf_equal(zm_exact, zm_rounded))
{
arf_zero(zr);
}
else
{
fmpz_t e;
fmpz_init(e);
/* more accurate, but not what we are testing
arf_sub(zr, zm_exact, zm_rounded, MAG_BITS, ARF_RND_UP);
arf_abs(zr, zr); */
fmpz_sub_ui(e, ARF_EXPREF(zm_rounded), prec);
arf_one(zr);
arf_mul_2exp_fmpz(zr, zr, e);
fmpz_clear(e);
}
/* propagated error */
if (!arb_is_exact(x))
{
arf_set_mag(t, arb_radref(x));
arf_abs(u, arb_midref(y));
arf_addmul(zr, t, u, MAG_BITS, ARF_RND_UP);
}
if (!arb_is_exact(y))
{
arf_set_mag(t, arb_radref(y));
arf_abs(u, arb_midref(x));
arf_addmul(zr, t, u, MAG_BITS, ARF_RND_UP);
}
if (!arb_is_exact(x) && !arb_is_exact(y))
{
arf_set_mag(t, arb_radref(x));
arf_set_mag(u, arb_radref(y));
arf_addmul(zr, t, u, MAG_BITS, ARF_RND_UP);
}
arf_set(arb_midref(z), zm_rounded);
arf_get_mag(arb_radref(z), zr);
arf_clear(zm_exact);
arf_clear(zm_rounded);
arf_clear(zr);
arf_clear(t);
arf_clear(u);
}
void
arb_abs(arb_t y, const arb_t x)
{
arf_abs(arb_midref(y), arb_midref(x));
mag_set(arb_radref(y), arb_radref(x));
}
int arb_mat_jacobi(arb_mat_t D, arb_mat_t P, const arb_mat_t A, slong prec) {
//
// Given a d x d real symmetric matrix A, compute an orthogonal matrix
// P and a diagonal D such that A = P D P^t = P D P^(-1).
//
// D should have already been initialized as a d x 1 matrix, and Pp
// should have already been initialized as a d x d matrix.
//
// If the eigenvalues can be certified as unique, then a nonzero int is
// returned, and the eigenvectors should have reasonable error bounds. If
// the eigenvalues cannot be certified as unique, then some of the
// eigenvectors will have infinite error radius.
#define B(i,j) arb_mat_entry(B, i, j)
#define D(i) arb_mat_entry(D, i, 0)
#define P(i,j) arb_mat_entry(P, i, j)
int dim = arb_mat_nrows(A);
if(dim == 1) {
arb_mat_set(D, A);
arb_mat_one(P);
return 0;
}
arb_mat_t B;
arb_mat_init(B, dim, dim);
arf_t * B1 = (arf_t*)malloc(dim * sizeof(arf_t));
arf_t * B2 = (arf_t*)malloc(dim * sizeof(arf_t));
arf_t * row_max = (arf_t*)malloc((dim - 1) * sizeof(arf_t));
int * row_max_indices = (int*)malloc((dim - 1) * sizeof(int));
for(int k = 0; k < dim; k++) {
arf_init(B1[k]);
arf_init(B2[k]);
}
for(int k = 0; k < dim - 1; k++) {
arf_init(row_max[k]);
}
arf_t x1, x2;
arf_init(x1);
arf_init(x2);
arf_t Gii, Gij, Gji, Gjj;
arf_init(Gii);
arf_init(Gij);
arf_init(Gji);
arf_init(Gjj);
arb_mat_set(B, A);
arb_mat_one(P);
for(int i = 0; i < dim - 1; i++) {
for(int j = i + 1; j < dim; j++) {
arf_abs(x1, arb_midref(B(i,j)));
if(arf_cmp(row_max[i], x1) < 0) {
arf_set(row_max[i], x1);
row_max_indices[i] = j;
}
}
}
int finished = 0;
while(!finished) {
arf_zero(x1);
int i = 0;
int j = 0;
for(int k = 0; k < dim - 1; k++) {
if(arf_cmp(x1, row_max[k]) < 0) {
arf_set(x1, row_max[k]);
i = k;
}
}
j = row_max_indices[i];
slong bound = arf_abs_bound_lt_2exp_si(x1);
if(bound < -prec * .9) {
finished = 1;
break;
}
else {
//printf("%ld\n", arf_abs_bound_lt_2exp_si(x1));
//arb_mat_printd(B, 10);
//printf("\n");
}
arf_twobytwo_diag(Gii, Gij, arb_midref(B(i,i)), arb_midref(B(i,j)), arb_midref(B(j,j)), 2*prec);
arf_neg(Gji, Gij);
arf_set(Gjj, Gii);
//printf("%d %d\n", i, j);
//arf_printd(Gii, 100);
//printf(" ");
//arf_printd(Gij, 100);
//printf("\n");
if(arf_is_zero(Gij)) { // If this happens, we're
finished = 1; // not going to do any better
break; // without increasing the precision.
}
for(int k = 0; k < dim; k++) {
arf_mul(B1[k], Gii, arb_midref(B(i,k)), prec, ARF_RND_NEAR);
arf_addmul(B1[k], Gji, arb_midref(B(j,k)), prec, ARF_RND_NEAR);
arf_mul(B2[k], Gij, arb_midref(B(i,k)), prec, ARF_RND_NEAR);
arf_addmul(B2[k], Gjj, arb_midref(B(j,k)), prec, ARF_RND_NEAR);
}
for(int k = 0; k < dim; k++) {
arf_set(arb_midref(B(i,k)), B1[k]);
arf_set(arb_midref(B(j,k)), B2[k]);
}
for(int k = 0; k < dim; k++) {
arf_mul(B1[k], Gii, arb_midref(B(k,i)), prec, ARF_RND_NEAR);
arf_addmul(B1[k], Gji, arb_midref(B(k,j)), prec, ARF_RND_NEAR);
arf_mul(B2[k], Gij, arb_midref(B(k,i)), prec, ARF_RND_NEAR);
arf_addmul(B2[k], Gjj, arb_midref(B(k,j)), prec, ARF_RND_NEAR);
}
for(int k = 0; k < dim; k++) {
arf_set(arb_midref(B(k,i)), B1[k]);
arf_set(arb_midref(B(k,j)), B2[k]);
}
for(int k = 0; k < dim; k++) {
arf_mul(B1[k], Gii, arb_midref(P(k,i)), prec, ARF_RND_NEAR);
arf_addmul(B1[k], Gji, arb_midref(P(k,j)), prec, ARF_RND_NEAR);
arf_mul(B2[k], Gij, arb_midref(P(k,i)), prec, ARF_RND_NEAR);
arf_addmul(B2[k], Gjj, arb_midref(P(k,j)), prec, ARF_RND_NEAR);
}
for(int k = 0; k < dim; k++) {
arf_set(arb_midref(P(k,i)), B1[k]);
arf_set(arb_midref(P(k,j)), B2[k]);
}
if(i < dim - 1)
arf_set_ui(row_max[i], 0);
if(j < dim - 1)
arf_set_ui(row_max[j], 0);
// Update the max in any row where the maximum
// was in a column that changed.
for(int k = 0; k < dim - 1; k++) {
if(row_max_indices[k] == j || row_max_indices[k] == i) {
arf_abs(row_max[k], arb_midref(B(k,k+1)));
row_max_indices[k] = k+1;
for(int l = k+2; l < dim; l++) {
arf_abs(x1, arb_midref(B(k,l)));
if(arf_cmp(row_max[k], x1) < 0) {
arf_set(row_max[k], x1);
row_max_indices[k] = l;
}
}
}
}
// Update the max in the ith row.
for(int k = i + 1; k < dim; k++) {
arf_abs(x1, arb_midref(B(i, k)));
if(arf_cmp(row_max[i], x1) < 0) {
arf_set(row_max[i], x1);
row_max_indices[i] = k;
}
}
// Update the max in the jth row.
for(int k = j + 1; k < dim; k++) {
arf_abs(x1, arb_midref(B(j, k)));
if(arf_cmp(row_max[j], x1) < 0) {
arf_set(row_max[j], x1);
row_max_indices[j] = k;
}
}
// Go through column i to see if any of
// the new entries are larger than the
// max of their row.
for(int k = 0; k < i; k++) {
if(k == dim) continue;
arf_abs(x1, arb_midref(B(k, i)));
if(arf_cmp(row_max[k], x1) < 0) {
arf_set(row_max[k], x1);
row_max_indices[k] = i;
}
}
// And then column j.
for(int k = 0; k < j; k++) {
if(k == dim) continue;
arf_abs(x1, arb_midref(B(k, j)));
if(arf_cmp(row_max[k], x1) < 0) {
arf_set(row_max[k], x1);
row_max_indices[k] = j;
}
}
}
for(int k = 0; k < dim; k++) {
arb_set(D(k), B(k,k));
arb_set_exact(D(k));
}
// At this point we've done that diagonalization and all that remains is
// to certify the correctness and compute error bounds.
arb_mat_t e;
arb_t error_norms[dim];
for(int k = 0; k < dim; k++) arb_init(error_norms[k]);
arb_mat_init(e, dim, 1);
arb_t z1, z2;
arb_init(z1);
arb_init(z2);
for(int j = 0; j < dim; j++) {
arb_mat_set(B, A);
for(int k = 0; k < dim; k++) {
arb_sub(B(k, k), B(k, k), D(j), prec);
}
for(int k = 0; k < dim; k++) {
arb_set(arb_mat_entry(e, k, 0), P(k, j));
}
arb_mat_L2norm(z2, e, prec);
arb_mat_mul(e, B, e, prec);
arb_mat_L2norm(error_norms[j], e, prec);
arb_div(z2, error_norms[j], z2, prec); // and now z1 is an upper bound for the
// error in the eigenvalue
arb_add_error(D(j), z2);
}
int unique_eigenvalues = 1;
for(int j = 0; j < dim; j++) {
if(j == 0) {
arb_sub(z1, D(j), D(1), prec);
}
else {
arb_sub(z1, D(j), D(0), prec);
}
arb_get_abs_lbound_arf(x1, z1, prec);
for(int k = 1; k < dim; k++) {
if(k == j) continue;
arb_sub(z1, D(j), D(k), prec);
arb_get_abs_lbound_arf(x2, z1, prec);
if(arf_cmp(x2, x1) < 0) {
arf_set(x1, x2);
}
}
if(arf_is_zero(x1)) {
unique_eigenvalues = 0;
}
arb_div_arf(z1, error_norms[j], x1, prec);
for(int k = 0; k < dim; k++) {
arb_add_error(P(k, j), z1);
}
}
arb_mat_clear(e);
arb_clear(z1);
arb_clear(z2);
for(int k = 0; k < dim; k++) arb_clear(error_norms[k]);
arf_clear(x1);
arf_clear(x2);
arb_mat_clear(B);
for(int k = 0; k < dim; k++) {
arf_clear(B1[k]);
arf_clear(B2[k]);
}
for(int k = 0; k < dim - 1; k++) {
arf_clear(row_max[k]);
}
arf_clear(Gii);
arf_clear(Gij);
arf_clear(Gji);
arf_clear(Gjj);
free(B1);
free(B2);
free(row_max);
free(row_max_indices);
if(unique_eigenvalues) return 0;
else return 1;
#undef B
#undef D
#undef P
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("get_mpn_fixed_mod_pi4....");
fflush(stdout);
flint_randinit(state);
/* _flint_rand_init_gmp(state); */
for (iter = 0; iter < 100000 * arb_test_multiplier(); iter++)
{
arf_t x;
int octant;
fmpz_t q;
mp_ptr w;
arb_t wb, t, u;
mp_size_t wn;
slong prec, prec2;
int success;
mp_limb_t error;
prec = 2 + n_randint(state, 10000);
wn = 1 + n_randint(state, 200);
prec2 = FLINT_MAX(prec, wn * FLINT_BITS) + 100;
arf_init(x);
arb_init(wb);
arb_init(t);
arb_init(u);
fmpz_init(q);
w = flint_malloc(sizeof(mp_limb_t) * wn);
arf_randtest(x, state, prec, 14);
/* this should generate numbers close to multiples of pi/4 */
if (n_randint(state, 4) == 0)
{
arb_const_pi(t, prec);
arb_mul_2exp_si(t, t, -2);
fmpz_randtest(q, state, 200);
arb_mul_fmpz(t, t, q, prec);
arf_add(x, x, arb_midref(t), prec, ARF_RND_DOWN);
}
arf_abs(x, x);
success = _arb_get_mpn_fixed_mod_pi4(w, q, &octant, &error, x, wn);
if (success)
{
/* could round differently */
if (fmpz_fdiv_ui(q, 8) != octant)
{
flint_printf("bad octant\n");
abort();
}
_arf_set_mpn_fixed(arb_midref(wb), w, wn, wn, 0, FLINT_BITS * wn, ARB_RND);
mag_set_ui_2exp_si(arb_radref(wb), error, -FLINT_BITS * wn);
arb_const_pi(u, prec2);
arb_mul_2exp_si(u, u, -2);
arb_set(t, wb);
if (octant % 2 == 1)
arb_sub(t, u, t, prec2);
arb_addmul_fmpz(t, u, q, prec2);
if (!arb_contains_arf(t, x))
{
flint_printf("FAIL (containment)\n");
flint_printf("x = "); arf_printd(x, 50); flint_printf("\n\n");
flint_printf("q = "); fmpz_print(q); flint_printf("\n\n");
flint_printf("w = "); arb_printd(wb, 50); flint_printf("\n\n");
flint_printf("t = "); arb_printd(t, 50); flint_printf("\n\n");
abort();
}
arb_const_pi(t, prec2);
arb_mul_2exp_si(t, t, -2);
if (arf_sgn(arb_midref(wb)) < 0 ||
arf_cmp(arb_midref(wb), arb_midref(t)) >= 0)
{
flint_printf("FAIL (expected 0 <= w < pi/4)\n");
flint_printf("x = "); arf_printd(x, 50); flint_printf("\n\n");
flint_printf("w = "); arb_printd(wb, 50); flint_printf("\n\n");
abort();
}
}
flint_free(w);
fmpz_clear(q);
arf_clear(x);
arb_clear(wb);
arb_clear(t);
arb_clear(u);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("get_abs_lbound_arf....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
arb_t x;
arf_t b, b2, b3;
fmpq_t q;
arb_init(x);
arf_init(b);
arf_init(b2);
arf_init(b3);
fmpq_init(q);
arb_randtest(x, state, 1 + n_randint(state, 200), 10);
arb_get_abs_lbound_arf(b, x, 2 + n_randint(state, 200));
arb_get_rand_fmpq(q, state, x, 1 + n_randint(state, 200));
arf_mul_fmpz(b2, b, fmpq_denref(q), ARF_PREC_EXACT, ARF_RND_DOWN);
arf_set_fmpz(b3, fmpq_numref(q));
arf_abs(b3, b3);
if (arf_cmp(b2, b3) > 0)
{
flint_printf("FAIL (abs_lbound):\n\n");
flint_printf("x = "); arb_print(x); flint_printf("\n\n");
flint_printf("q = "); fmpq_print(q); flint_printf("\n\n");
flint_printf("b = "); arf_print(b); flint_printf("\n\n");
flint_printf("b2 = "); arf_print(b2); flint_printf("\n\n");
flint_printf("b3 = "); arf_print(b3); flint_printf("\n\n");
flint_abort();
}
arb_get_abs_ubound_arf(b, x, 2 + n_randint(state, 200));
arb_get_rand_fmpq(q, state, x, 1 + n_randint(state, 200));
arf_mul_fmpz(b2, b, fmpq_denref(q), ARF_PREC_EXACT, ARF_RND_DOWN);
arf_set_fmpz(b3, fmpq_numref(q));
arf_abs(b3, b3);
if (arf_cmp(b2, b3) < 0)
{
flint_printf("FAIL (abs_ubound):\n\n");
flint_printf("x = "); arb_print(x); flint_printf("\n\n");
flint_printf("q = "); fmpq_print(q); flint_printf("\n\n");
flint_printf("b = "); arf_print(b); flint_printf("\n\n");
flint_printf("b2 = "); arf_print(b2); flint_printf("\n\n");
flint_printf("b3 = "); arf_print(b3); flint_printf("\n\n");
flint_abort();
}
arb_randtest_special(x, state, 1 + n_randint(state, 200), 1 + n_randint(state, 10));
arb_get_abs_lbound_arf(b, x, 2 + n_randint(state, 200));
arb_get_abs_ubound_arf(b2, x, 2 + n_randint(state, 200));
if (arf_cmp(b, b2) > 0)
{
flint_printf("FAIL:\n\n");
flint_printf("x = "); arb_print(x); flint_printf("\n\n");
flint_printf("b = "); arf_print(b); flint_printf("\n\n");
flint_printf("b2 = "); arf_print(b2); flint_printf("\n\n");
flint_abort();
}
arb_clear(x);
fmpq_clear(q);
arf_clear(b);
arf_clear(b2);
arf_clear(b3);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("can_round_mpfr....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000000; iter++)
{
mpfr_t x, y1, y2;
int r1, r2;
arb_t t;
slong prec;
mpfr_rnd_t rnd;
prec = 2 + n_randint(state, 300);
mpfr_init2(x, 2 + n_randint(state, 300));
mpfr_init2(y1, prec);
mpfr_init2(y2, prec);
arb_init(t);
switch (n_randint(state, 5))
{
case 0: rnd = MPFR_RNDN; break;
case 1: rnd = MPFR_RNDZ; break;
case 2: rnd = MPFR_RNDU; break;
case 3: rnd = MPFR_RNDD; break;
default: rnd = MPFR_RNDA;
}
arf_randtest(arb_midref(t), state, mpfr_get_prec(x), 1 + n_randint(state, 10));
arf_abs(arb_midref(t), arb_midref(t));
arf_get_mpfr(x, arb_midref(t), MPFR_RNDN);
arb_root_ui(t, t, 4, 2 + n_randint(state, 300));
if (arb_can_round_mpfr(t, prec, rnd))
{
r1 = mpfr_root(y1, x, 4, rnd);
r2 = arf_get_mpfr(y2, arb_midref(t), rnd);
if (r1 != r2 || !mpfr_equal_p(y1, y2))
{
flint_printf("FAIL! %ld\n");
flint_printf("r1 = %d, r2 = %d, prec = %wd\n", r1, r2, prec);
flint_printf("x = "); mpfr_dump(x); flint_printf("\n");
flint_printf("y1 = "); mpfr_dump(y1); flint_printf("\n");
flint_printf("y2 = "); mpfr_dump(y2); flint_printf("\n");
abort();
}
}
arb_clear(t);
mpfr_clear(x);
mpfr_clear(y1);
mpfr_clear(y2);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("sum....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 1000000 * arb_test_multiplier(); iter++)
{
slong i, len, prec, bits, expbits;
int res1, res2;
arf_t s1, s2, s3, err;
mag_t err_bound;
arf_struct terms[20];
arf_rnd_t rnd;
len = n_randint(state, 20);
bits = 2 + n_randint(state, 1000);
prec = 2 + n_randint(state, 1000);
expbits = n_randint(state, 14);
arf_init(s1);
arf_init(s2);
arf_init(s3);
arf_init(err);
mag_init(err_bound);
for (i = 0; i < len; i++)
{
arf_init(terms + i);
arf_randtest_special(terms + i, state, bits, expbits);
}
switch (n_randint(state, 4))
{
case 0: rnd = ARF_RND_DOWN; break;
case 1: rnd = ARF_RND_UP; break;
case 2: rnd = ARF_RND_FLOOR; break;
default: rnd = ARF_RND_CEIL; break;
}
res1 = arf_sum(s1, terms, len, prec, rnd);
arf_zero(s2);
for (i = 0; i < len; i++)
arf_add(s2, s2, terms + i, ARF_PREC_EXACT, ARF_RND_DOWN);
res2 = arf_set_round(s3, s2, prec, rnd);
if (!arf_equal(s1, s3) || res1 != res2)
{
flint_printf("FAIL (%wd)\n\n", iter);
flint_printf("prec = %wd\n\n", prec);
for (i = 0; i < len; i++)
{
flint_printf("terms[%wd] = ", i); arf_print(terms + i); flint_printf("\n\n");
}
flint_printf("s1 = "); arf_print(s1); flint_printf("\n\n");
flint_printf("s2 = "); arf_print(s2); flint_printf("\n\n");
flint_printf("s3 = "); arf_print(s3); flint_printf("\n\n");
flint_printf("res1 = %d, res2 = %d\n\n", res1, res2);
abort();
}
arf_sub(err, s1, s2, ARF_PREC_EXACT, ARF_RND_DOWN);
arf_abs(err, err);
if (res1)
arf_mag_set_ulp(err_bound, s1, prec);
else
mag_zero(err_bound);
if (arf_cmpabs_mag(err, err_bound) > 0)
{
flint_printf("FAIL (error bound)!\n");
flint_printf("prec = %wd\n\n", prec);
for (i = 0; i < len; i++)
{
flint_printf("terms[%wd] = ", i); arf_print(terms + i); flint_printf("\n\n");
}
flint_printf("s1 = "); arf_print(s1); flint_printf("\n\n");
flint_printf("s2 = "); arf_print(s2); flint_printf("\n\n");
flint_printf("s3 = "); arf_print(s3); flint_printf("\n\n");
flint_printf("error: "); arf_print(err); flint_printf("\n\n");
flint_printf("error bound: "); mag_print(err_bound); flint_printf("\n\n");
flint_printf("res1 = %d, res2 = %d\n\n", res1, res2);
abort();
}
arf_clear(s1);
arf_clear(s2);
arf_clear(s3);
arf_clear(err);
mag_clear(err_bound);
for (i = 0; i < len; i++)
arf_clear(terms + i);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
