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; }