struct sparse_matrix_t*
sparse_matrix_matmatmult (struct sparse_matrix_t* B, struct sparse_matrix_t* A)
{
enum sparse_matrix_storage_format_t format = A->format;
if (format != B->format)
{
bebop_log (0, "*** sparse_matrix_matmatmult: B and A do not have the "
"same format! ***\n");
return NULL;
}
else if (format != CSR)
{
bebop_log (0, "*** sparse_matrix_matmatmult: sparse matrix-matrix "
"multiplication not supported for matrix format %s ***\n",
sparse_matrix_format_string (A));
return NULL;
}
else
{
struct csr_matrix_t* C = csr_matrix_matmatmult ((struct csr_matrix_t*) (B->repr),
(struct csr_matrix_t*) (A->repr));
if (C == NULL)
return NULL;
else
return create_sparse_matrix (CSR, C);
}
}
int main(){
clock_t begin, end;
double time_spent;
begin = clock();
matrix* Q = create_matrix(4, 4);
value Q_arr[16] = {1, 0, 1, 0,
0, 2, 0, 1,
1, 0, 2, 0,
0, 1, 0, 1};
insert_array(Q_arr, Q);
sparse_matrix* s_Q = create_sparse_matrix(Q, 8);
matrix* q = create_matrix(4, 1);
value q_arr[4] = {3,
20,
5,
15};
insert_array(q_arr, q);
matrix* expected = create_matrix(4, 1);
value e_arr[4] = {1,
5,
2,
10};
insert_array(e_arr, expected);
matrix* x = create_zero_matrix(4, 1);
conjugate_gradient(s_Q, x, q);
assert(compare_matrices(x, expected));
free_matrix(Q);
free_matrix(q);
free_matrix(x);
free_matrix(expected);
free_sparse_matrix(s_Q);
end = clock();
time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
printf("time taken was: %f \n", time_spent);
}
/* Allocate a sparse matrix with non-zero pattern equal to L+L', but without
initialising any values. */
SparseMatrix* allocate_symmetric(const SparseMatrix *L, SparseMatrix *P)
{
int i, k, sum;
int *jL, *jP;
if (P == NULL)
P = create_sparse_matrix(L->N, NZ_SYM(L->nz, L->N));
validate_matrices(L, P);
/* Initialise P->j with zeros */
for (i = 0; i < P->N+1; ++i)
P->j[i] = 0;
/* Count number of non-zeros per column, store in P->j */
jL = L->j;
jP = P->j + 1; /* offset by 1 to allow in-place calculations later */
for (i = 0, k = 0; i < L->nz; ++i) {
if (i >= jL[k+1]) ++k; /* if (i) in new column, shift (k) to next col */
++jP[k]; /* increment count for current column */
if (k != L->i[i]) /* if non-diagonal term */
++jP[L->i[i]]; /* increment count for symmetric column */
}
/* Cumulative sum on jP, starting from 0 */
for (i = 0, sum = 0; i < P->N; ++i) {
int tmp = jP[i];
jP[i] = sum;
sum += tmp;
}
/* Compute P->i, using jP for cunning in-place calculation of P->j */
for (i = 0; i < L->N; ++i) /* for each column (i) in L */
for (k = jL[i]; k < jL[i+1]; ++k) {
int j = L->i[k]; /* get k-th row index (j) */
P->i[jP[i]++] = j; /* store row index (j) into col (i) in P */
if (i != j) /* if not a diagonal term, make symmetry */
P->i[jP[j]++] = i; /* store row index (i) into col (j) in P */
}
return P;
}
