int main()
{
long iter;
flint_rand_t state;
printf("transpose....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000; iter++)
{
long m, n;
acb_mat_t a, b, c;
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(c, m, n);
acb_mat_randtest(a, state, 2 + n_randint(state, 100), 10);
acb_mat_randtest(b, state, 2 + n_randint(state, 100), 10);
acb_mat_randtest(c, state, 2 + n_randint(state, 100), 10);
acb_mat_transpose(b, a);
acb_mat_transpose(c, b);
if (!acb_mat_equal(c, a))
{
printf("FAIL\n\n");
printf("m = %ld, n = %ld\n", m, n);
abort();
}
if (acb_mat_nrows(a) == acb_mat_ncols(a))
{
acb_mat_transpose(c, a);
acb_mat_transpose(a, a);
if (!acb_mat_equal(a, c))
{
printf("FAIL (aliasing)\n\n");
abort();
}
}
acb_mat_clear(a);
acb_mat_clear(b);
acb_mat_clear(c);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
void
_acb_poly_compose_series_brent_kung(acb_ptr res,
acb_srcptr poly1, long len1,
acb_srcptr poly2, long len2, long n, long prec)
{
acb_mat_t A, B, C;
acb_ptr t, h;
long i, m;
if (n == 1)
{
acb_set(res, poly1);
return;
}
m = n_sqrt(n) + 1;
acb_mat_init(A, m, n);
acb_mat_init(B, m, m);
acb_mat_init(C, m, n);
h = _acb_vec_init(n);
t = _acb_vec_init(n);
/* Set rows of B to the segments of poly1 */
for (i = 0; i < len1 / m; i++)
_acb_vec_set(B->rows[i], poly1 + i*m, m);
_acb_vec_set(B->rows[i], poly1 + i*m, len1 % m);
/* Set rows of A to powers of poly2 */
acb_set_ui(A->rows[0] + 0, 1UL);
_acb_vec_set(A->rows[1], poly2, len2);
for (i = 2; i < m; i++)
_acb_poly_mullow(A->rows[i], A->rows[(i + 1) / 2], n, A->rows[i / 2], n, n, prec);
acb_mat_mul(C, B, A, prec);
/* Evaluate block composition using the Horner scheme */
_acb_vec_set(res, C->rows[m - 1], n);
_acb_poly_mullow(h, A->rows[m - 1], n, poly2, len2, n, prec);
for (i = m - 2; i >= 0; i--)
{
_acb_poly_mullow(t, res, n, h, n, n, prec);
_acb_poly_add(res, t, n, C->rows[i], n, prec);
}
_acb_vec_clear(h, n);
_acb_vec_clear(t, n);
acb_mat_clear(A);
acb_mat_clear(B);
acb_mat_clear(C);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("dft....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 100 * arb_test_multiplier(); iter++)
{
acb_mat_t A, Ainv, AT;
slong n, prec;
n = n_randint(state, 10);
prec = 53 + n_randint(state, 30);
acb_mat_init(A, n, n);
acb_mat_init(Ainv, n, n);
acb_mat_init(AT, n, n);
acb_mat_randtest(A, state, 100, 10);
acb_mat_dft(A, 0, prec);
if (!acb_mat_inv(Ainv, A, prec))
{
flint_printf("FAIL: small DFT matrix (n = %wd) not invertible\n", n);
flint_abort();
}
acb_mat_conjugate_transpose(AT, A);
if (!acb_mat_overlaps(AT, Ainv))
{
flint_printf("FAIL: overlap (n = %wd)\n", n);
flint_printf("A = \n"); acb_mat_printd(A, 15); flint_printf("\n\n");
flint_printf("Ainv = \n"); acb_mat_printd(Ainv, 15); flint_printf("\n\n");
flint_printf("AT = \n"); acb_mat_printd(AT, 15); flint_printf("\n\n");
flint_abort();
}
acb_mat_clear(A);
acb_mat_clear(Ainv);
acb_mat_clear(AT);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
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_solve(acb_mat_t X, const acb_mat_t A, const acb_mat_t B, slong prec)
{
int result;
slong n, m, *perm;
acb_mat_t LU;
n = acb_mat_nrows(A);
m = acb_mat_ncols(X);
if (n == 0 || m == 0)
return 1;
perm = _perm_init(n);
acb_mat_init(LU, n, n);
result = acb_mat_lu(perm, LU, A, prec);
if (result)
acb_mat_solve_lu_precomp(X, perm, LU, B, prec);
acb_mat_clear(LU);
_perm_clear(perm);
return result;
}
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);
}
}
}
}
int
acb_mat_inv(acb_mat_t X, const acb_mat_t A, long prec)
{
if (X == A)
{
int r;
acb_mat_t T;
acb_mat_init(T, acb_mat_nrows(A), acb_mat_ncols(A));
r = acb_mat_inv(T, A, prec);
acb_mat_swap(T, X);
acb_mat_clear(T);
return r;
}
acb_mat_one(X);
return acb_mat_solve(X, A, X, prec);
}
void
acb_mat_approx_solve_triu_recursive(acb_mat_t X,
const acb_mat_t U, const acb_mat_t B, int unit, slong prec)
{
acb_mat_t UA, UB, UD, XX, XY, BX, BY, T;
slong r, n, m;
n = U->r;
m = B->c;
r = n / 2;
if (n == 0 || m == 0)
return;
/*
Denoting inv(M) by M^, we have:
[A B]^ [X] == [A^ (X - B D^ Y)]
[0 D] [Y] == [ D^ Y ]
*/
acb_mat_window_init(UA, U, 0, 0, r, r);
acb_mat_window_init(UB, U, 0, r, r, n);
acb_mat_window_init(UD, U, r, r, n, n);
acb_mat_window_init(BX, B, 0, 0, r, m);
acb_mat_window_init(BY, B, r, 0, n, m);
acb_mat_window_init(XX, X, 0, 0, r, m);
acb_mat_window_init(XY, X, r, 0, n, m);
acb_mat_approx_solve_triu(XY, UD, BY, unit, prec);
acb_mat_init(T, UB->r, XY->c);
acb_mat_approx_mul(T, UB, XY, prec);
acb_mat_sub(XX, BX, T, prec);
acb_mat_get_mid(XX, XX);
acb_mat_clear(T);
acb_mat_approx_solve_triu(XX, UA, XX, unit, prec);
acb_mat_window_clear(UA);
acb_mat_window_clear(UB);
acb_mat_window_clear(UD);
acb_mat_window_clear(BX);
acb_mat_window_clear(BY);
acb_mat_window_clear(XX);
acb_mat_window_clear(XY);
}
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;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("inv....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000; iter++)
{
fmpq_mat_t Q, Qinv;
acb_mat_t A, Ainv;
slong n, qbits, prec;
int q_invertible, r_invertible, r_invertible2;
n = 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(Qinv, n, n);
acb_mat_init(A, n, n);
acb_mat_init(Ainv, n, n);
fmpq_mat_randtest(Q, state, qbits);
q_invertible = fmpq_mat_inv(Qinv, Q);
if (!q_invertible)
{
acb_mat_set_fmpq_mat(A, Q, prec);
r_invertible = acb_mat_inv(Ainv, 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("Ainv = \n"); acb_mat_printd(Ainv, 15); flint_printf("\n\n");
abort();
}
}
else
{
/* now this must converge */
while (1)
{
acb_mat_set_fmpq_mat(A, Q, prec);
r_invertible = acb_mat_inv(Ainv, A, 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("A = \n"); acb_mat_printd(A, 15); flint_printf("\n\n");
abort();
}
prec *= 2;
}
}
if (!acb_mat_contains_fmpq_mat(Ainv, Qinv))
{
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("Qinv = \n"); fmpq_mat_print(Qinv); flint_printf("\n\n");
flint_printf("A = \n"); acb_mat_printd(A, 15); flint_printf("\n\n");
flint_printf("Ainv = \n"); acb_mat_printd(Ainv, 15); flint_printf("\n\n");
abort();
}
/* test aliasing */
r_invertible2 = acb_mat_inv(A, A, prec);
if (!acb_mat_equal(A, Ainv) || r_invertible != r_invertible2)
{
flint_printf("FAIL (aliasing)\n");
flint_printf("A = \n"); acb_mat_printd(A, 15); flint_printf("\n\n");
flint_printf("Ainv = \n"); acb_mat_printd(Ainv, 15); flint_printf("\n\n");
abort();
}
}
fmpq_mat_clear(Q);
fmpq_mat_clear(Qinv);
acb_mat_clear(A);
acb_mat_clear(Ainv);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("sqr....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
slong n, qbits1, rbits1, rbits2;
fmpq_mat_t A, B;
acb_mat_t a, b, c;
qbits1 = 2 + n_randint(state, 200);
rbits1 = 2 + n_randint(state, 200);
rbits2 = 2 + n_randint(state, 200);
n = n_randint(state, 10);
fmpq_mat_init(A, n, n);
fmpq_mat_init(B, n, n);
acb_mat_init(a, n, n);
acb_mat_init(b, n, n);
acb_mat_init(c, n, n);
fmpq_mat_randtest(A, state, qbits1);
fmpq_mat_mul(B, A, A);
acb_mat_set_fmpq_mat(a, A, rbits1);
acb_mat_sqr(b, a, rbits2);
if (!acb_mat_contains_fmpq_mat(b, B))
{
flint_printf("FAIL\n\n");
flint_printf("n = %wd, bits2 = %wd\n", n, rbits2);
flint_printf("A = "); fmpq_mat_print(A); flint_printf("\n\n");
flint_printf("B = "); fmpq_mat_print(B); flint_printf("\n\n");
flint_printf("a = "); acb_mat_printd(a, 15); flint_printf("\n\n");
flint_printf("b = "); acb_mat_printd(b, 15); flint_printf("\n\n");
abort();
}
/* test aliasing */
acb_mat_set(c, a);
acb_mat_sqr(c, c, rbits2);
if (!acb_mat_equal(c, b))
{
flint_printf("FAIL (aliasing)\n\n");
abort();
}
fmpq_mat_clear(A);
fmpq_mat_clear(B);
acb_mat_clear(a);
acb_mat_clear(b);
acb_mat_clear(c);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
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("mul_threaded....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 5000 * arb_test_multiplier(); iter++)
{
slong m, n, k, qbits1, qbits2, rbits1, rbits2, rbits3;
fmpq_mat_t A, B, C;
acb_mat_t a, b, c, d;
flint_set_num_threads(1 + n_randint(state, 5));
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);
m = n_randint(state, 10);
n = n_randint(state, 10);
k = n_randint(state, 10);
fmpq_mat_init(A, m, n);
fmpq_mat_init(B, n, k);
fmpq_mat_init(C, m, k);
acb_mat_init(a, m, n);
acb_mat_init(b, n, k);
acb_mat_init(c, m, k);
acb_mat_init(d, m, k);
fmpq_mat_randtest(A, state, qbits1);
fmpq_mat_randtest(B, state, qbits2);
fmpq_mat_mul(C, A, B);
acb_mat_set_fmpq_mat(a, A, rbits1);
acb_mat_set_fmpq_mat(b, B, rbits2);
acb_mat_mul_threaded(c, a, b, rbits3);
if (!acb_mat_contains_fmpq_mat(c, C))
{
flint_printf("FAIL\n\n");
flint_printf("threads = %d, m = %wd, n = %wd, k = %wd, bits3 = %wd\n",
flint_get_num_threads(), m, n, k, rbits3);
flint_printf("A = "); fmpq_mat_print(A); flint_printf("\n\n");
flint_printf("B = "); fmpq_mat_print(B); flint_printf("\n\n");
flint_printf("C = "); fmpq_mat_print(C); flint_printf("\n\n");
flint_printf("a = "); acb_mat_printd(a, 15); flint_printf("\n\n");
flint_printf("b = "); acb_mat_printd(b, 15); flint_printf("\n\n");
flint_printf("c = "); acb_mat_printd(c, 15); flint_printf("\n\n");
flint_abort();
}
/* test aliasing with a */
if (acb_mat_nrows(a) == acb_mat_nrows(c) &&
acb_mat_ncols(a) == acb_mat_ncols(c))
{
acb_mat_set(d, a);
acb_mat_mul_threaded(d, d, b, rbits3);
if (!acb_mat_equal(d, c))
{
flint_printf("FAIL (aliasing 1)\n\n");
flint_abort();
}
}
/* test aliasing with b */
if (acb_mat_nrows(b) == acb_mat_nrows(c) &&
acb_mat_ncols(b) == acb_mat_ncols(c))
{
acb_mat_set(d, b);
acb_mat_mul_threaded(d, a, d, rbits3);
if (!acb_mat_equal(d, c))
{
flint_printf("FAIL (aliasing 2)\n\n");
flint_abort();
}
}
fmpq_mat_clear(A);
fmpq_mat_clear(B);
fmpq_mat_clear(C);
acb_mat_clear(a);
acb_mat_clear(b);
acb_mat_clear(c);
acb_mat_clear(d);
}
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 < 10000 * arb_test_multiplier(); iter++)
{
slong m, n, k, qbits1, qbits2, rbits1, rbits2, rbits3;
fmpq_mat_t A, B, C;
acb_mat_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);
m = n_randint(state, 10);
n = n_randint(state, 10);
k = n_randint(state, 10);
fmpq_mat_init(A, m, n);
fmpq_mat_init(B, n, k);
fmpq_mat_init(C, m, k);
acb_mat_init(a, m, n);
acb_mat_init(b, n, k);
acb_mat_init(c, m, k);
acb_mat_init(d, m, k);
fmpq_mat_randtest(A, state, qbits1);
fmpq_mat_randtest(B, state, qbits2);
fmpq_mat_mul(C, A, B);
acb_mat_set_fmpq_mat(a, A, rbits1);
acb_mat_set_fmpq_mat(b, B, rbits2);
acb_mat_mul(c, a, b, rbits3);
if (!acb_mat_contains_fmpq_mat(c, C))
{
flint_printf("FAIL\n\n");
flint_printf("m = %wd, n = %wd, k = %wd, bits3 = %wd\n", m, n, k, rbits3);
flint_printf("A = "); fmpq_mat_print(A); flint_printf("\n\n");
flint_printf("B = "); fmpq_mat_print(B); flint_printf("\n\n");
flint_printf("C = "); fmpq_mat_print(C); flint_printf("\n\n");
flint_printf("a = "); acb_mat_printd(a, 15); flint_printf("\n\n");
flint_printf("b = "); acb_mat_printd(b, 15); flint_printf("\n\n");
flint_printf("c = "); acb_mat_printd(c, 15); flint_printf("\n\n");
abort();
}
/* test aliasing with a */
if (acb_mat_nrows(a) == acb_mat_nrows(c) &&
acb_mat_ncols(a) == acb_mat_ncols(c))
{
acb_mat_set(d, a);
acb_mat_mul(d, d, b, rbits3);
if (!acb_mat_equal(d, c))
{
flint_printf("FAIL (aliasing 1)\n\n");
abort();
}
}
/* test aliasing with b */
if (acb_mat_nrows(b) == acb_mat_nrows(c) &&
acb_mat_ncols(b) == acb_mat_ncols(c))
{
acb_mat_set(d, b);
acb_mat_mul(d, a, d, rbits3);
if (!acb_mat_equal(d, c))
{
flint_printf("FAIL (aliasing 2)\n\n");
abort();
}
}
fmpq_mat_clear(A);
fmpq_mat_clear(B);
fmpq_mat_clear(C);
acb_mat_clear(a);
acb_mat_clear(b);
acb_mat_clear(c);
acb_mat_clear(d);
}
/* check algebraic properties like associativity and distributivity */
for (iter = 0; iter < 1000 * arb_test_multiplier(); iter++)
{
slong m, n, k, l;
slong rbits;
acb_mat_t a, b, c, d, ab, ac, bd, cd, s;
rbits = 2 + n_randint(state, 200);
m = n_randint(state, 10);
n = n_randint(state, 10);
k = n_randint(state, 10);
l = n_randint(state, 10);
_acb_mat_init_randtest(a, m, n, state);
_acb_mat_init_randtest(b, n, k, state);
_acb_mat_init_randtest(c, n, k, state);
_acb_mat_init_randtest(d, k, l, state);
acb_mat_init(ab, m, k);
acb_mat_init(ac, m, k);
acb_mat_init(bd, n, l);
acb_mat_init(cd, n, l);
acb_mat_init(s, n, k);
acb_mat_mul(ab, a, b, rbits);
acb_mat_mul(ac, a, c, rbits);
acb_mat_mul(bd, b, d, rbits);
acb_mat_mul(cd, c, d, rbits);
acb_mat_add(s, b, c, rbits);
/* check associativity of multiplication */
/* (A*B)*D = A*(B*D) */
{
acb_mat_t lhs, rhs;
acb_mat_init(lhs, m, l);
acb_mat_init(rhs, m, l);
acb_mat_mul(lhs, ab, d, rbits);
acb_mat_mul(rhs, a, bd, rbits);
if (!acb_mat_overlaps(lhs, rhs))
{
flint_printf("FAIL\n\n");
flint_printf("m, n, k, l = %wd, %wd, %wd, %wd\n", m, n, k, l);
flint_printf("rbits = %wd\n", rbits);
_acb_mat_nprintd("a", a);
_acb_mat_nprintd("b", b);
_acb_mat_nprintd("d", d);
_acb_mat_nprintd("(a*b)*d", lhs);
_acb_mat_nprintd("a*(b*d)", rhs);
abort();
}
acb_mat_clear(lhs);
acb_mat_clear(rhs);
}
/* check left distributivity of multiplication over addition */
/* A*(B + C) = A*B + A*C */
{
acb_mat_t lhs, rhs;
acb_mat_init(lhs, m, k);
acb_mat_init(rhs, m, k);
acb_mat_mul(lhs, a, s, rbits);
acb_mat_add(rhs, ab, ac, rbits);
if (!acb_mat_overlaps(lhs, rhs))
{
flint_printf("FAIL\n\n");
flint_printf("m, n, k, l = %wd, %wd, %wd, %wd\n", m, n, k, l);
flint_printf("rbits = %wd\n", rbits);
_acb_mat_nprintd("a", a);
_acb_mat_nprintd("b", b);
_acb_mat_nprintd("c", c);
_acb_mat_nprintd("a*(b + c)", lhs);
_acb_mat_nprintd("a*b + b*c", rhs);
abort();
}
acb_mat_clear(lhs);
acb_mat_clear(rhs);
}
/* check right distributivity of multiplication over addition */
/* (B + C)*D = B*D + C*D */
{
acb_mat_t lhs, rhs;
acb_mat_init(lhs, n, l);
acb_mat_init(rhs, n, l);
acb_mat_mul(lhs, s, d, rbits);
acb_mat_add(rhs, bd, cd, rbits);
if (!acb_mat_overlaps(lhs, rhs))
{
flint_printf("FAIL\n\n");
flint_printf("m, n, k, l = %wd, %wd, %wd, %wd\n", m, n, k, l);
flint_printf("rbits = %wd\n", rbits);
_acb_mat_nprintd("b", b);
_acb_mat_nprintd("c", c);
_acb_mat_nprintd("d", d);
_acb_mat_nprintd("(b + c)*d", lhs);
_acb_mat_nprintd("b*d + c*d", rhs);
abort();
}
acb_mat_clear(lhs);
acb_mat_clear(rhs);
}
/* check left multiplicative identity I*D = D */
{
acb_mat_t one, lhs;
acb_mat_init(one, k, k);
acb_mat_init(lhs, k, l);
acb_mat_one(one);
acb_mat_mul(lhs, one, d, rbits);
if (!acb_mat_contains(lhs, d))
{
flint_printf("FAIL\n\n");
flint_printf("k = %wd, l = %wd\n", k, l);
flint_printf("rbits = %wd\n", rbits);
_acb_mat_nprintd("identity * d", lhs);
_acb_mat_nprintd("d", d);
abort();
}
acb_mat_clear(one);
acb_mat_clear(lhs);
}
/* check right multiplicative identity A*I = A */
{
acb_mat_t one, lhs;
acb_mat_init(one, n, n);
acb_mat_init(lhs, m, n);
acb_mat_one(one);
acb_mat_mul(lhs, a, one, rbits);
if (!acb_mat_contains(lhs, a))
{
flint_printf("FAIL\n\n");
flint_printf("m = %wd, n = %wd\n", m, n);
flint_printf("rbits = %wd\n", rbits);
_acb_mat_nprintd("a * identity", lhs);
_acb_mat_nprintd("a", a);
abort();
}
acb_mat_clear(one);
acb_mat_clear(lhs);
}
acb_mat_clear(a);
acb_mat_clear(b);
acb_mat_clear(c);
acb_mat_clear(d);
acb_mat_clear(ab);
acb_mat_clear(ac);
acb_mat_clear(bd);
acb_mat_clear(cd);
acb_mat_clear(s);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
void
_acb_mat_init_randtest(acb_mat_t mat, slong r, slong c, flint_rand_t state)
{
acb_mat_init(mat, r, c);
acb_mat_randtest(mat, state, 2 + n_randint(state, 200), 10);
}
int main()
{
slong iter;
flint_rand_t state;
flint_printf("exp....");
fflush(stdout);
flint_randinit(state);
/* check exp(A)*exp(c*A) = exp((1+c)*A) */
for (iter = 0; iter < 500 * arb_test_multiplier(); iter++)
{
acb_mat_t A, E, F, EF, G;
fmpq_mat_t Q;
acb_t c, d;
slong n, qbits, prec;
n = n_randint(state, 5);
qbits = 2 + n_randint(state, 300);
prec = 2 + n_randint(state, 300);
acb_init(c);
acb_init(d);
fmpq_mat_init(Q, n, n);
acb_mat_init(A, n, n);
acb_mat_init(E, n, n);
acb_mat_init(F, n, n);
acb_mat_init(EF, n, n);
acb_mat_init(G, n, n);
_fmpq_mat_randtest_for_exp(Q, state, qbits);
acb_mat_set_fmpq_mat(A, Q, prec);
acb_mat_exp(E, A, prec);
acb_randtest(c, state, prec, 10);
acb_mat_scalar_mul_acb(F, A, c, prec);
acb_mat_exp(F, F, prec);
acb_add_ui(d, c, 1, prec);
acb_mat_scalar_mul_acb(G, A, d, prec);
acb_mat_exp(G, G, prec);
acb_mat_mul(EF, E, F, prec);
if (!acb_mat_overlaps(EF, G))
{
flint_printf("FAIL\n\n");
flint_printf("n = %wd, prec = %wd\n", n, prec);
flint_printf("c = \n"); acb_printd(c, 15); flint_printf("\n\n");
flint_printf("A = \n"); acb_mat_printd(A, 15); flint_printf("\n\n");
flint_printf("E = \n"); acb_mat_printd(E, 15); flint_printf("\n\n");
flint_printf("F = \n"); acb_mat_printd(F, 15); flint_printf("\n\n");
flint_printf("E*F = \n"); acb_mat_printd(EF, 15); flint_printf("\n\n");
flint_printf("G = \n"); acb_mat_printd(G, 15); flint_printf("\n\n");
flint_abort();
}
acb_clear(c);
acb_clear(d);
fmpq_mat_clear(Q);
acb_mat_clear(A);
acb_mat_clear(E);
acb_mat_clear(F);
acb_mat_clear(EF);
acb_mat_clear(G);
}
flint_randclear(state);
flint_cleanup();
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
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 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;
}
int main()
{
long iter;
flint_rand_t state;
printf("det....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000; iter++)
{
fmpq_mat_t Q;
fmpq_t Qdet;
acb_mat_t A;
acb_t Adet, imagunit;
long n, qbits, prec;
int imaginary;
n = n_randint(state, 8);
qbits = 1 + n_randint(state, 100);
prec = 2 + n_randint(state, 200);
imaginary = n_randint(state, 2);
fmpq_mat_init(Q, n, n);
fmpq_init(Qdet);
acb_mat_init(A, n, n);
acb_init(Adet);
acb_init(imagunit);
fmpq_mat_randtest(Q, state, qbits);
fmpq_mat_det(Qdet, Q);
acb_mat_set_fmpq_mat(A, Q, prec);
if (imaginary)
{
acb_onei(imagunit);
acb_mat_scalar_mul_acb(A, A, imagunit, prec);
}
acb_mat_det(Adet, A, prec);
if (imaginary)
{
acb_onei(imagunit);
acb_inv(imagunit, imagunit, prec);
acb_pow_ui(imagunit, imagunit, n, prec);
acb_mul(Adet, Adet, imagunit, prec);
}
if (!acb_contains_fmpq(Adet, Qdet))
{
printf("FAIL (containment, iter = %ld)\n", iter);
printf("n = %ld, prec = %ld\n", n, prec);
printf("\n");
printf("Q = \n"); fmpq_mat_print(Q); printf("\n\n");
printf("Qdet = \n"); fmpq_print(Qdet); printf("\n\n");
printf("A = \n"); acb_mat_printd(A, 15); printf("\n\n");
printf("Adet = \n"); acb_printd(Adet, 15); printf("\n\n");
printf("Adet = \n"); acb_print(Adet); printf("\n\n");
abort();
}
fmpq_mat_clear(Q);
fmpq_clear(Qdet);
acb_mat_clear(A);
acb_clear(Adet);
acb_clear(imagunit);
}
flint_randclear(state);
flint_cleanup();
printf("PASS\n");
return EXIT_SUCCESS;
}
