Sparse Matrices in C

Author: mattliving

Makefile

@@ -0,0 +1,13 @@
+# Makefile
+
+matrix: matrix.o coo.o csr.o
+	gcc -o matrix matrix.o coo.o csr.o
+        
+matrix.o: matrix.c
+	gcc -O1 -c matrix.c
+
+coo.o: coo.c coo.h
+	gcc -O1 -c coo.c
+
+csr.o: csr.c csr.h coo.c coo.h
+	gcc -O1 -c csr.c coo.c

coo.c

@@ -0,0 +1,100 @@
+/*
+ *  coo.c
+ *  21103CW2
+ *
+ *  Created by Matthew Livingston on 23/01/2012.
+ *  Copyright 2012 University of Bristol. All rights reserved.
+ *
+ */
+
+#include "coo.h"
+
+// Allocate memory for a new Node struct
+Node * insertNode(int row, int col, int val, Node * nextNode) {
+	Node * newNode = calloc(1, sizeof(Node)); 
+	newNode->row = row;
+	newNode->col = col;
+	newNode->val = val;
+	newNode->next = nextNode;
+	
+	return newNode;	
+}
+
+// Add a new node to the List 
+List * add(List * list, int row, int col, int val) {
+	if (list->head == NULL) list->head = list->tail = insertNode(row, col, val, NULL);  
+	else list->tail = list->tail->next = insertNode(row, col, val, NULL); 
+	list->size++;
+	return list;
+}
+
+// Add a new node to the List in ascending row order
+List * addRowOrdered(List * list, int row, int col, int val) {
+	if (list->head == NULL) list->head = list->tail = insertNode(row, col, val, NULL); 
+	else if (row <= list->head->row) list->head = insertNode(row, col, val, list->head); 
+	else if (row >= list->tail->row) list->tail = list->tail->next = insertNode(row, col, val, NULL); 
+	else {
+		Node * prev = searchList(list->head, row);
+		if (prev != NULL) prev->next = insertNode(row, col, val, prev->next);
+		else list->tail = insertNode(row, col, val, NULL);
+	}
+	list->size++;
+	return list;
+}
+
+// Search a List sequentially
+Node * searchList(Node * node, int row) {
+	while (node->next != NULL) {
+		if (node->next->row > row) return node;
+		else node = node->next;
+	}
+	return NULL;
+}
+
+// Search a List for a specific element
+int searchElement(Node * node, int row, int col) {
+	while (node != NULL) {
+		if ((node->row == row) && (node->col == col)) return node->val;
+		else node = node->next;
+	}
+	return -1;
+}
+
+// Transpose a COO matrix
+List * transpose(List * list) {
+	Node * node = list->head;
+	int temp;
+	while (node != NULL) {
+		temp = node->row;
+		node->row = node->col;
+		node->col = temp;
+		node = node->next;
+	}
+	temp       = list->rows;
+	list->rows = list->cols;
+	list->cols = temp; 
+	return list;
+}
+
+// Return pointer to an empty list
+List * freeList(List * list) {
+	Node * temp;
+	while ((temp = list->head) != NULL) {
+		list->head = list->head->next;
+		free(temp);
+	}
+	list->rows = 0;
+	list->cols = 0;
+	list->size = 0;
+	return list;
+}
+
+// Print a List
+void printList(Node * node) {
+	while (node != NULL) 
+	{
+		printf("%d %d %d", node->row, node->col, node->val);
+		printf("\n");
+		node = node->next;
+	}
+}

coo.h

@@ -0,0 +1,39 @@
+/*
+ *  coo.h
+ *  21103CW2
+ *
+ *  Created by Matthew Livingston on 23/01/2012.
+ *  Copyright 2012 University of Bristol. All rights reserved.
+ *
+ */
+
+#ifndef coo_h
+#define coo_h
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+typedef struct node {
+	int row, col, val;
+	struct node * next;
+} Node;
+
+typedef struct {
+	Node * head;
+	Node * tail; 
+	int rows;
+	int cols;
+	int size;
+} List;
+
+Node * insertNode(int row, int col, int val, Node * nextNode);
+List * add(List * list, int row, int col, int val);
+List * addRowOrdered(List * list, int row, int col, int val);
+Node * searchList(Node * node, int row);
+int searchElement(Node * node, int row, int col);
+List * transpose(List * list);
+List * freeList(List * list);
+void printList(Node * node);
+
+#endif

csr.c

@@ -0,0 +1,120 @@
+/*
+ *  csr.c
+ *  21103CW2
+ *
+ *  Created by Matthew Livingston on 23/01/2012.
+ *  Copyright 2012 University of Bristol. All rights reserved.
+ *
+ */
+
+#include "csr.h"
+
+// Add two CSR matrices together and return a COO matrix
+List * addCSR(CSR * A, CSR * B, List * M) {
+	M->rows = A->rows;
+	M->cols = A->cols;
+	int total, i, j, k = 0; 
+	for (i = 0; i < M->rows; i++) {
+		for (j = 0; j < M->cols; j++) {
+				total = findVal(A, i, j) + findVal(B, i, j);
+				if (total != 0) { M = add(M, i, j, total); k++; }
+		}	
+	}
+	M->size = k;
+	return M;
+}
+
+// Find a column value in a particular row of a CSR matrix
+int findVal(CSR * csr, int row, int col) {
+	int i;
+	for (i = csr->row_ptr[row]; i < csr->row_ptr[row+1]; i++) {
+		if (csr->col_ind[i] == col) return csr->val[i]; 
+	}
+	return 0;
+}
+
+// Multiply two CSR matrices together and return a COO matrix
+List * multiplyCSR(CSR * A, CSR * B, List * M) {
+	M->rows = A->rows;
+	M->cols = B->cols;
+	int size = 0, total, MRow, MCol, ARow, BCol; 
+	for (MRow = 0; MRow < M->rows; MRow++) {
+		for (MCol = 0; MCol < M->cols; MCol++) {
+			total = 0;
+			for (ARow = A->row_ptr[MRow]; ARow < A->row_ptr[MRow+1]; ARow++) {
+				for (BCol = B->row_ptr[A->col_ind[ARow]]; BCol < B->row_ptr[A->col_ind[ARow]+1]; BCol++) {
+					if (B->col_ind[BCol] == MCol) total += A->val[ARow] * B->val[BCol];
+				}
+			}
+			if (total != 0) { M = add(M, MRow, MCol, total); size++; }
+		}	
+	}
+	M->size = size;
+	return M;
+}
+
+// Allocate space for and initialise a CSR matrix 
+CSR * initCSR(CSR * csr, int size, int rows) {
+	csr->val     = calloc(size, sizeof(int)); 
+	csr->col_ind = calloc(size, sizeof(int)); 
+	csr->row_ptr = calloc(rows+1, sizeof(int));
+	csr->val_length = size;
+	csr->row_ptr_length = rows+1;
+	int i;
+	for (i = 0; i < csr->row_ptr_length; i++) csr->row_ptr[i] = -1;
+
+	return csr;
+}
+
+// Return pointer to empty CSR matrix
+CSR * freeCSR(CSR * csr) { 
+	free(csr->val);
+	free(csr->col_ind);
+	free(csr->row_ptr); 
+	return csr;
+}
+
+// Print a particular column of a CSR matrix
+void printCol(CSR * csr, int col) {
+	int * A = calloc(csr->cols, sizeof(int));
+	int i, j; 
+	for (i = 0; i < csr->row_ptr_length-1; i++) {
+		for (j = csr->row_ptr[i]; j < csr->row_ptr[i+1]; j++) if (csr->col_ind[j] == col) A[i] = csr->val[j];
+	}
+	for (i = 0; i < csr->cols; i++) {
+		if (i < csr->cols-1) printf("%d,", A[i]);
+		else printf("%d", A[i]);
+	}
+	printf("\n");
+	free(A);
+}
+
+// Print a particular row of a CSR matrix
+void printRow(CSR * csr, int row) {
+	int * A = calloc(csr->rows, sizeof(int));
+	int i;
+	for (i = csr->row_ptr[row]; i < csr->row_ptr[row+1]; i++) A[csr->col_ind[i]] = csr->val[i];
+	for (i = 0; i < csr->rows; i++) {
+		if (i < csr->rows-1) printf("%d,", A[i]);
+		else printf("%d", A[i]);
+	}
+	printf("\n");
+	free(A);
+}
+
+// Print out the three arrays that make up the CSR matrix
+void printCSR(CSR * csr) {
+	int i;
+	for (i = 0; i < csr->val_length; i++) {
+		printf("%d ", csr->val[i]);
+	}
+	printf("\n\n");
+	for (i = 0; i < csr->val_length; i++) {
+		printf("%d ", csr->col_ind[i]);
+	}
+	printf("\n\n");
+	for (i = 0; i < csr->row_ptr_length; i++) {
+		printf("%d ", csr->row_ptr[i]);
+	}
+	printf("\n");
+}

csr.h

@@ -0,0 +1,37 @@
+/*
+ *  csr.h
+ *  21103CW2
+ *
+ *  Created by Matthew Livingston on 23/01/2012.
+ *  Copyright 2012 University of Bristol. All rights reserved.
+ *
+ */
+
+#ifndef csr_h
+#define csr_h
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include "coo.h"
+
+typedef struct {
+	int * val;
+	int * col_ind;
+	int * row_ptr;
+	int val_length;
+	int row_ptr_length;
+	int rows;
+	int cols;
+} CSR;
+
+List * addCSR(CSR * A, CSR * B, List * M);
+List * multiplyCSR(CSR * A, CSR * B, List * M);
+int findVal(CSR * csr, int row, int col);
+CSR * initCSR(CSR * csr, int size, int rows);
+CSR * freeCSR(CSR * csr);
+void printCSR(CSR * csr);
+void printCol(CSR * csr, int col);
+void printRow(CSR * csr, int row);
+
+#endif

input/.DS_Store

@@ -0,0 +1,10 @@
+5,5
+0,0,-1
+0,4,2
+1,1,5
+1,3,6
+2,2,7
+3,1,8
+3,3,9
+4,0,3
+4,4,-4