grid hard_sudoku(){ grid board = fill_with_zeros(); board.array[0][0] = 8; board.array[0][3] = 4; board.array[0][5] = 6; board.array[0][8] = 7; board.array[1][6] = 4; board.array[2][1] = 1; board.array[2][6] = 6; board.array[2][7] = 5; board.array[3][0] = 5; board.array[3][2] = 9; board.array[3][4] = 3; board.array[3][6] = 7; board.array[3][7] = 8; board.array[4][4] = 7; board.array[5][1] = 4; board.array[5][2] = 8; board.array[5][4] = 2; board.array[5][6] = 1; board.array[5][8] = 3; board.array[6][1] = 5; board.array[6][2] = 2; board.array[6][7] = 9; board.array[7][2] = 1; board.array[8][0] = 3; board.array[8][3] = 9; board.array[8][5] = 2; board.array[8][8] = 5; return board; }
int main(){ int i,j,len, carry; int tmp; char *pos; fill_with_zeros(output,MAX); while(1){ fgets(number, MAX, stdin); if ((pos=strchr(number, '\n')) != NULL) *pos = '\0'; len = strlen(number); if(len == 1 && number[0] == '0') break; fill_with_zeros(number, len); carry = 0; j = strlen(output)-1; for(i=strlen(number)-1; i >= 0; --i, --j){ number[i] = ((number[i] - '0') + carry)+'0'; tmp = (number[i] - '0') + (output[j] - '0'); if(tmp >= 10){ carry = 1; tmp -= 10; }else{ carry = 0; } output[j] = (tmp)+'0'; } } j=0; while(output[j++] == '0'); for(i=j-1; i<strlen(output); i++) printf("%c", output[i]); printf("\n"); return 0; }
int main(int argc, char **argv){ /* Variables declaration */ int i; int j; /* Number of rounds to run the algorithm */ int rounds = 0; /* Total size of the array */ int total_size = (rows * columns) / participants; printf("Total amount of work is %d\n", total_size); /* the amount of work that is assigned to worker1 */ int amount_of_work = floor( (worker1 + 1) * columns / participants ) - floor( worker1 * columns / participants ); printf("amount of work is %d\n", amount_of_work); /* Session start */ session *s; join_session(&argc, &argv, &s, "worker1.spr"); role *master = s->get_role(s, "master"); /* Dynamic memory allocation of array C */ int *C = NULL; C = (int *) malloc(columns * sizeof(int)); if(C == NULL) { /* Terminate program if there is not enough memory */ fprintf(stderr, "out of memory \n"); exit(0); } /* Declaration of the main array */ int *Beta_worker1 = NULL; /* Dynamic memory allocation */ Beta_worker1 = (int *) malloc( total_size * sizeof(int) ); /* Abort if there is not enough memory */ if(Beta_worker1 == NULL){ fprintf(stderr, "out of memory\n"); exit(-1); } /* The array that will hold the results */ int *worker1_results = NULL; worker1_results = (int *) malloc( amount_of_work * sizeof(int) ); /* Fill with zeros the result array */ fill_with_zeros(worker1_results, amount_of_work); /* The size of the arrays that master waits from the workers */ size_t array_C = columns; size_t array_Beta = total_size; /* worker1 receives the arrays in order to do the computation */ recv_int_array(master, C, &array_C); recv_int_array(master, Beta_worker1, &array_Beta); /* Run for 1000 rounds */ while(rounds++ < 1000){ /* Main computation from master */ for(i = 0; i < amount_of_work; i++) for(j = 0; j < columns; j++) worker1_results[i] += Beta_worker1[i * amount_of_work + j] * C[j]; }//End of while /* worker1 sends the results to the master */ send_int_array(master, worker1_results, amount_of_work); /* End Session */ end_session(s); /* Deallocate memmory */ free(C); C = NULL; free(Beta_worker1); Beta_worker1 = NULL; free(worker1_results); worker1_results = NULL; return EXIT_SUCCESS; }
void setup() { config_wireless(); CC2500_Read(&status_byte, CC2500_STX, 1); // signal fill_with_zeros(buffer, 64); }
int main(int argc ,char **argv){ /* Declare start and end of computation time */ struct timeval start, end; /* Variables declaration */ int i; int j; int rows_of_proc; /* Number of rounds that the parallel part will be computed */ int rounds = 0; /* Variable that shows the non zero elemets of the array */ int non_zero_elements = 0; /* Session start */ //session *s; //join_session(&argc, &argv, &s, "Master.spr"); //role *worker1 = s->get_role(s, "worker1"); //role *worker2 = s->get_role(s, "worker2"); //role *worker3 = s->get_role(s, "worker3"); /* Declaration of array results, which is the vector that will hold the results */ int *results = NULL; /* Declaration of array x, which is the vector that will bw multiplied with the array */ int *x = NULL; //Dynamic memory allocation x = (int *) malloc( ncolumns * sizeof(int) ); if(x == NULL) { fprintf(stderr, "out of memory\n"); exit(-1); } //Fill the vector x printf("Filling and printing vector x \n"); fill_vector(x, ncolumns); /* The array that contains the start of each row within the non-zero elements array*/ int *row_ptr = NULL; /* Dynamic memory allocation of the array row_ptr */ row_ptr = (int *) malloc( (nrows + 1) * sizeof(int) ); /* Check if we have enough memory */ if(row_ptr == NULL) { fprintf(stderr, "out of memory\n"); exit(-1); } //Declaration of array A int **A = NULL; //Dynamic memory allocation of the matrix A = malloc(nrows * sizeof(int *)); /* Check if we have enough memory */ if(A == NULL) { fprintf(stderr, "out of memory\n"); exit(-1); } for(i = 0; i < nrows; i++) { A[i] = malloc(ncolumns * sizeof(int)); /* Check if we have enough memory */ if(A[i] == NULL) { fprintf(stderr, "out of memory\n"); exit(-1); } } /* A[0][0] = 5; A[0][1] = 1; A[0][2] = 0; A[0][3] = 0; A[0][4] = 0; A[0][5] = 0; A[1][0] = 0; A[1][1] = 6; A[1][2] = 0; A[1][3] = 7; A[1][4] = 0; A[1][5] = 8; A[2][0] = 0; A[2][1] = 0; A[2][2] = 1; A[2][3] = 0; A[2][4] = 0; A[2][5] = 0; A[3][0] = 0; A[3][1] = 0; A[3][2] = 2; A[3][3] = 0; A[3][4] = 3; A[3][5] = 2; A[4][0] = 9; A[4][1] = 0; A[4][2] = 0; A[4][3] = 1; A[4][4] = 4; A[4][5] = 0; A[5][0] = 1; A[5][1] = 0; A[5][2] = 2; A[5][3] = 3; A[5][4] = 0; A[5][5] = 1; */ /* Fill tha matrix with values */ fill_matrix(A); /* Start counting the time */ gettimeofday(&start, NULL); /* Computation of non zero elements */ non_zero_elements = num_of_non_zero_elements(A); printf("Num of non zeros is %d \n", non_zero_elements); /* Master sends the non zero elements to the workers */ //send_int(worker1, non_zero_elements); //send_int(worker2, non_zero_elements); //send_int(worker3, non_zero_elements); /* Dynamically allocate memory for the array results */ results = (int *) malloc( nrows * sizeof(int) ); fill_with_zeros(results, nrows); /* Declaration af array values and memory allocation */ int *values = (int *) malloc(non_zero_elements * sizeof(int)); /* Check if we have enough memory */ if(values == NULL) { fprintf(stderr, "out of memory\n"); exit(-1); } /* Fill the values array */ fill_values(A, values); /* Declaration of the array values and dynamic memory allocation */ int *col_ind = (int *) malloc( non_zero_elements * sizeof(int) ); /* Check if we have enough memory */ if(col_ind == NULL) { fprintf(stderr, "out of memory\n"); exit(-1); } /* Fill the col_ind array */ fill_col_ind(A, col_ind); /* Fill the row_ptr array with zero*/ fill_with_zeros(row_ptr, nrows + 1); /* Print row_ptr initialized */ ////////////////print_vector(row_ptr, nrows + 1); /* Fill the row_ptr array */ fill_row_ptr(A, row_ptr); /* The results that workers will send to master */ int *buffer_results[participants] = {NULL}; /* Master sends tha arrays to workers */ //send_int_array(worker1, row_ptr, nrows + 1); //send_int_array(worker1, values, non_zero_elements); //send_int_array(worker1, col_ind, non_zero_elements); //send_int_array(worker1, x, ncolumns); //send_int_array(worker2, row_ptr, nrows + 1); //send_int_array(worker2, values, non_zero_elements); //send_int_array(worker2, col_ind, non_zero_elements); //send_int_array(worker2, x, ncolumns); //send_int_array(worker3, row_ptr, nrows + 1); //send_int_array(worker3, values, non_zero_elements); //send_int_array(worker3, col_ind, non_zero_elements); //send_int_array(worker3, x, ncolumns); /* print_vector(values, non_zero_elements); printf("\n"); print_vector(row_ptr, nrows + 1); printf("\n"); print_vector(col_ind, non_zero_elements); */ //print_vector(values, non_zero_elements); /* Define the work that master will do */ /*int start_work_i[participants]; int end_work_i[participants];*/ int start_work[participants]; int end_work[participants]; int amount_of_work[participants]; for(i = 0; i < participants; i++){ /* The amount of work that the master will do */ start_work[i] = floor((i * nrows)/participants); end_work[i] = floor(((i + 1) * nrows)/participants); amount_of_work[i] = end_work[i] - start_work[i]; printf("start = %d - end = %d - amount of work = %d\n", start_work[i], end_work[i], amount_of_work[i]); /* Dynamic allocation of buffer results */ buffer_results[i] = (int *) malloc(amount_of_work[i] * sizeof(int)); if(buffer_results[i] == NULL){ fprintf(stderr, "Out of memory, aborting program...\n"); } } /* The amount of work that the master will do */ //start_work[master] = floor((master * nrows)/participants); //end_work[master] = floor(((master + 1) * nrows)/participants); //printf("start = %d - end = %d\n", start_work[0], end_work[0]); /* Run for 40 rounds */ while(rounds++ < 40){ /* Main computation of the result. Each processor computes the work that is assigned to it*/ for(i = start_work[master]; i < end_work[master]; i++){ for(j = row_ptr[i]; j < row_ptr[i + 1]; j++) buffer_results[0][i] += values[j] * x[col_ind[j]]; //results[i] += values[j] * x[col_ind[j]]; } } /* Master node receives the results */ //receive_int_array(worker1, buffer_results[1], amount_of_work[1]); //receive_int_array(worker2, buffer_results[2], amount_of_work[2]); //receive_int_array(worker3, buffer_results[3], amount_of_work[3]); /* End counting of time here */ gettimeofday(&end, NULL); /* Computation of time */ long time_elapsed = ((end.tv_sec * 1000000 + end.tv_usec) - (start.tv_sec * 1000000 + start.tv_usec)) / 1000000; /* Print the time that has elapsed */ printf("Elapsed time is: %ld seconds\n", time_elapsed); /* int counter = 0; while(counter++ < 1000){ for(i = 0; i < nrows; i++){ //printf("rank = %d - i = %d\n", rank, i); //printf("RANK = %d\n", rank); for(j = row_ptr[i]; j < row_ptr[i + 1]; j++) results[i] += values[j] * x[col_ind[j]]; //results[i - start] += values[j] * x[col_ind[j]]; } }*/ /* Define the sub-buffers that we will send to the participants */ /*int *buffer_values[participants] = {NULL}; int *buffer_col_ind[participants] = {NULL}; int *buffer_row_ptr[participants] = {NULL};*/ /* Compute which part of the array each participant will compute */ //for(i = 0; i < participants; i++){ /*start_work_i[i] = floor((i * nrows)/participants); end_work_i[i] = floor(((i + 1) * nrows)/participants); start_work[i] = floor((i * non_zero_elements)/participants); end_work[i] = floor(((i + 1) * non_zero_elements)/participants); amount_of_work[i] = floor(((i + 1) * non_zero_elements)/participants) - floor(( i * non_zero_elements)/participants); //amount_of_work[i] = end_work[i] - start_work[i]; printf("start = %d - end = %d - amount of work = %d\n", start_work[i], end_work[i], amount_of_work[i]); */ /* Dynamically buffer allocation */ /*buffer_values[i] = (int *) malloc( (amount_of_work[i]) * sizeof(int)); buffer_col_ind[i] = (int *) malloc( (amount_of_work[i]) * sizeof(int)); */ //buffer_values[i] = (int *) malloc( (non_zero_elements) * sizeof(int)); //buffer_col_ind[i] = (int *) malloc( (non_zero_elements) * sizeof(int)); /* Check if memory is enough */ /*if(buffer_values[i] == NULL){ fprintf(stderr, "Out of memory.Aborting the program...\n"); exit(0); }*/ /* Check if memory is enough */ /*if(buffer_col_ind[i] == NULL){ fprintf(stderr, "Out of memory.Aborting the program...\n"); exit(0); }*/ //} ////////////////////////print_array(A); ////////////////////////print_vector(row_ptr, nrows + 1); //printf("row_ptr[%d] = %d\n", start_work[0], row_ptr[start_work[0]]); //printf("row_ptr[%d] = %d\n", end_work[0], row_ptr[end_work[0]]); //print_vector(buffer_values[0], amount_of_work[0]); //printf("\n\n"); /* Compute the buffer for each participant (amount of work) */ /*for(i = 0; i < participants; i++){ memcpy( buffer_values[i], values + start_work[i], amount_of_work[i] * sizeof(int) ); memcpy( buffer_col_ind[i], col_ind + start_work[i], amount_of_work[i] * sizeof(int)); //printf("buffer[%d] = %s\n", i, buffer[i]); }*/ //print_vector(buffer_values[0], amount_of_work[0]); //print_vector(buffer_col_ind[0], amount_of_work[0]); //print_vector(col_ind, non_zero_elements); //print_vector(values, non_zero_elements); ////////print_vector(col_ind, non_zero_elements); /* Main computation of the result. Master computes the work that is assigned to it*/ /*for(i = start_work[0]; i < end_work[0]; i++){ for(j = row_ptr[i]; j < row_ptr[i + 1]; j++) results[i] += values[j] * x[col_ind[j]]; //results[i - start] += values[j] * x[col_ind[j]]; }*/ /* for(i = start_work_i[1]; i < end_work_i[1]; i++){ for(j = row_ptr[i]; j < row_ptr[i + 1]; j++){ printf("j = %d\n", j); results[i] += buffer_values[1][j] * x[buffer_col_ind[1][j]]; } } */ //printf("buffer_values[%d][%d] = %d\n", 1, 12, buffer_values[1][12]); /* Main computation of the result. Each processor computes the work that is assigned to it*/ /*for(i = start; i < end; i++){ //printf("rank = %d - i = %d\n", rank, i); //printf("RANK = %d\n", rank); for(j = row_ptr[i]; j < row_ptr[i + 1]; j++) y[i] += values[j] * x[col_ind[j]]; //results[i - start] += values[j] * x[col_ind[j]]; }*/ /* The arrays that we will send to the workers */ //int *buffer_col_ind = NULL; //int *buffer_values = NULL; /* Free memory */ free(x); free(results); free(values); free(col_ind); free(row_ptr); return EXIT_SUCCESS; }