int main() { int a[3][3]; int b[3][3]; int c[3][3]; //Q2: define pointers (5) //Define pointers ap, bp, and cp to the matrices that are defined above //SOLUTION CODE int* ap = &a[0][0]; int* bp = &b[0][0]; int* cp = &c[0][0]; //SOLUTION CODE initialize_matrices(ap, bp, cp); printf("Matrix a:\n"); fill_matrix(ap); printf("Matrix b:\n"); fill_matrix(bp); add_matrices(ap, bp, cp); print_sum_matrix(cp); return 0; }
MDArray<double> Shrinkage::combine(MDArray<double> target,MDArray<double> MLE,double lambda) { assert(target.get_shape() == MLE.get_shape()); // assert(lambda>=0 && lambda<=1); lambda = std::max(lambda, 0.0); lambda = std::min(lambda, 1.0); return add_matrices(mult_num_to_matrix(target,lambda),mult_num_to_matrix(MLE,1-lambda)); }
//#define DEBUG void SymList::compute_subgroup() { Matrix2D<DOUBLE> I(4, 4); I.initIdentity(); Matrix2D<DOUBLE> L1(4, 4), R1(4, 4), L2(4, 4), R2(4, 4), newL(4, 4), newR(4, 4); Matrix2D<int> tried(true_symNo, true_symNo); int i, j; int new_chain_length; while (found_not_tried(tried, i, j, true_symNo)) { tried(i, j) = 1; get_matrices(i, L1, R1); get_matrices(j, L2, R2); newL = L1 * L2; newR = R1 * R2; new_chain_length = __chain_length(i) + __chain_length(j); Matrix2D<DOUBLE> newR3 = newR; newR3.resize(3,3); if (newL.isIdentity() && newR3.isIdentity()) continue; // Try to find it in current ones bool found; found = false; for (int l = 0; l < SymsNo(); l++) { get_matrices(l, L1, R1); if (newL.equal(L1) && newR.equal(R1)) { found = true; break; } } if (!found) { //#define DEBUG #ifdef DEBUG std::cout << "Matrix size " << tried.Xdim() << " " << "trying " << i << " " << j << " " << "chain length=" << new_chain_length << std::endl; std::cout << "Result R Sh\n" << newR; #endif #undef DEBUG newR.setSmallValuesToZero(); newL.setSmallValuesToZero(); add_matrices(newL, newR, new_chain_length); tried.resize(MAT_YSIZE(tried) + 1, MAT_XSIZE(tried) + 1); } } }
static char *test_add_matrices() { // We should create 2 empty matrices. If we add them we should get // an empty matrix. Matrix *a = create_matrix(2, 2); Matrix *b = create_matrix(2, 2); // We will store the result of the adition in a third matrix c. Matrix *c = create_matrix(2, 2); add_matrices(a, b, &c); // Since a and b are empty their result will an empty matrix too // so it makes sense to compare c against b or a. mu_assert("c != a or b", compare_matrices(a, c)); destroy_matrix(a); destroy_matrix(b); destroy_matrix(c); return 0; }
int main(void) { int m1[100][100], m2[100][100], destination_matrix[100][100], n_rows, n_columns, i, j; //defining all the variables scanf ("%d %d", &n_rows, &n_columns); // enter the number of rows and columns for matrices printf("Enter the First matrix->"); for(i=0;i<n_rows;i++) for(j=0;j<n_columns;j++) scanf("%d",&m1[i][j]); // enter matrix m1 printf("\nEnter the Second matrix->"); for(i=0;i<n_rows;i++){ for(j=0;j<n_columns;j++){ scanf("%d",&m2[i][j]); // enter matrix m2 } } add_matrices(m1, m2, destination_matrix, n_rows,n_columns); // call value from function "add_matrices" for(i=0;i<n_rows;i++){ for(j=0;j<n_columns;j++){ printf ("%d ",destination_matrix[i][j]); // print/show the resulting matrix from the addition } printf ("\n"); } 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); } }
/* * PURPOSE: run the commands which user entered * INPUTS: * cmd double pointer that holds all commands * mats the matrix list * num_mats the number of matrix in the list * RETURN: void * If no errors occurred during process then return nothing * else print error message **/ void run_commands (Commands_t* cmd, Matrix_t** mats, unsigned int num_mats) { //TODO ERROR CHECK INCOMING PARAMETERS if(!cmd){ printf("commands array is null\n"); return; } if(!(*mats)){ printf("matrix list is null\n"); return; } /*Parsing and calling of commands*/ if (strncmp(cmd->cmds[0],"display",strlen("display") + 1) == 0 && cmd->num_cmds == 2) { /*find the requested matrix*/ int idx = find_matrix_given_name(mats,num_mats,cmd->cmds[1]); if (idx >= 0) { display_matrix (mats[idx]); } else { printf("Matrix (%s) doesn't exist\n", cmd->cmds[1]); return; } } else if (strncmp(cmd->cmds[0],"add",strlen("add") + 1) == 0 && cmd->num_cmds == 4) { int mat1_idx = find_matrix_given_name(mats,num_mats,cmd->cmds[1]); int mat2_idx = find_matrix_given_name(mats,num_mats,cmd->cmds[2]); if (mat1_idx >= 0 && mat2_idx >= 0) { Matrix_t* c = NULL; if( !create_matrix (&c,cmd->cmds[3], mats[mat1_idx]->rows, mats[mat1_idx]->cols)) { printf("Failure to create the result Matrix (%s)\n", cmd->cmds[3]); return; } if(add_matrix_to_array(mats,c, num_mats) == 999){ perror("PROGRAM FAILED TO ADD MATRIX TO ARRAY\n"); return; } //TODO ERROR CHECK NEEDED if (! add_matrices(mats[mat1_idx], mats[mat2_idx],c) ) { printf("Failure to add %s with %s into %s\n", mats[mat1_idx]->name, mats[mat2_idx]->name,c->name); return; } } } else if (strncmp(cmd->cmds[0],"duplicate",strlen("duplicate") + 1) == 0 && cmd->num_cmds == 3 && strlen(cmd->cmds[1]) + 1 <= MATRIX_NAME_LEN) { int mat1_idx = find_matrix_given_name(mats,num_mats,cmd->cmds[1]); if (mat1_idx >= 0 ) { Matrix_t* dup_mat = NULL; if( !create_matrix (&dup_mat,cmd->cmds[2], mats[mat1_idx]->rows, mats[mat1_idx]->cols)) { return; } if(!duplicate_matrix (mats[mat1_idx], dup_mat)){ perror("PROGRAM FAILED TO DUPLICATE MATRIX\n"); return; } //TODO ERROR CHECK NEEDED if(add_matrix_to_array(mats,dup_mat,num_mats) == 999){ perror("PROGRAM FAILED TO ADD MATRIX TO ARRAY\n"); return; } //TODO ERROR CHECK NEEDED printf ("Duplication of %s into %s finished\n", mats[mat1_idx]->name, cmd->cmds[2]); } else { printf("Duplication Failed\n"); return; } } else if (strncmp(cmd->cmds[0],"equal",strlen("equal") + 1) == 0 && cmd->num_cmds == 2) { int mat1_idx = find_matrix_given_name(mats,num_mats,cmd->cmds[1]); int mat2_idx = find_matrix_given_name(mats,num_mats,cmd->cmds[2]); if (mat1_idx >= 0 && mat2_idx >= 0) { if ( equal_matrices(mats[mat1_idx],mats[mat2_idx]) ) { printf("SAME DATA IN BOTH\n"); } else { printf("DIFFERENT DATA IN BOTH\n"); } } else { printf("Equal Failed\n"); return; } } else if (strncmp(cmd->cmds[0],"shift",strlen("shift") + 1) == 0 && cmd->num_cmds == 4) { int mat1_idx = find_matrix_given_name(mats,num_mats,cmd->cmds[1]); const int shift_value = atoi(cmd->cmds[3]); if (mat1_idx >= 0 ) { if(!bitwise_shift_matrix(mats[mat1_idx],cmd->cmds[2][0], shift_value)){ perror("PROGRAM FAILED TO SHIFT MATRIX\n"); return; } //TODO ERROR CHECK NEEDED printf("Matrix (%s) has been shifted by %d\n", mats[mat1_idx]->name, shift_value); } else { printf("Matrix shift failed\n"); return; } } else if (strncmp(cmd->cmds[0],"read",strlen("read") + 1) == 0 && cmd->num_cmds == 2) { Matrix_t* new_matrix = NULL; if(! read_matrix(cmd->cmds[1],&new_matrix)) { printf("Read Failed\n"); return; } if(add_matrix_to_array(mats,new_matrix, num_mats) == 999){ perror("PROGRAM FAILED TO ADD MATRIX TO ARRAY\n"); return; } //TODO ERROR CHECK NEEDED printf("Matrix (%s) is read from the filesystem\n", cmd->cmds[1]); } else if (strncmp(cmd->cmds[0],"write",strlen("write") + 1) == 0 && cmd->num_cmds == 2) { int mat1_idx = find_matrix_given_name(mats,num_mats,cmd->cmds[1]); if(! write_matrix(mats[mat1_idx]->name,mats[mat1_idx])) { printf("Write Failed\n"); return; } else { printf("Matrix (%s) is wrote out to the filesystem\n", mats[mat1_idx]->name); } } else if (strncmp(cmd->cmds[0], "create", strlen("create") + 1) == 0 && strlen(cmd->cmds[1]) + 1 <= MATRIX_NAME_LEN && cmd->num_cmds == 4) { Matrix_t* new_mat = NULL; const unsigned int rows = atoi(cmd->cmds[2]); const unsigned int cols = atoi(cmd->cmds[3]); if(!create_matrix(&new_mat,cmd->cmds[1],rows, cols)){ perror("PROGRAM FAILED TO ADD CREATE TO ARRAY\n"); return; } //TODO ERROR CHECK NEEDED if(add_matrix_to_array(mats,new_mat,num_mats) == 999){ perror("PROGRAM FAILED TO ADD MATRIX TO ARRAY\n"); return; } // TODO ERROR CHECK NEEDED printf("Created Matrix (%s,%u,%u)\n", new_mat->name, new_mat->rows, new_mat->cols); } else if (strncmp(cmd->cmds[0], "random", strlen("random") + 1) == 0 && cmd->num_cmds == 4) { int mat1_idx = find_matrix_given_name(mats,num_mats,cmd->cmds[1]); const unsigned int start_range = atoi(cmd->cmds[2]); const unsigned int end_range = atoi(cmd->cmds[3]); if(!random_matrix(mats[mat1_idx],start_range, end_range)) { perror("PROGRAM FAILED TO RANDOMIZE MATRIX\n"); return; } //TODO ERROR CHECK NEEDED printf("Matrix (%s) is randomized between %u %u\n", mats[mat1_idx]->name, start_range, end_range); } else { printf("Not a command in this application\n"); } }
double moment ( int moment_n, double x[][3], double y[][3], double delta) { int n_steps = 100; int phi_n_steps = 100; int i, j, n; int k, t, p; double value = 0.0; double delta_sq = delta*delta; double kappa, theta, phi; double kappa_step, theta_step, phi_step; double cosk, sink, costh, sinth; double surface_element, phi_contributn; double ATA [4][4] = {{0.0}}; double prev_ATA[4][4] = {{0.0}}; double ATA_sum [4][4] = {{0.0}}; double a[3] = {0.0}, b[3] = {0.0}; double q[4] = {0.0}; /**************/ int construct_ATA (double ATA[4][4], double a[3],double b[3]); int add_matrices (double matrix1[4][4],double matrix2[4][4],double result[4][4]); double braket (double ATA[4][4], double q[4]); /* sum of A^TA matrices */ for (n=0; n<moment_n; n++ ) { for (i=0; i<3; i++ ) { a[i] = y[n][i] + x[n][i]; b[i] = y[n][i] - x[n][i]; } construct_ATA (ATA, a, b); add_matrices (prev_ATA, ATA, ATA_sum); memcpy (prev_ATA[0], ATA_sum[0], 4*4*sizeof(double)); } if (0) { /*check */ q[0] = 1; for (i=0; i<4; i++ ) { for (j=0; j<4; j++ ) { printf ("%8.3lf ", ATA_sum[i][j]); } printf ("\n"); } printf ("\n"); double aux, sum_sq = 0.0;; for (i=0; i<4; i++ ) { aux = x[1][i]-y[1][i]; sum_sq += aux*aux; } printf ( " 00: %8.4le %8.4le %8.4le \n", ATA_sum[0][0], braket(ATA_sum, q), sum_sq); exit(1); } value = 0.0; kappa_step = M_PI/n_steps; theta_step = M_PI/n_steps; phi_step = 2*M_PI/phi_n_steps; /* for angles kappa, theta phi */ for (k=1; k<=n_steps; k++) { kappa = ( (double)k-0.5)*kappa_step; cosk = cos(kappa); sink = sin(kappa); q[0] = cosk; for (t=1; t<=n_steps; t++) { theta = ( (double)t-0.5)*theta_step; sinth = sin (theta); costh = cos (theta); q[3] = sink*costh; surface_element = sink*sink*sinth; phi_contributn = 0; for (p=1; p<=phi_n_steps; p++) { phi = ((double)p-0.5)*phi_step; q[1] = sink*sinth*cos(phi); q[2] = sink*sinth*sin(phi); phi_contributn += exp(-braket(ATA_sum, q)/delta_sq); //value += sink*sink*sinth; //printf ( "%3d %3d %3d %8.4le %8.2le -- %8.4le \n", k, t, p, //braket(ATA, q), exp(-braket(ATA, q)/delta_sq), phi_contributn); } value += phi_contributn*surface_element; } } value *= kappa_step*theta_step*phi_step; /*integration steps*/ value /= 2*M_PI*M_PI; /* the function should return the average*/ return value; }
int mappedCoords2rotation (double **x, double **y, int no_vectors, double q[4], double **R, double T[3], double *rmsd) { double x_mp[3], y_mp[3]; int ctr; int i, j; double ATA [4][4] = {{0.0}}; double prev_ATA[4][4] = {{0.0}}; double ATA_sum [4][4] = {{0.0}}; double a[3] = {0.0}, b[3] = {0.0}; int add_matrices (double matrix1[4][4],double matrix2[4][4], double result[4][4]); int construct_ATA (double ATA[4][4], double a[3], double b[3]); /* note how we pass the matrix: pointer to the first element in the block */ void dsyev_ (char * jobz, char *uplo, int *n, double *A, int * lda, double * w, double * work, int * lwork, int *info); if (!no_vectors) { *rmsd = -1; return 1; } memset ( &(q[0]), 0, 4*sizeof(double) ); /* turn the matching atoms into vectors x and y - use only c-alphas*/ /* check: */ if (0) { printf (" Number of vectors read in: %d. \n", no_vectors); for ( ctr =0; ctr < no_vectors; ctr++ ) { printf ("\t x%1d %10.4lf %10.4lf %10.4lf ", ctr, x[0][ctr], x[1][ctr], x[2][ctr]); printf ("\t y%1d %10.4lf %10.4lf %10.4lf \n", ctr, y[0][ctr], y[1][ctr], y[2][ctr]); } exit (1); } /* find the meanpoints: */ for ( i =0; i < 3; i++ ) { x_mp[i] = 0.0; y_mp[i] = 0.0; } for ( ctr =0; ctr < no_vectors; ctr++ ) { for ( i =0; i < 3; i++ ) { x_mp[i] += x[i][ctr]; y_mp[i] += y[i][ctr]; } } for ( i =0; i < 3; i++ ) { x_mp[i] /= no_vectors; y_mp[i] /= no_vectors; } /* subtract them from x, y */ for ( ctr =0; ctr < no_vectors; ctr++ ) { for ( i =0; i < 3; i++ ) { x[i][ctr] -= x_mp[i]; y[i][ctr] -= y_mp[i]; } } /* B = ATA_sum matrix to diagonalize in order to get the quaternion */ for ( ctr =0; ctr < no_vectors; ctr++ ) { for (i=0; i<3; i++ ) { a[i] = y[i][ctr] + x[i][ctr]; b[i] = y[i][ctr] - x[i][ctr]; } construct_ATA (ATA, a, b); add_matrices (prev_ATA, ATA, ATA_sum); memcpy (prev_ATA[0], ATA_sum[0], 4*4*sizeof(double)); } for (i=0; i<4; i++ ) { for (j=0; j<4; j++ ) { ATA_sum[i][j] /= no_vectors; } } /* diagonalize ATA_sum - the eigenvector corresponsing to the smallest lambda is the quaternion we are looking for; the eigenvalue is the rmsd*/ /* use the nomenclature from dsyev*/ char jobz= 'V'; /*Compute eigenvalues and eigenvectors.*/ char uplo= 'U'; /* Upper triangle of A (the matrix we are diagonalizing) is stored; */ int n = 4; /* order and the leading dimension of A */ int lda = 4; double ** A; int info; int lwork = 200; double w [4]; double work[200]; if ( !( A=dmatrix(4,4) ) ) exit (1); memcpy (A[0], ATA_sum[0], 4*4*sizeof(double)); /* note how we pass the matrix: */ dsyev_ ( &jobz, &uplo, &n, A[0], &lda, w, work, &lwork, &info); if ( ! info) { *rmsd = sqrt (w[0]); for (i=0; i<4; i++ ) q[i] = A[0][i]; if (0) { /* w contains the eigenvalues */ printf ("\n"); for (i=0; i<4; i++ ) printf ("%8.3lf ", w[i]); printf ("\nrmsd: %8.3lf \n", *rmsd); printf ("quat:\n"); for (i=0; i<4; i++ ) printf ("%8.3lf ", q[i]); printf ("\n"); /* printf (" opt lwork: %d\n", (int) work[0]); */ } } else { fprintf (stderr, "Error in dsyev().\n"); exit (1); } /* construct the rotation matrix R */ quat_to_R (q,R); /* T = y_mp - R x_mp */ for (i=0; i<3; i++ ) { T[i] = y_mp[i]; for (j=0; j<3; j++ ) { T[i] -= R[i][j]*x_mp[j]; } } free_dmatrix(A); return 0; }
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; }
/* * PURPOSE: Runs various commands for the operations to be performed on the matrices * INPUTS: command array, matrix array, size of matrix array * RETURN: Nothing **/ void run_commands (Commands_t* cmd, Matrix_t** mats, unsigned int num_mats) { if(cmd == NULL || mats == NULL || num_mats <= 0) return; /*Parsing and calling of commands*/ if (strncmp(cmd->cmds[0],"display",strlen("display") + 1) == 0 && cmd->num_cmds == 2) { /*find the requested matrix*/ int idx = find_matrix_given_name(mats,num_mats,cmd->cmds[1]); if (idx >= 0) { display_matrix (mats[idx]); } else { printf("Matrix (%s) doesn't exist\n", cmd->cmds[1]); return; } } else if (strncmp(cmd->cmds[0],"add",strlen("add") + 1) == 0 && cmd->num_cmds == 4) { int mat1_idx = find_matrix_given_name(mats,num_mats,cmd->cmds[1]); int mat2_idx = find_matrix_given_name(mats,num_mats,cmd->cmds[2]); if (mat1_idx >= 0 && mat2_idx >= 0) { Matrix_t* c = NULL; if( !create_matrix (&c,cmd->cmds[3], mats[mat1_idx]->rows, mats[mat1_idx]->cols)) { printf("Failure to create the result Matrix (%s)\n", cmd->cmds[3]); return; } if(add_matrix_to_array(mats,c, num_mats) == -1){ printf("Failed to add matrix to the array"); return; } if (! add_matrices(mats[mat1_idx], mats[mat2_idx],c) ) { printf("Failure to add %s with %s into %s\n", mats[mat1_idx]->name, mats[mat2_idx]->name,c->name); return; } } } else if (strncmp(cmd->cmds[0],"duplicate",strlen("duplicate") + 1) == 0 && cmd->num_cmds == 3 && strlen(cmd->cmds[1]) + 1 <= MATRIX_NAME_LEN) { int mat1_idx = find_matrix_given_name(mats,num_mats,cmd->cmds[1]); if (mat1_idx >= 0 ) { Matrix_t* dup_mat = NULL; if( !create_matrix (&dup_mat,cmd->cmds[2], mats[mat1_idx]->rows, mats[mat1_idx]->cols)) { return; } if(duplicate_matrix (mats[mat1_idx], dup_mat) == false){ printf("Duplication Failed\n"); return; } if(add_matrix_to_array(mats,dup_mat,num_mats) == -1){ printf("Failed to add matrix to array\n"); return; } printf ("Duplication of %s into %s finished\n", mats[mat1_idx]->name, cmd->cmds[2]); } else { printf("Duplication Failed\n"); return; } } else if (strncmp(cmd->cmds[0],"equal",strlen("equal") + 1) == 0 && cmd->num_cmds == 3) { int mat1_idx = find_matrix_given_name(mats,num_mats,cmd->cmds[1]); int mat2_idx = find_matrix_given_name(mats,num_mats,cmd->cmds[2]); if (mat1_idx >= 0 && mat2_idx >= 0) { if ( equal_matrices(mats[mat1_idx],mats[mat2_idx]) ) { printf("SAME DATA IN BOTH\n"); } else { printf("DIFFERENT DATA IN BOTH\n"); } } else { printf("Equal Failed\n"); return; } } else if (strncmp(cmd->cmds[0],"shift",strlen("shift") + 1) == 0 && cmd->num_cmds == 4) { int mat1_idx = find_matrix_given_name(mats,num_mats,cmd->cmds[1]); const int shift_value = atoi(cmd->cmds[3]); if (mat1_idx <= 0 ) { printf("Matrix shift failed\n"); return; } if(bitwise_shift_matrix(mats[mat1_idx],cmd->cmds[2][0], shift_value) == false){ printf("Matrix shift failed\n"); return; } else printf("Matrix (%s) has been shifted by %d\n", mats[mat1_idx]->name, shift_value); } else if (strncmp(cmd->cmds[0],"read",strlen("read") + 1) == 0 && cmd->num_cmds == 2) { Matrix_t* new_matrix = NULL; if(! read_matrix(cmd->cmds[1],&new_matrix)) { printf("Read Failed\n"); return; } if(add_matrix_to_array(mats,new_matrix, num_mats) == -1){ printf("Failed to add matrix to the array"); ; } printf("Matrix (%s) is read from the filesystem\n", cmd->cmds[1]); } else if (strncmp(cmd->cmds[0],"write",strlen("write") + 1) == 0 && cmd->num_cmds == 2) { int mat1_idx = find_matrix_given_name(mats,num_mats,cmd->cmds[1]); if(! write_matrix(mats[mat1_idx]->name,mats[mat1_idx])) { printf("Write Failed\n"); return; } else { printf("Matrix (%s) is wrote out to the filesystem\n", mats[mat1_idx]->name); } } else if (strncmp(cmd->cmds[0], "create", strlen("create") + 1) == 0 && strlen(cmd->cmds[1]) + 1 <= MATRIX_NAME_LEN && cmd->num_cmds == 4) { Matrix_t* new_mat = NULL; const unsigned int rows = atoi(cmd->cmds[2]); const unsigned int cols = atoi(cmd->cmds[3]); if(create_matrix(&new_mat,cmd->cmds[1],rows, cols) == false){ printf("Failed to create the matrix"); return; } if(add_matrix_to_array(mats,new_mat,num_mats) == -1){ printf("Failed to add matrix to the array"); return; } printf("Created Matrix (%s,%u,%u)\n", new_mat->name, new_mat->rows, new_mat->cols); } else if (strncmp(cmd->cmds[0], "random", strlen("random") + 1) == 0 && cmd->num_cmds == 4) { int mat1_idx = find_matrix_given_name(mats,num_mats,cmd->cmds[1]); const unsigned int start_range = atoi(cmd->cmds[2]); const unsigned int end_range = atoi(cmd->cmds[3]); if(random_matrix(mats[mat1_idx],start_range, end_range) == false){ printf("Failed to randomize\n"); return;//TODO ERROR CHECK NEEDED } printf("Matrix (%s) is randomized between %u %u\n", mats[mat1_idx]->name, start_range, end_range); } else { printf("Not a command in this application\n"); } }
int opt_quat ( double ** x, int NX, int *set_of_directions_x, double ** y, int NY, int *set_of_directions_y, int set_size, double * q, double * rmsd) { double * x_sub[set_size], * y_sub[set_size]; int ctr; int i, j; double ATA [4][4] = {{0.0}}; double prev_ATA[4][4] = {{0.0}}; double ATA_sum [4][4] = {{0.0}}; double a[3] = {0.0}, b[3] = {0.0}; int add_matrices (double matrix1[4][4],double matrix2[4][4], double result[4][4]); int construct_ATA (double ATA[4][4], double a[3], double b[3]); /* note how we pass the matrix: pointer to the first element in the block */ void dsyev_ (char * jobz, char *uplo, int *n, double *A, int * lda, double * w, double * work, int * lwork, int *info); if (!set_size) { *rmsd = -1; return 1; } memset ( &(q[0]), 0, 4*sizeof(double) ); /* find the subset */ ctr = 0; for ( ctr =0; ctr < set_size; ctr++ ) { x_sub[ctr] = x[set_of_directions_x[ctr]]; y_sub[ctr] = y[set_of_directions_y[ctr]]; } /* check: */ if (0) { printf (" Number of vectors to match: %d. \n", set_size); for ( ctr =0; ctr < set_size; ctr++ ) { printf ("\t x%1d %10.4lf %10.4lf %10.4lf ", ctr, x_sub[ctr][0], x_sub[ctr][1], x_sub[ctr][2]); printf ("\t y%1d %10.4lf %10.4lf %10.4lf \n", ctr, y_sub[ctr][0], y_sub[ctr][1], y_sub[ctr][2]); } exit (1); } /* B = ATA_sum matrix to diagonalize in order to get the quaternion */ for ( ctr =0; ctr < set_size; ctr++ ) { for (i=0; i<3; i++ ) { a[i] = y_sub[ctr][i] + x_sub[ctr][i]; b[i] = y_sub[ctr][i] - x_sub[ctr][i]; } construct_ATA (ATA, a, b); add_matrices (prev_ATA, ATA, ATA_sum); memcpy (prev_ATA[0], ATA_sum[0], 4*4*sizeof(double)); } for (i=0; i<4; i++ ) { for (j=0; j<4; j++ ) { ATA_sum[i][j] /= set_size; } } /* diagonalize ATA_sum - the eigenvector corresponsing to the smallest lambda is the quaternion we are looking for; the eigenvalue is the rmsd*/ /* use the nomenclature from dsyev*/ char jobz= 'V'; /*Compute eigenvalues and eigenvectors.*/ char uplo= 'U'; /* Upper triangle of A (the matrix we are diagonalizing) is stored; */ int n = 4; /* order and the leading dimension of A */ int lda = 4; double ** A; int info; int lwork = 200; double w [4]; double work[200]; if ( !( A=dmatrix(4,4) ) ) exit (1); memcpy (A[0], ATA_sum[0], 4*4*sizeof(double)); /* note how we pass the matrix: */ dsyev_ ( &jobz, &uplo, &n, A[0], &lda, w, work, &lwork, &info); if ( ! info) { *rmsd = sqrt (w[0]); for (i=0; i<4; i++ ) q[i] = A[0][i]; if (0) { /* w contains the eigenvalues */ printf ("\n"); for (i=0; i<4; i++ ) printf ("%8.3lf ", w[i]); printf ("\nrmsd: %8.3lf \n", *rmsd); printf ("quat:\n"); for (i=0; i<4; i++ ) printf ("%8.3lf ", q[i]); printf ("\n"); /* printf (" opt lwork: %d\n", (int) work[0]); */ } } else { fprintf (stderr, "Error in dsyev().\n"); exit (1); } free_dmatrix(A); return 0; }
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; }