int main(void) {
clock_t begin, end;
double time_spent;
begin = clock();
matrix* a = create_matrix(4, 4);
value temp_a[16] = { 18, 60, 57, 96,
41, 24, 99, 58,
14, 30, 97, 66,
51, 13, 19, 85 };
insert_array(temp_a, a);
matrix* b = create_matrix(4, 4);
assert(insert_array(temp_a, b));
//tests check_boundaries
assert(check_boundaries(1,1,a));
assert(check_boundaries(4,4,a));
assert(!check_boundaries(4,5,a));
assert(!check_boundaries(5,4,a));
assert(!check_boundaries(0,1,a));
assert(!check_boundaries(1,0,a));
assert(!check_boundaries(-1,1,a));
assert(!check_boundaries(1,-1,a));
//tests compare_matrices,insert_value and get_value
assert(compare_matrices(a,b));
assert(insert_value(10,1,1,b));
assert(!compare_matrices(a,b));
assert(get_value(1,1,b)==10);
assert(insert_value(18,1,1,b));
assert(compare_matrices(a,b));
//tests is_matrix
matrix* c=a;
assert(compare_matrices(a,c));
assert(!is_matrix(a,b));
assert(is_matrix(a,c));
//tests insert_value by trying to go outside the matrix
assert(insert_value(1,1,1,c));
assert(insert_value(2,2,2,c));
assert(insert_value(3,3,3,c));
assert(insert_value(4,4,4,c));
assert(!insert_value(5,5,5,c));
assert(!insert_value(-1,-1,-1,c));
assert(!insert_value(-1,-1,1,c));
assert(!insert_value(-1,1,-1,c));
//test get_value
assert(get_value(1,1,c)==1);
assert(get_value(2,2,c)==2);
assert(get_value(3,3,c)==3);
assert(get_value(4,4,c)==4);
assert(get_value(0,0,c)==0);
assert(get_value(1,-1,c)==0);
assert(get_value(-1,1,c)==0);
assert(get_value(5,5,c)==0);
//tests insert and get without boundary checks
insert_value_without_check(4,1,1,c);
insert_value_without_check(3,2,2,c);
insert_value_without_check(2,3,3,c);
insert_value_without_check(1,4,4,c);
assert(get_value_without_check(1,1,c)==4);
assert(get_value_without_check(2,2,c)==3);
assert(get_value_without_check(3,3,c)==2);
assert(get_value_without_check(4,4,c)==1);
//tests add_matrices
value temp_b[16]={
36,120,114,192,
82,48,198,116,
28, 60, 194,132,
102,26,38,170};
assert(insert_array(temp_b,a));
matrix* d = create_matrix(4, 4);
assert(add_matrices(b,b,d));
assert(compare_matrices(d,a));
//tests subtract_matrices
value temp_c[16]={
0,0,0,0,
0,0,0,0,
0, 0, 0,0,
0,0,0,0};
assert(insert_array(temp_c,a));
assert(subtract_matrices(b,b,d));
assert(compare_matrices(d,a));
//tests sum_of_row
assert(insert_array(temp_a,a));
assert(sum_of_row(1,a)==231);
assert(sum_of_row(4,a)==168);
assert(sum_of_row(0,a)==0);
assert(sum_of_row(5,a)==0);
//tests sum_of_column
assert(sum_of_column(1,a)==124);
assert(sum_of_column(4,a)==305);
assert(sum_of_column(0,a)==0);
assert(sum_of_column(5,a)==0);
//tests get_row_vector
matrix* e = create_matrix(1, 4);
value temp_d[4] = { 18, 60, 57, 96};
assert(insert_array(temp_d,e));
matrix* f = create_matrix(1, 4);
assert(!get_row_vector(0,a,f));
assert(!get_row_vector(5,a,f));
assert(get_row_vector(1,a,f));
assert(compare_matrices(e,f));
//tests get_column_vector
matrix* g = create_matrix(4, 1);
assert(insert_array(temp_d,e));
matrix* h = create_matrix(1, 4);
assert(!get_row_vector(0,a,h));
assert(!get_row_vector(5,a,h));
assert(get_row_vector(1,a,h));
assert(compare_matrices(e,h));
//tests mulitply_matrices
assert(multiply_matrices(a,a,b));
value temp_f[16]={8478,5478,14319,17130,
6066,6760,15418,16792,
6206,5328,14431,15096,
6052,5047,7652,14129.00};
assert(insert_array(temp_f,d));
assert(compare_matrices(b,d));
assert(!multiply_matrices(a,h,b));
assert(!multiply_matrices(a,a,h));
//tests transpose_matrix
value temp_g[16]={18,41,14,51,
60,24,30,13,
57,99,97,19,
96,58,66,85};
assert(insert_array(temp_g,d));
assert(transpose_matrix(a,b));
assert(compare_matrices(b,d));
assert(!transpose_matrix(e,b));
assert(!transpose_matrix(a,e));
//tests multiply_matrix_with_scalar
value temp_h[16] = { 36, 120, 114, 192,
82, 48, 198, 116,
28, 60, 194, 132,
102, 26, 38, 170 };
assert(insert_array(temp_h,b));
multiply_matrix_with_scalar(2,a);
assert(compare_matrices(a,b));
//test get_sub_matrix
matrix* i=create_matrix(2,2);
assert(insert_array(temp_a,a));
assert(get_sub_matrix(1,2,1,2,a,i));
matrix* j=create_matrix(2,2);
value temp_i[4] = { 18, 60, 41, 24};
assert(insert_array(temp_i,j));
assert(compare_matrices(j,i));
value temp_j[4] = { 97, 66, 19, 85};
assert(insert_array(temp_j,j));
assert(get_sub_matrix(3,4,3,4,a,i));
assert(compare_matrices(j,i));
assert(!get_sub_matrix(2,4,3,4,a,i));
assert(!get_sub_matrix(3,4,2,4,a,i));
assert(!get_sub_matrix(4,5,4,5,a,i));
assert(!get_sub_matrix(0,1,0,1,a,i));
//test insert_row_vector
assert(insert_array(temp_a,a));
value temp_k[16] = { 18, 60, 57, 96,
18, 60, 57, 96,
14, 30, 97, 66,
51, 13, 19, 85 };
assert(insert_array(temp_k,b));
assert(insert_array(temp_d,e));
assert(insert_row_vector(2,e,a));
assert(compare_matrices(a,b));
end = clock();
time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
printf("time taken was: %f \n",time_spent);
free_matrix(a);
free_matrix(b);
free_matrix(d);
free_matrix(e);
free_matrix(f);
free_matrix(g);
free_matrix(h);
free_matrix(i);
free_matrix(j);
return 0;
}
/**
* NAME: strassen_postprocess
* INPUT: MATRIX* mOrig, MATRIX* mNew2, int colSize, int rowSize
* USAGE: Strips zeros from mOrig and outputs a new rowSize by colSize matrix.
*
* NOTES: Assumes all inputs are already initialized.
*/
void strassen_helper(MATRIX* m1, MATRIX* m2, MATRIX* res)
{
// base case
if (m1->numRows <= 1)
{
mult_bignums(&m1->matrix[0][0], &m2->matrix[0][0], &res->matrix[0][0]);
}
else
{
// split mOrig1 & mOrig2 into a 2x2 of submatrices
int n = m1->numRows/2;
// Initialize submatrices
MATRIX* a11 = malloc(sizeof(MATRIX));
MATRIX* a12 = malloc(sizeof(MATRIX));
MATRIX* a21 = malloc(sizeof(MATRIX));
MATRIX* a22 = malloc(sizeof(MATRIX));
MATRIX* b11 = malloc(sizeof(MATRIX));
MATRIX* b12 = malloc(sizeof(MATRIX));
MATRIX* b21 = malloc(sizeof(MATRIX));
MATRIX* b22 = malloc(sizeof(MATRIX));
zero_matrix(n,n,a11);
zero_matrix(n,n,a12);
zero_matrix(n,n,a21);
zero_matrix(n,n,a22);
zero_matrix(n,n,b11);
zero_matrix(n,n,b12);
zero_matrix(n,n,b21);
zero_matrix(n,n,b22);
// Strassens algorithm
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
// First matrix
a11->matrix[i][j] = m1->matrix[i][j];
a12->matrix[i][j] = m1->matrix[i][j+n];
a21->matrix[i][j] = m1->matrix[i+n][j];
a22->matrix[i][j] = m1->matrix[i+n][j+n];
// Second matrix
b11->matrix[i][j] = m2->matrix[i][j];
b12->matrix[i][j] = m2->matrix[i][j+n];
b21->matrix[i][j] = m2->matrix[i+n][j];
b22->matrix[i][j] = m2->matrix[i+n][j+n];
}
}
// Create two temporary matrices
MATRIX* temp1 = malloc(sizeof(MATRIX));
MATRIX* temp2 = malloc(sizeof(MATRIX));
zero_matrix(n,n,temp1);
zero_matrix(n,n,temp2);
// The 7 important variable matrices of Strassens algorithm
MATRIX* x1 = malloc(sizeof(MATRIX));
MATRIX* x2 = malloc(sizeof(MATRIX));
MATRIX* x3 = malloc(sizeof(MATRIX));
MATRIX* x4 = malloc(sizeof(MATRIX));
MATRIX* x5 = malloc(sizeof(MATRIX));
MATRIX* x6 = malloc(sizeof(MATRIX));
MATRIX* x7 = malloc(sizeof(MATRIX));
zero_matrix(n,n,x1);
zero_matrix(n,n,x2);
zero_matrix(n,n,x3);
zero_matrix(n,n,x4);
zero_matrix(n,n,x5);
zero_matrix(n,n,x6);
zero_matrix(n,n,x7);
// Fill those 7 matrices with the correct values
add_matrices(a11, a22, temp1);
add_matrices(b11, b22, temp2);
strassen_helper(temp1, temp2, x1);
add_matrices(a21, a22, temp1);
strassen_helper(temp1, b11, x2);
subtract_matrices(b12, b22, temp2);
strassen_helper(a11, temp2, x3);
subtract_matrices(b21, b11, temp2);
strassen_helper(a22, temp2, x4);
add_matrices(a11, a12, temp1);
strassen_helper(temp1, b22, x5);
subtract_matrices(a21, a11, temp1);
add_matrices(b11, b12, temp2);
strassen_helper(temp1, temp2, x6);
subtract_matrices(a12, a22, temp1);
add_matrices(b21, b22, temp2);
strassen_helper(temp1, temp2, x7);
// 4 temporary result submatrices
MATRIX* res11 = malloc(sizeof(MATRIX));
MATRIX* res12 = malloc(sizeof(MATRIX));
MATRIX* res21 = malloc(sizeof(MATRIX));
MATRIX* res22 = malloc(sizeof(MATRIX));
zero_matrix(n, n, res11);
zero_matrix(n, n, res12);
zero_matrix(n, n, res21);
zero_matrix(n, n, res22);
add_matrices(x3, x5, res12);
add_matrices(x2, x4, res21);
add_matrices(x1, x4, temp1);
add_matrices(temp1, x7, temp2);
subtract_matrices(temp2, x5, res11);
add_matrices(x1, x3, temp1);
add_matrices(temp1, x6, temp2);
subtract_matrices(temp2, x2, res22);
// Group submatrices
for (int i=0; i<n; i++)
{
for (int j=0; j<n; j++)
{
// first matrix
res->matrix[i][j] = res11->matrix[i][j];
res->matrix[i][j+n] = res12->matrix[i][j];
res->matrix[i+n][j] = res21->matrix[i][j];
res->matrix[i+n][j+n] = res22->matrix[i][j];
}
}
// Free all matrices.
free_matrix(a11);
free_matrix(a12);
free_matrix(a21);
free_matrix(a22);
free_matrix(b11);
free_matrix(b12);
free_matrix(b21);
free_matrix(b22);
free_matrix(temp1);
free_matrix(temp2);
free_matrix(x1);
free_matrix(x2);
free_matrix(x3);
free_matrix(x4);
free_matrix(x5);
free_matrix(x6);
free_matrix(x7);
free_matrix(res11);
free_matrix(res12);
free_matrix(res21);
free_matrix(res22);
}
}
int main(void)
{
int retval = 0;
int choice = 0;
short *prandom_data;
#ifdef PATCHED_1
char m_result_data[MAX_ROWS * MAX_COLS * sizeof(int)];
#else
char m_result_data[((MAX_ROWS * MAX_COLS) - 1) * sizeof(int)];
#endif
prandom_data = create_random_shorts();
matrix_t *m;
matrix_t *m1, *m2;
matrix_t *m_result;
m1 = create_matrix(SHORT, NULL);
m2 = create_matrix(SHORT, NULL);
m_result = create_matrix(INT, m_result_data);
char *input = malloc(2048);
printf("Matrix math is fun!\n");
printf("-------------------\n");
while (1)
{
choice = select_menu_choice(input, LINE_SIZE);
switch(choice)
{
case 1:
printf("Inputting Matrix Values:\n");
m = choose_matrix(m1, m2, input, LINE_SIZE);
if (!m)
goto cgc_exit;
if (input_matrix(m, input, LINE_SIZE) == ERROR)
goto cgc_exit;
break;
case 2:
printf("Print Matrices:\n");
print_matrices(m1, m2, m_result);
break;
case 3:
printf("Adding Matrices:\n");
add_matrices(m1, m2, m_result);
break;
case 4:
printf("Subtracting Matrices:\n");
subtract_matrices(m1, m2, m_result);
break;
case 5:
printf("Multiplying Matrices:\n");
multiply_matrices(m1, m2, m_result);
break;
case 6:
printf("Swap Rows in a Matrix:\n");
m = choose_matrix(m1, m2, input, LINE_SIZE);
if (!m)
goto cgc_exit;
retval = swap_matrix_row_col(m, SWAP_ROW, input, LINE_SIZE);
if (retval == ERROR)
goto cgc_exit;
if (retval == SUCCESS)
print_matrix("Swapped Rows", m);
break;
case 7:
printf("Swap Columns in a Matrix:\n");
m = choose_matrix(m1, m2, input, LINE_SIZE);
if (!m)
goto cgc_exit;
retval = swap_matrix_row_col(m, SWAP_COL, input, LINE_SIZE);
if (retval == ERROR)
goto cgc_exit;
if (retval == SUCCESS)
print_matrix("Swapped Columns", m);
break;
case 8:
printf("Transpose a Matrix:\n");
m = choose_matrix(m1, m2, input, LINE_SIZE);
if (!m)
goto cgc_exit;
transpose_matrix(m);
break;
case 9:
printf("Perform Reduced Row Echelon Form on Matrix\n");
m = choose_matrix(m1, m2, input, LINE_SIZE);
if (!m)
goto cgc_exit;
rref_matrix(m, m_result);
break;
case 10:
printf("Create a Random Matrix:\n");
m = choose_matrix(m1, m2, input, LINE_SIZE);
if (!m)
goto cgc_exit;
if (random_matrix(m, input, LINE_SIZE, prandom_data) == ERROR)
goto cgc_exit;
break;
case 11:
goto cgc_exit;
default:
printf("Bad Selection\n");
}
}
cgc_exit:
printf("Exiting...\n");
return 0;
}
