------------------mmult.c-----------------------------
//A program to multiply matrices
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <math.h>
#include "matrix.h"


int main(int argc, char * argv[])
{
	// Three matrices to work with
	struct matrix *m1=NULL;
	struct matrix *m2=NULL;
	struct matrix *m3=NULL;

	// Create a random 3x3 matrix
	m1=mrand(3,3);
	if (m1==NULL) {
		printf("Malloc error\n");
		return 1;
	}
	// Create a random 3x3 matrix
	m2=mrand(3,3);
	if (m2==NULL) {
		printf("Malloc error\n");
		return 1;
	}

	// Multiply the two
	m3=mmult(m1,m2);
	if (m3==NULL) {
		mfree(m1);
		mfree(m2);
		return 1;
	}

	// Print them all
	mprint(m1);
	mprint(m2);
	mprint(m3);

	// Clean up
	mfree(m1);
	mfree(m2);
	mfree(m3);

	return 0;
}


--------------------matrix.c------------------------
//  - Matrix routines
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include "matrix.h"

// Create random matrix of size i by j
struct matrix *mrand(int i, int j)
{
	int a, b;			// Counters
	struct matrix *m;	// The matrix pointer
	
	// Allocate the matrix structure
	m=(struct matrix *)malloc(sizeof(struct matrix));
	if (m==NULL) {
		perror("Malloc");
		return NULL;
	}

	// Set the size
	m->r=i;
	m->c=j;

	// Alocate the rows & Handle errors
	m->d=(float **)malloc(sizeof(float *)*m->r);
	if (m->d==NULL) {
		perror("Malloc");
		free(m);
		return NULL;
	}
	// Allocate the columns & Handle errors
	for (b=0; b<j; b++) {
		m->d[b]=(float *)malloc(sizeof(float)*m->c);
		if (m->d[b]==NULL) {
			perror("Malloc");
			for (a=0;a<b;a++) {
				free(m->d[a]);
			}
			free(m->d);
			free(m);
			return NULL;
		}
	}
	// Fill the matrix
	for (a=0;a<i;a++) {
		for (b=0;b<j;b++) {
			m->d[a][b]=drand48();
		}
	}
	return m;
}

// Multiply m1 by m2 result is allocated and returned
struct matrix *mmult(struct matrix *m1, struct matrix *m2)
{
	struct matrix *m;
	int a, b, c;

	// Sanity
	if (m1==NULL) {
		printf("Null matrix!\n");
		return NULL;
	}
	if (m2==NULL) {
		printf("Null matrix!\n");
		return NULL;
	}
	// Inner dimensions must agree
	if (m1->c!=m2->r) {
		printf("Matrix inner dimensions must agree\n");
		return NULL;
	}

	// As in mrand(), allocate space for the new matrix
	m=(struct matrix *)malloc(sizeof(struct matrix));
	if (m==NULL) {
		perror("Malloc");
		return NULL;
	}

	m->r=m1->r;
	m->c=m2->c;

	m->d=(float **)malloc(sizeof(float *)*m->r);
	if (m->d==NULL) {
		perror("Malloc");
		free(m);
		return NULL;
	}
	for (b=0; b<m->r; b++) {
		m->d[b]=(float *)malloc(sizeof(float)*m->c);
		if (m->d[b]==NULL) {
			perror("Malloc");
			for (a=0;a<b;a++) {
				free(m->d[a]);
			}
			free(m->d);
			free(m);
			return NULL;
		}
	}
	// Multiply
	for (a=0;a<m1->r;a++) {
		for (b=0;b<m2->c;b++) {
			m->d[a][b]=0;
			for (c=0;c<m1->c;c++) {
				m->d[a][b]+=m1->d[a][c]*m2->d[c][b];
			}
		}
	}
	return m;
}

// Print a matrix
void mprint(struct matrix *m)
{
	int a, b;	// Counters

	// Sanity
	if (m==NULL) {
		printf("Null Matrix!\n");
		return;
	}
	// MATLAB format
	printf("[");
	for (a=0;a<m->r;a++) {
		for (b=0;b<m->c;b++) {
			printf("%.9f ",m->d[a][b]);
		}
		printf(";\n");
	}
	printf("]\n");

	return;
}

// Free a matrix
void mfree(struct matrix *m)
{
	int a;	// Counter

	// Sanity
	if (m==NULL) {
		printf("Null Matrix!\n");
		return;
	}
	// Free in reverse order
	for (a=0;a<m->r;a++) {
		free(m->d[a]);
	}
	free(m->d);
	free(m);
	m=NULL;
	return;
}



------------matrix.h-------------
/***Matrix routine protos***/
#ifndef __MATRIX_H__
#define __MATRIX_H__

// Organize the matrix data
struct matrix {
	int r;
	int c;
	float **d;
};

// Create a random matrix
struct matrix * mrand(int i, int j);
// Multiply matrices
struct matrix * mmult(struct matrix *m1, struct matrix *m2);
// Free a matrix
void mfree(struct matrix *m);
// Print a matrix
void mprint(struct matrix *m);

#endif // __MATRIX_H__

-------------------Makefile---------------------------------

TARGET=mmult
OBJS=mmult.o matrix.o
CFLAGS=-g -Wall
.PHONY: clean all

all: ${TARGET}

${TARGET}: ${OBJS}
	${CC} -o ${TARGET} ${OBJS}

clean:
	rm -f ${OBJS} ${TARGET}

matrix.o: matrix.h