void
acb_mat_transpose(acb_mat_t B, const acb_mat_t A)
{
slong i, j;
if (acb_mat_nrows(B) != acb_mat_ncols(A) || acb_mat_ncols(B) != acb_mat_nrows(A))
{
flint_printf("Exception (acb_mat_transpose). Incompatible dimensions.\n");
flint_abort();
}
if (acb_mat_is_empty(A))
return;
if (A == B) /* In-place, guaranteed to be square */
{
for (i = 0; i < acb_mat_nrows(A) - 1; i++)
{
for (j = i + 1; j < acb_mat_ncols(A); j++)
{
acb_swap(acb_mat_entry(A, i, j), acb_mat_entry(A, j, i));
}
}
}
else /* Not aliased; general case */
{
for (i = 0; i < acb_mat_nrows(B); i++)
for (j = 0; j < acb_mat_ncols(B); j++)
acb_set(acb_mat_entry(B, i, j), acb_mat_entry(A, j, i));
}
}
void
acb_mat_neg(acb_mat_t dest, const acb_mat_t src)
{
slong i, j;
for (i = 0; i < acb_mat_nrows(src); i++)
for (j = 0; j < acb_mat_ncols(src); j++)
acb_neg(acb_mat_entry(dest, i, j),
acb_mat_entry(src, i, j));
}
void
acb_mat_one(acb_mat_t mat)
{
slong i, j;
for (i = 0; i < acb_mat_nrows(mat); i++)
for (j = 0; j < acb_mat_ncols(mat); j++)
if (i == j)
acb_one(acb_mat_entry(mat, i, j));
else
acb_zero(acb_mat_entry(mat, i, j));
}
void
acb_mat_set(acb_mat_t dest, const acb_mat_t src)
{
slong i, j;
if (dest != src && acb_mat_ncols(src) != 0)
{
for (i = 0; i < acb_mat_nrows(src); i++)
for (j = 0; j < acb_mat_ncols(src); j++)
acb_set(acb_mat_entry(dest, i, j),
acb_mat_entry(src, i, j));
}
}
void
acb_mat_pow_ui(acb_mat_t B, const acb_mat_t A, ulong exp, long prec)
{
long d = acb_mat_nrows(A);
if (exp <= 2 || d <= 1)
{
if (exp == 0 || d == 0)
{
acb_mat_one(B);
}
else if (d == 1)
{
acb_pow_ui(acb_mat_entry(B, 0, 0),
acb_mat_entry(A, 0, 0), exp, prec);
}
else if (exp == 1)
{
acb_mat_set(B, A);
}
else if (exp == 2)
{
acb_mat_mul(B, A, A, prec); /* todo: sqr */
}
}
else
{
acb_mat_t T, U;
long i;
acb_mat_init(T, d, d);
acb_mat_set(T, A);
acb_mat_init(U, d, d);
for (i = ((long) FLINT_BIT_COUNT(exp)) - 2; i >= 0; i--)
{
acb_mat_mul(U, T, T, prec); /* todo: sqr */
if (exp & (1L << i))
acb_mat_mul(T, U, A, prec);
else
acb_mat_swap(T, U);
}
acb_mat_swap(B, T);
acb_mat_clear(T);
acb_mat_clear(U);
}
}
int
acb_mat_contains(const acb_mat_t mat1, const acb_mat_t mat2)
{
slong i, j;
if ((acb_mat_nrows(mat1) != acb_mat_nrows(mat2)) ||
(acb_mat_ncols(mat1) != acb_mat_ncols(mat2)))
return 0;
for (i = 0; i < acb_mat_nrows(mat1); i++)
for (j = 0; j < acb_mat_ncols(mat1); j++)
if (!acb_contains(acb_mat_entry(mat1, i, j), acb_mat_entry(mat2, i, j)))
return 0;
return 1;
}
int
acb_mat_is_real(const acb_mat_t mat)
{
slong i, j;
for (i = 0; i < acb_mat_nrows(mat); i++)
for (j = 0; j < acb_mat_ncols(mat); j++)
if (!acb_is_real(acb_mat_entry(mat, i, j)))
return 0;
return 1;
}
void
acb_mat_ones(acb_mat_t mat)
{
slong R, C, i, j;
R = acb_mat_nrows(mat);
C = acb_mat_ncols(mat);
for (i = 0; i < R; i++)
for (j = 0; j < C; j++)
acb_one(acb_mat_entry(mat, i, j));
}
void
acb_mat_mul_entrywise(acb_mat_t C, const acb_mat_t A, const acb_mat_t B, slong prec)
{
slong i, j;
if (acb_mat_nrows(A) != acb_mat_nrows(B) ||
acb_mat_ncols(A) != acb_mat_ncols(B))
{
flint_printf("acb_mat_mul_entrywise: incompatible dimensions\n");
abort();
}
for (i = 0; i < acb_mat_nrows(A); i++)
{
for (j = 0; j < acb_mat_ncols(A); j++)
{
acb_mul(acb_mat_entry(C, i, j),
acb_mat_entry(A, i, j),
acb_mat_entry(B, i, j), prec);
}
}
}
void
acb_mat_set_round_fmpz_mat(acb_mat_t dest, const fmpz_mat_t src, slong prec)
{
slong i, j;
if (acb_mat_ncols(dest) != 0)
{
for (i = 0; i < acb_mat_nrows(dest); i++)
for (j = 0; j < acb_mat_ncols(dest); j++)
acb_set_round_fmpz(acb_mat_entry(dest, i, j),
fmpz_mat_entry(src, i, j), prec);
}
}
void
acb_mat_approx_solve_triu_classical(acb_mat_t X, const acb_mat_t U,
const acb_mat_t B, int unit, slong prec)
{
slong i, j, n, m;
acb_ptr tmp;
acb_t s, t;
n = U->r;
m = B->c;
acb_init(s);
acb_init(t);
tmp = flint_malloc(sizeof(acb_struct) * n);
for (i = 0; i < m; i++)
{
for (j = 0; j < n; j++)
tmp[j] = *acb_mat_entry(X, j, i);
for (j = n - 1; j >= 0; j--)
{
acb_approx_dot(s, acb_mat_entry(B, j, i), 1, U->rows[j] + j + 1, 1, tmp + j + 1, 1, n - j - 1, prec);
if (!unit)
acb_approx_div(tmp + j, s, arb_mat_entry(U, j, j), t, prec);
else
acb_swap(tmp + j, s);
}
for (j = 0; j < n; j++)
*acb_mat_entry(X, j, i) = tmp[j];
}
flint_free(tmp);
acb_clear(s);
acb_clear(t);
}
void
acb_mat_det(acb_t det, const acb_mat_t A, slong prec)
{
slong n;
if (!acb_mat_is_square(A))
{
flint_printf("acb_mat_det: a square matrix is required!\n");
flint_abort();
}
n = acb_mat_nrows(A);
if (n == 0)
{
acb_one(det);
}
else if (n == 1)
{
acb_set_round(det, acb_mat_entry(A, 0, 0), prec);
}
else if (n == 2)
{
_acb_mat_det_cofactor_2x2(det, A, prec);
}
else if (!acb_mat_is_finite(A))
{
acb_indeterminate(det);
}
else if (acb_mat_is_tril(A) || acb_mat_is_triu(A))
{
acb_mat_diag_prod(det, A, prec);
}
else if (n == 3)
{
_acb_mat_det_cofactor_3x3(det, A, prec);
/* note: 4x4 performs worse than LU */
}
else
{
if (n <= 14 || prec > 10.0 * n)
acb_mat_det_lu(det, A, prec);
else
acb_mat_det_precond(det, A, prec);
}
}
void
acb_mat_mul(acb_mat_t C, const acb_mat_t A, const acb_mat_t B, slong prec)
{
slong ar, ac, br, bc, i, j, k;
ar = acb_mat_nrows(A);
ac = acb_mat_ncols(A);
br = acb_mat_nrows(B);
bc = acb_mat_ncols(B);
if (ac != br || ar != acb_mat_nrows(C) || bc != acb_mat_ncols(C))
{
flint_printf("acb_mat_mul: incompatible dimensions\n");
abort();
}
if (br == 0)
{
acb_mat_zero(C);
return;
}
if (A == C || B == C)
{
acb_mat_t T;
acb_mat_init(T, ar, bc);
acb_mat_mul(T, A, B, prec);
acb_mat_swap(T, C);
acb_mat_clear(T);
return;
}
for (i = 0; i < ar; i++)
{
for (j = 0; j < bc; j++)
{
acb_mul(acb_mat_entry(C, i, j),
acb_mat_entry(A, i, 0),
acb_mat_entry(B, 0, j), prec);
for (k = 1; k < br; k++)
{
acb_addmul(acb_mat_entry(C, i, j),
acb_mat_entry(A, i, k),
acb_mat_entry(B, k, j), prec);
}
}
}
}
void
_acb_mat_diag_prod(acb_t res, const acb_mat_t A, slong a, slong b, slong prec)
{
if (b - a == 0)
acb_one(res);
else if (b - a == 1)
acb_set_round(res, acb_mat_entry(A, a, a), prec);
else if (b - a == 2)
acb_mul(res, acb_mat_entry(A, a, a), acb_mat_entry(A, a + 1, a + 1), prec);
else if (b - a == 3)
{
acb_mul(res, acb_mat_entry(A, a, a), acb_mat_entry(A, a + 1, a + 1), prec);
acb_mul(res, res, acb_mat_entry(A, a + 2, a + 2), prec);
}
else
{
acb_t t;
acb_init(t);
_acb_mat_diag_prod(t, A, a, a + (b - a) / 2, prec);
_acb_mat_diag_prod(res, A, a + (b - a) / 2, b, prec);
acb_mul(res, res, t, prec);
acb_clear(t);
}
}
void
check_periods()
{
FILE * fp;
int ip, f, in, im;
int flag = 0;
flint_printf("periods...");
fflush(stdout);
fp = fopen("ref_periods.txt", "r");
if (fp == NULL)
abort();
for (ip = 0; ip < nm; ip++)
{
slong prec = vp[ip];
acb_t ref;
acb_init(ref);
for (f = 0; f < nf; f++)
{
for (in = 0; in < nn; in++)
{
fmpz_poly_t pol;
fmpz_poly_init(pol);
vf[f](pol, vn[in]);
for (im = 0; im < nm; im++)
{
slong c;
abel_jacobi_t aj;
abel_jacobi_init_poly(aj, vm[im], pol);
abel_jacobi_compute(aj, flag, prec);
/* check 4 entries of each matrix */
for (c = 0; c < nc; c++)
{
acb_ptr coeff;
acb_get_file(ref, fp, prec);
coeff = acb_mat_entry(aj->omega0, c % 2, c / 2);
if (!acb_overlaps(ref, coeff))
{
flint_printf("FAIL:\n\n");
flint_printf("pol = ");
fmpz_poly_print(pol);
flint_printf("\nn = %ld, m = %ld, prec = %ld\n", vn[in], vm[im], prec);
flint_printf("\nref = ");
acb_printd(ref, 20);
flint_printf("\nperiod = ");
acb_printd(coeff, 20);
flint_printf("\n\n");
abort();
}
}
abel_jacobi_clear(aj);
}
fmpz_poly_clear(pol);
}
}
acb_clear(ref);
}
fclose(fp);
flint_cleanup();
printf("PASS\n");
}
static void
_acb_mat_det_cofactor_3x3(acb_t t, const acb_mat_t A, slong prec)
{
acb_t a;
acb_init(a);
acb_mul (a, acb_mat_entry(A, 1, 0), acb_mat_entry(A, 2, 1), prec);
acb_submul(a, acb_mat_entry(A, 1, 1), acb_mat_entry(A, 2, 0), prec);
acb_mul (t, a, acb_mat_entry(A, 0, 2), prec);
acb_mul (a, acb_mat_entry(A, 1, 2), acb_mat_entry(A, 2, 0), prec);
acb_submul(a, acb_mat_entry(A, 1, 0), acb_mat_entry(A, 2, 2), prec);
acb_addmul(t, a, acb_mat_entry(A, 0, 1), prec);
acb_mul (a, acb_mat_entry(A, 1, 1), acb_mat_entry(A, 2, 2), prec);
acb_submul(a, acb_mat_entry(A, 1, 2), acb_mat_entry(A, 2, 1), prec);
acb_addmul(t, a, acb_mat_entry(A, 0, 0), prec);
acb_clear(a);
}
int main() {
slong d, i;
slong prec = 60;
flint_rand_t state;
flint_printf("integration parameters...");
fflush(stdout);
flint_randinit(state);
for (d = 3; d < 30; d++)
{
slong f;
acb_mat_t pols;
slong nmin[nf], nmax[nf];
double nmed[nf];
mag_t e_de, e_gc;
arf_t h, l;
arf_init(h);
arf_init(l);
mag_init(e_gc);
mag_init(e_de);
acb_mat_init(pols, imax, d);
/* create imax random examples */
for (i = 0; i < imax; i++)
acb_vec_set_random_u(pols->rows[i], d, state, prec, 4, .01);
/* compute integration parameters */
for (f = 0; f < nf; f++)
{
nmed[f] = 0.; nmin[f] = LONG_MAX; nmax[f] = 0;
for (i = 0; i < imax; i++)
{
slong n;
#if 0
flint_printf("\nd = %ld, i = %ld, %6s\n", d, i, f ? "de" : "gauss");
for (n = 0; n < d; n++)
flint_printf("\nu_%ld = ", n),
acb_printd(acb_mat_entry(pols, i, n), 10);
#endif
if (f == 0)
n = gc_params(e_gc, pols->rows[i], d, 0, prec);
else
n = de_params(e_de, h, l, pols->rows[i], d, 0., 0, 1, 2, prec);
nmed[f] += n;
if (n < nmin[f]) nmin[f] = n;
if (n > nmax[f]) nmax[f] = n;
}
nmed[f] /= imax;
flint_printf("\n%6s: d = %3ld, min, max, med = %3ld, %8ld, %8.3lf",
f ? "de" : "gauss", d, nmin[f], nmax[f], nmed[f]);
}
acb_mat_clear(pols);
arf_clear(h);
arf_clear(l);
mag_clear(e_gc);
mag_clear(e_de);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return 0;
}
int
acb_mat_eig_simple_rump(acb_ptr E, acb_mat_t L, acb_mat_t R,
const acb_mat_t A, acb_srcptr E_approx, const acb_mat_t R_approx, slong prec)
{
slong i, j, n;
acb_mat_t X, R2;
int result;
n = acb_mat_nrows(A);
if (n == 0)
return 1;
if (n == 1)
{
acb_set_round(E, acb_mat_entry(A, 0, 0), prec);
if (L != NULL)
acb_one(acb_mat_entry(L, 0, 0));
if (R != NULL)
acb_one(acb_mat_entry(R, 0, 0));
return 1;
}
acb_mat_init(X, n, 1);
acb_mat_init(R2, n, n);
result = 1;
for (i = 0; i < n && result; i++)
{
for (j = 0; j < n; j++)
acb_set(acb_mat_entry(X, j, 0), acb_mat_entry(R_approx, j, i));
acb_mat_eig_enclosure_rump(E + i, NULL, X, A, E_approx + i, X, prec);
if (!acb_is_finite(E + i))
result = 0;
for (j = 0; j < i; j++)
if (acb_overlaps(E + i, E + j))
result = 0;
for (j = 0; j < n; j++)
acb_set(acb_mat_entry(R2, j, i), acb_mat_entry(X, j, 0));
}
if (R != NULL)
{
if (result)
acb_mat_set(R, R2);
else
acb_mat_indeterminate(R);
}
if (L != NULL)
{
if (!result || !acb_mat_inv(L, R, prec))
acb_mat_indeterminate(L);
}
if (!result)
_acb_vec_indeterminate(E, n);
acb_mat_clear(X);
acb_mat_clear(R2);
return result;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("lu....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000; iter++)
{
fmpq_mat_t Q;
acb_mat_t A, LU, P, L, U, T;
slong i, j, n, qbits, prec, *perm;
int q_invertible, r_invertible;
n = n_randint(state, 8);
qbits = 1 + n_randint(state, 100);
prec = 2 + n_randint(state, 202);
fmpq_mat_init(Q, n, n);
acb_mat_init(A, n, n);
acb_mat_init(LU, n, n);
acb_mat_init(P, n, n);
acb_mat_init(L, n, n);
acb_mat_init(U, n, n);
acb_mat_init(T, n, n);
perm = _perm_init(n);
fmpq_mat_randtest(Q, state, qbits);
q_invertible = fmpq_mat_is_invertible(Q);
if (!q_invertible)
{
acb_mat_set_fmpq_mat(A, Q, prec);
r_invertible = acb_mat_lu(perm, LU, A, 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("A = \n"); acb_mat_printd(A, 15); flint_printf("\n\n");
flint_printf("LU = \n"); acb_mat_printd(LU, 15); flint_printf("\n\n");
}
}
else
{
/* now this must converge */
while (1)
{
acb_mat_set_fmpq_mat(A, Q, prec);
r_invertible = acb_mat_lu(perm, LU, A, prec);
if (r_invertible)
{
break;
}
else
{
if (prec > 10000)
{
flint_printf("FAIL: failed to converge at 10000 bits\n");
abort();
}
prec *= 2;
}
}
acb_mat_one(L);
for (i = 0; i < n; i++)
for (j = 0; j < i; j++)
acb_set(acb_mat_entry(L, i, j),
acb_mat_entry(LU, i, j));
for (i = 0; i < n; i++)
for (j = i; j < n; j++)
acb_set(acb_mat_entry(U, i, j),
acb_mat_entry(LU, i, j));
for (i = 0; i < n; i++)
acb_one(acb_mat_entry(P, perm[i], i));
acb_mat_mul(T, P, L, prec);
acb_mat_mul(T, T, U, prec);
if (!acb_mat_contains_fmpq_mat(T, Q))
{
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("A = \n"); acb_mat_printd(A, 15); flint_printf("\n\n");
flint_printf("LU = \n"); acb_mat_printd(LU, 15); flint_printf("\n\n");
flint_printf("L = \n"); acb_mat_printd(L, 15); flint_printf("\n\n");
flint_printf("U = \n"); acb_mat_printd(U, 15); flint_printf("\n\n");
flint_printf("P*L*U = \n"); acb_mat_printd(T, 15); flint_printf("\n\n");
abort();
}
}
fmpq_mat_clear(Q);
acb_mat_clear(A);
acb_mat_clear(LU);
acb_mat_clear(P);
acb_mat_clear(L);
acb_mat_clear(U);
acb_mat_clear(T);
_perm_clear(perm);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
static void
_acb_mat_det_cofactor_2x2(acb_t t, const acb_mat_t A, slong prec)
{
acb_mul (t, acb_mat_entry(A, 0, 0), acb_mat_entry(A, 1, 1), prec);
acb_submul(t, acb_mat_entry(A, 0, 1), acb_mat_entry(A, 1, 0), prec);
}
