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);
}
}
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);
}
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 tau_matrix(acb_mat_t tau, const acb_mat_t omega0, const acb_mat_t omega1, slong prec)
{
acb_mat_inv(tau, omega1, prec);
acb_mat_mul(tau, tau, omega0, prec);
}
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("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_sqr(acb_mat_t B, const acb_mat_t A, slong prec)
{
acb_mat_mul(B, A, A, prec);
}
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 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;
}
