#include <stdio.h>
#include <stdlib.h>
#include "matrix.h"

/*
 * This function allocates space for an n x m matrix, placing an array
 * of n pointers to arrays of m floats into the pointer v.
 * The number of rows and columns are stored in the matrix structure,
 * which is returned.
 *
 * In an object oriented environment, this function would be known as
 * the constructor.
 */
matrix construct_matrix (int n, int m) {
	matrix	A;
	int	i;

	A.nrows = n;
	A.ncolumns = m;
	A.v = (float **) malloc (sizeof (float *) * A.nrows);
	for (i=0; i<A.nrows; i++) 
		A.v[i] = (float *) malloc (sizeof (float) * A.ncolumns);
	return A;
}

/*
 * This function adds two matrices, returning the result.  It checks to
 * make sure that the two matrices are of the same size.
 */
matrix add_matrix (matrix A, matrix B) {
	int	i, j;
	matrix	C;

	/* same size? */

	if (A.nrows != B.nrows || A.ncolumns != B.ncolumns) {

		/* nope; return a bogus value */

		C.v = NULL;
		C.nrows = -1;
		C.ncolumns = -1;
		return C;
	}

	/* allocate a new matrix for the result */

	C = construct_matrix (A.nrows, A.ncolumns);

	/* add respective elements of A and B, putting the result in C */

	for (i=0; i<A.nrows; i++) 
		for (j=0; j<A.ncolumns; j++)
			C.v[i][j] = A.v[i][j] + B.v[i][j];
	return C;
}

/*
 * This functions frees storage for a matrix.  In an object oriented
 * environment, this function would be known as the destructor. 
 */
void destruct_matrix (matrix A) {
	int	i;

	if (A.v) {

		/* free storage for each row */


		for (i=0; i<A.nrows; i++) free (A.v[i]);

		/* free the array of pointers */

		free (A.v);

		/* set v = NULL so no one will try to use it later */

		A.v = NULL;
	}
}

/*
 * This function does a scalar multiplication of the matrix A by the
 * number c.  It multiplies each element of the matrix A by c, placing
 * the result in a new matrix B.
 */
matrix scalar_mult_matrix (float c, matrix A) {
	int	i, j;
	matrix	B;

	/* allocate a new matrix for the result */

	B = construct_matrix (A.nrows, A.ncolumns);

	/* multiply each element by c, placing the result in B */

	for (i=0; i<A.nrows; i++)
		for (j=0; j<A.ncolumns; j++) 
			B.v[i][j] = c * A.v[i][j];
	return B;
}

/*
 * This function negates each element of a matrix, returning the result.  
 * It does this simply by scalar multiplying the matrix by -1.
 */
matrix negate_matrix (matrix A) {
	return scalar_mult_matrix (-1.0, A);
}

/* 
 * This function, internal to the matrix routines, returns 0 
 * if i and j would be an illegal access to the matrix,
 * 1 otherwise.  It is used by set_matrix and get_matrix to check if
 * an access is out of bounds.  This way, no more segmentation faults
 * (we hope).
 */
int check_bounds (matrix A, int i, int j) {
	if (i >= A.nrows || j >= A.ncolumns || i < 0 || j < 0) {
		fprintf (stderr, "access violation!\n");
		return 0;
	}
	return 1;
}

/* This function sets a matrix element equal to c */
void set_matrix (matrix A, int i, int j, float c) {
	if (check_bounds (A, i, j)) A.v[i][j] = c;
}

/* This function returns the value of a matrix element */
float get_matrix (matrix A, int i, int j) {
	if (check_bounds (A, i, j)) return A.v[i][j];
	return 0.0;
}

/* This function prints the matrix in a nice format */
void print_matrix (matrix A) {
	int	i, j;

	/* for each row... */

	for (i=0; i<A.nrows; i++) {

		/* print the row as [ number number ... number ] */

		printf ("[ ");
		for (j=0; j<A.ncolumns; j++)
			printf ("%6.3f ", A.v[i][j]);
		printf ("]\n");
	}
}

/* sample main program */

int main () {
	matrix	A, B, C;
	int	i, j;

	/* make a 5 x 5 matrix */

	A = construct_matrix (5, 5);

	/* put some convenient values in the matrix */

	for (i=0; i<5; i++) for (j=0; j<5; j++) 
		set_matrix (A, i, j, (float) (i + j));

	/* B = 5.0 * A */

	B = scalar_mult_matrix (5.0, A);

	/* C = A + B */

	C = add_matrix (A, B);

	/* print the result */

	print_matrix (C);

	/* clean up */

	destruct_matrix (A);
	destruct_matrix (B);
	destruct_matrix (C);
}