/****************************/
/*                          */
/* matrixmultiply.c         */
/* Author: Iasonas Petras   */
/****************************/

#include <stdio.h>
#include <time.h>
#include <stdlib.h>

enum {NUM_OF_ROWS_1 = 600};
enum {NUM_OF_COLUMNS_1 = 700};
enum {NUM_OF_ROWS_2 = 700};
enum {NUM_OF_COLUMNS_2 = 600};


/* Reports on stdout times needed to multiply a 
NUM_OF_ROWS_1 x NUM_OF_COLUMNS_1 matrix
with a NUM_OF_ROWS_2 x NUM_OF_COLUMNS_2 matrix in
- row-major order
- column-major order.
Writes the result in a file named MatrixMultiplicationResult.txt.
Returns 0 if matrices all contain the expected results and the file is 
generated as expected.
*/

int main (void)
{
	int A[NUM_OF_ROWS_1][NUM_OF_COLUMNS_1];
	int B[NUM_OF_ROWS_2][NUM_OF_COLUMNS_2];
	int C1[NUM_OF_ROWS_1][NUM_OF_COLUMNS_2];
	int C2[NUM_OF_ROWS_1][NUM_OF_COLUMNS_2];
	int C3[NUM_OF_ROWS_1][NUM_OF_COLUMNS_2];
	int row, column, k;
	clock_t iInitialClock;
	clock_t iFinalClock;
	FILE *psFile;



	/* Initialize A with random elements in the range [0,...,999]*/
	for (row=0; row<NUM_OF_ROWS_1; row++){
		for (column=0; column<NUM_OF_COLUMNS_1; column++)
			A[row][column]= rand() % 1000;
	}

	/* Initialize B with random elements in the range [0,...,999]*/
	for (row=0; row<NUM_OF_ROWS_2; row++){
		for (column=0; column<NUM_OF_COLUMNS_2; column++)
			B[row][column]= rand() % 1000;
	}


	/* The natural way to multiply two matrices. 
	See also the Memory Hierarchy Lecture */
	for (row = 0; row < NUM_OF_ROWS_1; row++)
	{
		for (column = 0; column < NUM_OF_COLUMNS_2; column++)
		{
			for (k = 0; k < NUM_OF_COLUMNS_1; k++)
				C1[row][column] = A[row][k] + B[k][column];
		}
	}

	iInitialClock = clock();
	/* Multiply in row-major order. 
	See also the Memory Hierarchy Lecture */
	for (row = 0; row < NUM_OF_ROWS_1; row++)
	{
		for (k = 0; k < NUM_OF_COLUMNS_1; k++)
		{
			for (column = 0; column < NUM_OF_COLUMNS_2; column++)
				C2[row][column] = A[row][k] + B[k][column];
		}
	}
	iFinalClock = clock();

	printf("CPU time for row-major order multiplication:  %f seconds\n",
		((double)(iFinalClock - iInitialClock)) / CLOCKS_PER_SEC);
	fflush(stdout);

	iInitialClock = clock();
	/* Multiply in column-major order. 
	See also the Memory Hierarchy Lecture */
	for (column = 0; column < NUM_OF_COLUMNS_2; column++)
	{
		for (k = 0; k < NUM_OF_COLUMNS_1; k++)
		{
			for (row = 0; row < NUM_OF_ROWS_1; row++)
				C3[row][column] = A[row][k] + B[k][column];
		}
	}
	iFinalClock = clock();

	printf("CPU time for column-major order multiplication: %f seconds\n",
		((double)(iFinalClock - iInitialClock)) / CLOCKS_PER_SEC);
	fflush(stdout);

	/* Chech for consistency in the matrix multiplication results */
	for (row = 0; row < NUM_OF_ROWS_1; row++){
		for (column = 0; column < NUM_OF_COLUMNS_2; column++){
			if((C1[row][column]!=C2[row][column]) || 
				(C1[row][column]!=C3[row][column])
				|| (C3[row][column]!=C2[row][column])){
				fprintf(stderr,"Matrix muliplication \
comparison failed!");
				exit(EXIT_FAILURE);
			}

		}

	}


	if ((psFile = fopen("MatrixMultiplicationResult.txt", "w")) == NULL){
		perror(NULL);
		exit(EXIT_FAILURE);
	}
	fprintf(psFile, "Matrix Multiplication Result\n");
	fprintf(psFile, "--------------------------------\
---------------------------------\n");

	for (row = 0; row < NUM_OF_ROWS_1; row++){
		for (column = 0; column < NUM_OF_COLUMNS_2; column++){
			fprintf(psFile, "%d, ", C1[row][column]);
		}
		fprintf(psFile, "\n\n\n");
	}

	if (fclose(psFile) == EOF){
		perror(NULL);
		exit(EXIT_FAILURE);
	}
	
	return 0;
}


/*****************************Sample Run***********************************/

/* 
$ gcc217 matrixmultiply.c -o matrixmultiply

$ ./matrixmultiply
CPU time for row-major order multiplication:  0.810000 seconds
CPU time for column-major order multiplication:  1.640000 seconds

*/