int main(void)
{
fmpz_mat_t A, B, C, D;
slong i;
FLINT_TEST_INIT(state);
flint_printf("mul....");
fflush(stdout);
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
slong m, n, k;
m = n_randint(state, 50);
n = n_randint(state, 50);
k = n_randint(state, 50);
fmpz_mat_init(A, m, n);
fmpz_mat_init(B, n, k);
fmpz_mat_init(C, m, k);
fmpz_mat_init(D, m, k);
fmpz_mat_randtest(A, state, n_randint(state, 200) + 1);
fmpz_mat_randtest(B, state, n_randint(state, 200) + 1);
/* Make sure noise in the output is ok */
fmpz_mat_randtest(C, state, n_randint(state, 200) + 1);
fmpz_mat_mul(C, A, B);
fmpz_mat_mul_classical_inline(D, A, B);
if (!fmpz_mat_equal(C, D))
{
flint_printf("FAIL: results not equal\n");
abort();
}
fmpz_mat_mul(A, A, B);
if (!fmpz_mat_equal(A, C))
{
flint_printf("FAIL: aliasing failed\n");
abort();
}
fmpz_mat_clear(A);
fmpz_mat_clear(B);
fmpz_mat_clear(C);
fmpz_mat_clear(D);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
void
fmpq_mat_mul_fmpz_mat(fmpq_mat_t C, const fmpq_mat_t A, const fmpz_mat_t B)
{
slong i, j;
fmpz_mat_t Aclear;
fmpz_mat_t Cclear;
fmpz * Aden;
fmpz_mat_init(Aclear, A->r, A->c);
fmpz_mat_init(Cclear, A->r, B->c);
Aden = _fmpz_vec_init(A->r);
fmpq_mat_get_fmpz_mat_rowwise(Aclear, Aden, A);
fmpz_mat_mul(Cclear, Aclear, B);
for (i = 0; i < C->r; i++)
{
for (j = 0; j < C->c; j++)
{
fmpz_set(fmpq_mat_entry_num(C, i, j), fmpz_mat_entry(Cclear, i, j));
fmpz_set(fmpq_mat_entry_den(C, i, j), Aden + i);
fmpq_canonicalise(fmpq_mat_entry(C, i, j));
}
}
fmpz_mat_clear(Aclear);
fmpz_mat_clear(Cclear);
_fmpz_vec_clear(Aden, A->r);
}
void
_fmpz_holonomic_forward_bsplit_fmpz(fmpz_mat_t M, fmpz_t Q,
const fmpz_holonomic_t op, long start, long a, long b)
{
long r = fmpz_holonomic_order(op);
if (b - a == 1)
{
_fmpz_holonomic_eval_companion_matrix_fmpz(M, Q, op, start + a);
}
else
{
fmpz_mat_t L, R;
fmpz_t Q2;
long m = a + (b - a) / 2;
fmpz_mat_init(L, r, r);
fmpz_mat_init(R, r, r);
fmpz_init(Q2);
_fmpz_holonomic_forward_bsplit_fmpz(L, Q, op, start, a, m);
_fmpz_holonomic_forward_bsplit_fmpz(R, Q2, op, start, m, b);
fmpz_mat_mul(M, R, L);
fmpz_mul(Q, Q, Q2);
fmpz_mat_clear(L);
fmpz_mat_clear(R);
fmpz_clear(Q2);
}
}
int main(void)
{
slong i;
FLINT_TEST_INIT(state);
flint_printf("pow....");
fflush(stdout);
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
fmpz_mat_t A, B, C;
slong i, n;
ulong e;
n = n_randint(state, 10);
e = n_randint(state, 20);
fmpz_mat_init(A, n, n);
fmpz_mat_init(B, n, n);
fmpz_mat_init(C, n, n);
fmpz_mat_randtest(A, state, n_randint(state, 200) + 1);
fmpz_mat_randtest(B, state, n_randint(state, 200) + 1);
/* Make sure noise in the output is ok */
fmpz_mat_randtest(B, state, n_randint(state, 200) + 1);
fmpz_mat_pow(B, A, e);
fmpz_mat_one(C);
for (i = 0; i < e; i++)
fmpz_mat_mul(C, C, A);
if (!fmpz_mat_equal(C, B))
{
flint_printf("FAIL: results not equal\n");
abort();
}
fmpz_mat_pow(A, A, e);
if (!fmpz_mat_equal(A, B))
{
flint_printf("FAIL: aliasing failed\n");
abort();
}
fmpz_mat_clear(A);
fmpz_mat_clear(B);
fmpz_mat_clear(C);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
inline void subtractMultipleTo(DMatZZ& C,
const DMatZZ& A,
const DMatZZ& B)
{
DMatZZ D(C.ring(), A.numRows(), B.numColumns());
fmpz_mat_mul(D.fmpz_mat(), A.fmpz_mat(), B.fmpz_mat());
fmpz_mat_sub(C.fmpz_mat(), C.fmpz_mat(), D.fmpz_mat());
}
inline void mult(const DMatZZ& A,
const DMatZZ& B,
DMatZZ& result_product)
{
// The A1 and B1 on the next line are switched because the memory layout expected
// is the transpose of what we have for DMat.
fmpz_mat_mul(result_product.fmpz_mat(), A.fmpz_mat(), B.fmpz_mat());
}
inline void mult(const DMatZZGMP& A,
const DMatZZGMP& B,
DMatZZGMP& result_product)
{
FlintZZMat A1(A);
FlintZZMat B1(B);
FlintZZMat result1(A.numRows(), B.numColumns());
fmpz_mat_mul(result1.value(), A1.value(), B1.value());
result1.toDMat(result_product);
}
inline void subtractMultipleTo(DMatZZGMP& C,
const DMatZZGMP& A,
const DMatZZGMP& B)
{
FlintZZMat A1(A);
FlintZZMat B1(B);
FlintZZMat C1(C);
FlintZZMat result1(A.numRows(), B.numColumns());
FlintZZMat D1(A.numRows(), B.numColumns());
fmpz_mat_mul(D1.value(), A1.value(), B1.value());
fmpz_mat_sub(C1.value(), C1.value(), D1.value());
C1.toDMat(C);
}
void sample(void * arg, ulong count)
{
mat_mul_t * params = (mat_mul_t *) arg;
long i, m = params->m, n = params->n, k = params->k;
long bits = params->bits;
int algorithm = params->algorithm;
flint_rand_t rnd;
fmpz_mat_t A, B, C;
flint_rand_t state;
flint_randinit(state);
fmpz_mat_init(A, m, n);
fmpz_mat_init(B, n, k);
fmpz_mat_init(C, m, k);
fmpz_mat_randbits(A, state, bits);
fmpz_mat_randbits(B, state, bits);
prof_start();
if (algorithm == 0)
for (i = 0; i < count; i++)
fmpz_mat_mul(C, A, B);
else if (algorithm == 1)
for (i = 0; i < count; i++)
fmpz_mat_mul_classical(C, A, B);
else if (algorithm == 2)
for (i = 0; i < count; i++)
fmpz_mat_mul_classical_inline(C, A, B);
else if (algorithm == 3)
for (i = 0; i < count; i++)
fmpz_mat_mul_multi_mod(C, A, B);
prof_stop();
fmpz_mat_clear(A);
fmpz_mat_clear(B);
fmpz_mat_clear(C);
flint_randclear(state);
}
void
fmpz_mat_mul(fmpz_mat_t C, const fmpz_mat_t A, const fmpz_mat_t B)
{
long dim, m, n, k, ab, bb;
m = A->r;
n = A->c;
k = B->c;
if (C == A || C == B)
{
fmpz_mat_t t;
fmpz_mat_init(t, m, k);
fmpz_mat_mul(t, A, B);
fmpz_mat_swap(C, t);
fmpz_mat_clear(t);
return;
}
dim = FLINT_MIN(FLINT_MIN(m, n), k);
if (dim < 10)
{
fmpz_mat_mul_classical(C, A, B);
return;
}
ab = fmpz_mat_max_bits(A);
bb = fmpz_mat_max_bits(B);
ab = FLINT_ABS(ab);
bb = FLINT_ABS(bb);
if (5*(ab + bb) > dim * dim)
{
fmpz_mat_mul_classical(C, A, B);
}
else
{
_fmpz_mat_mul_multi_mod(C, A, B, ab + bb + FLINT_BIT_COUNT(n) + 1);
}
}
int
main(void)
{
fmpz_mat_t A, X, B, AX;
fmpz_t den;
slong i, m, n, r;
int success;
FLINT_TEST_INIT(state);
flint_printf("solve_cramer....");
fflush(stdout);
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
m = n_randint(state, 4);
n = n_randint(state, 10);
fmpz_mat_init(A, m, m);
fmpz_mat_init(B, m, n);
fmpz_mat_init(X, m, n);
fmpz_mat_init(AX, m, n);
fmpz_init(den);
fmpz_mat_randrank(A, state, m, 1+n_randint(state, 2)*n_randint(state, 100));
fmpz_mat_randtest(B, state, 1+n_randint(state, 2)*n_randint(state, 100));
/* Dense */
if (n_randint(state, 2))
fmpz_mat_randops(A, state, 1+n_randint(state, 1 + m*m));
success = fmpz_mat_solve_cramer(X, den, A, B);
fmpz_mat_mul(AX, A, X);
fmpz_mat_scalar_divexact_fmpz(AX, AX, den);
if (!fmpz_mat_equal(AX, B) || !success)
{
flint_printf("FAIL:\n");
flint_printf("AX != B!\n");
flint_printf("A:\n"), fmpz_mat_print_pretty(A), flint_printf("\n");
flint_printf("B:\n"), fmpz_mat_print_pretty(B), flint_printf("\n");
flint_printf("X:\n"), fmpz_mat_print_pretty(X), flint_printf("\n");
flint_printf("den(X) = "), fmpz_print(den), flint_printf("\n");
flint_printf("AX:\n"), fmpz_mat_print_pretty(AX), flint_printf("\n");
abort();
}
fmpz_mat_clear(A);
fmpz_mat_clear(B);
fmpz_mat_clear(X);
fmpz_mat_clear(AX);
fmpz_clear(den);
}
/* Test singular systems */
for (i = 0; i < 1000 * flint_test_multiplier(); i++)
{
m = 1 + n_randint(state, 3);
n = 1 + n_randint(state, 10);
r = n_randint(state, m);
fmpz_mat_init(A, m, m);
fmpz_mat_init(B, m, n);
fmpz_mat_init(X, m, n);
fmpz_mat_init(AX, m, n);
fmpz_init(den);
fmpz_mat_randrank(A, state, r, 1+n_randint(state, 2)*n_randint(state, 100));
fmpz_mat_randtest(B, state, 1+n_randint(state, 2)*n_randint(state, 100));
/* Dense */
if (n_randint(state, 2))
fmpz_mat_randops(A, state, 1+n_randint(state, 1 + m*m));
success = fmpz_mat_solve_cramer(X, den, A, B);
if (!fmpz_is_zero(den) || success)
{
flint_printf("FAIL:\n");
flint_printf("singular system gave nonzero determinant\n");
abort();
}
fmpz_mat_clear(A);
fmpz_mat_clear(B);
fmpz_mat_clear(X);
fmpz_mat_clear(AX);
fmpz_clear(den);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
int
main(void)
{
fmpz_mat_t A, X, B, AX, AXm, Bm;
fmpz_t mod;
slong i, m, n, r;
int success;
FLINT_TEST_INIT(state);
flint_printf("solve_dixon....");
fflush(stdout);
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
m = n_randint(state, 20);
n = n_randint(state, 20);
fmpz_mat_init(A, m, m);
fmpz_mat_init(B, m, n);
fmpz_mat_init(Bm, m, n);
fmpz_mat_init(X, m, n);
fmpz_mat_init(AX, m, n);
fmpz_mat_init(AXm, m, n);
fmpz_init(mod);
fmpz_mat_randrank(A, state, m, 1+n_randint(state, 2)*n_randint(state, 100));
fmpz_mat_randtest(B, state, 1+n_randint(state, 2)*n_randint(state, 100));
/* Dense */
if (n_randint(state, 2))
fmpz_mat_randops(A, state, 1+n_randint(state, 1 + m*m));
success = fmpz_mat_solve_dixon(X, mod, A, B);
fmpz_mat_set(AXm, X);
fmpz_mat_mul(AX, A, AXm);
fmpz_mat_scalar_mod_fmpz(AXm, AX, mod);
fmpz_mat_scalar_mod_fmpz(Bm, B, mod);
if (!fmpz_mat_equal(AXm, Bm) || !success)
{
flint_printf("FAIL:\n");
flint_printf("AX != B!\n");
flint_printf("A:\n"), fmpz_mat_print_pretty(A), flint_printf("\n");
flint_printf("B:\n"), fmpz_mat_print_pretty(B), flint_printf("\n");
flint_printf("X:\n"), fmpz_mat_print_pretty(X), flint_printf("\n");
flint_printf("mod = "), fmpz_print(mod), flint_printf("\n");
flint_printf("AX:\n"), fmpz_mat_print_pretty(AX), flint_printf("\n");
abort();
}
fmpz_mat_clear(A);
fmpz_mat_clear(B);
fmpz_mat_clear(Bm);
fmpz_mat_clear(X);
fmpz_mat_clear(AX);
fmpz_mat_clear(AXm);
fmpz_clear(mod);
}
/* Test singular systems */
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
m = 1 + n_randint(state, 10);
n = 1 + n_randint(state, 10);
r = n_randint(state, m);
fmpz_mat_init(A, m, m);
fmpz_mat_init(B, m, n);
fmpz_mat_init(X, m, n);
fmpz_init(mod);
fmpz_mat_randrank(A, state, r, 1+n_randint(state, 2)*n_randint(state, 100));
fmpz_mat_randtest(B, state, 1+n_randint(state, 2)*n_randint(state, 100));
/* Dense */
if (n_randint(state, 2))
fmpz_mat_randops(A, state, 1+n_randint(state, 1 + m*m));
if (fmpz_mat_solve_dixon(X, mod, A, B) != 0)
{
flint_printf("FAIL:\n");
flint_printf("singular system, returned nonzero\n");
abort();
}
fmpz_mat_clear(A);
fmpz_mat_clear(B);
fmpz_mat_clear(X);
fmpz_clear(mod);
}
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return 0;
}
static inline void
fmpz_mat_mul_mod(fmpz_mat_t a, fmpz_mat_t b, fmpz_mat_t c, fmpz_t p)
{
fmpz_mat_mul(a, b, c);
fmpz_mat_scalar_mod_fmpz(a, a, p);
}
