static void t_clib_for_each() { struct clib_array *pArray; struct clib_deque *pDeq; struct clib_set *pSet; struct clib_map *pMap; struct clib_slist *pSlist; struct clib_iterator *pArrayIterator; struct clib_iterator *pDequeIterator; struct clib_iterator *pSetIterator; struct clib_iterator *pMapIterator; struct clib_iterator *pSlistIterator; printf ( "Performing for_each for array\n"); pArray = create_c_array(); pArrayIterator = new_iterator_c_array ( pArray ); clib_for_each ( pArrayIterator, print_integers ); delete_c_array( pArray ); delete_iterator_c_array ( pArrayIterator ); printf ( "Performing for_each for deque\n"); pDeq = create_deque(); pDequeIterator = new_iterator_c_deque ( pDeq ); clib_for_each ( pDequeIterator, print_integers ); delete_c_deque( pDeq ); delete_iterator_c_deque ( pDequeIterator ); printf ( "Performing for_each for set\n"); pSet = create_set(); pSetIterator = new_iterator_c_set ( pSet ); clib_for_each ( pSetIterator, print_integers ); delete_c_set( pSet ); delete_iterator_c_set ( pSetIterator ); printf ( "Performing for_each for map\n"); pMap = create_map(); pMapIterator = new_iterator_c_map ( pMap ); clib_for_each ( pMapIterator, print_integers ); delete_c_map( pMap ); delete_iterator_c_map ( pMapIterator ); printf ( "Performing for_each for slist\n"); pSlist = create_slist(); pSlistIterator = new_iterator_c_slist ( pSlist ); clib_for_each ( pSlistIterator, print_integers ); delete_c_slist( pSlist ); delete_iterator_c_slist ( pSlistIterator ); }
void* single_iterate(iterator_state* state, void (*callback)(iterator_state* state, void* results), void* result) { wavelet_tree* bwt = &state->bwts[0], *reverse_bwt = &state->reverse_bwts[0]; bit_vector* reverse_runs = &state->reverse_runs_vectors[0]; substring_stack* stack = &state->stacks[0]; unsigned int* c_array = state->c_arrays[0]; interval* normal = &state->normals[0], *reverse = &state->reverses[0]; alphabet_data* alpha_data = &state->alpha_datas[0]; int bwt_length = bwt->get_num_bits(bwt), i; //Initialize first intervals. In the start both intervals are the whole bwt normal->i = 0; normal->j = bwt_length - 1; reverse->i = 0; reverse->j = bwt_length - 1; //create starting substring substring* substr = create_substring(normal, reverse, 0, 0); substring* temp, *new_substring = state->current; //printf("Variables initialized, commencing iteration\n"); while (1) { if (substr == NULL) break; //if size of the interval is 1, it cannot be a right-maximal string //if(substr->normal->i == substring->normal->j) continue; // Determine characters that precede the interval alpha_data = create_alphabet_interval(&substr->normal, bwt, alpha_data); //printf("Created alphabet interval\n"); c_array = create_c_array(bwt, &substr->normal, 0, 0, c_array); //printf("Created C-array\n"); for (i = 0; i < alpha_data->length; i++) { state->current_extension = alpha_data->alphabet[i]; normal = backward_search_interval(bwt, &substr->normal, state->current_extension, normal); //printf("Updated normal interval\n"); reverse = update_reverse_interval(&substr->reverse, normal, alpha_data->alphabet, alpha_data->length, c_array, state->current_extension, reverse); //printf("Updated reverse interval\n"); //printf("Alphabet length: %d\n", alpha_data->length); if (is_reverse_interval_right_maximal(reverse_runs, reverse)) { //printf("Found right maximal\n"); new_substring = create_substring(normal, reverse, substr->length + 1, new_substring); /*printf("New substring:\n"); printf("\tNormal: %d.%d\n", normal->i, normal->j); printf("\tReverse: %d.%d\n", reverse->i, reverse->j); printf("\tLength: %d\n", new_substring->length);*/ // callback function pointers callback(state, result); push(stack, new_substring); //printf("Callbacked and pushed\n"); state->prev = create_substring(&new_substring->normal, &new_substring->reverse, new_substring->length, state->prev); //printf("Updated as prev in state\n"); } } temp = pop(stack); if (temp == NULL) break; substr = create_substring(&temp->normal, &temp->reverse, temp->length, substr); //printf("New substring popped\n"); } free(substr); return result; }
void* double_iterate(iterator_state* state, void (*callback)(iterator_state* state, void* results), void* result) { wavelet_tree* bwt1 = &state->bwts[0], *bwt2 = &state->bwts[1]; wavelet_tree* rev_bwt1 = &state->reverse_bwts[0], *rev_bwt2 = &state->reverse_bwts[1]; bit_vector* rev_runs1 = &state->reverse_runs_vectors[0], *rev_runs2 = &state->reverse_runs_vectors[1]; substring_stack* stack1 = &state->stacks[0], *stack2 = &state->stacks[1]; unsigned int* c_array1 = state->c_arrays[0], *c_array2 = state->c_arrays[1]; interval* normal1 = &state->normals[0], *normal2 = &state->normals[1]; interval* reverse1 = &state->reverses[0], *reverse2 = &state->reverses[1]; alphabet_data* alpha_data1 = &state->alpha_datas[0], *alpha_data2 = &state->alpha_datas[1]; alphabet_data* common_alphabet = state->common_alphabet; int bwt_length1 = bwt1->get_num_bits(bwt1), bwt_length2 = bwt2->get_num_bits(bwt2), i; //Initialize first intervals. In the start both intervals are the whole bwt normal1->i = 0; normal1->j = bwt_length1 - 1; reverse1->i = 0; reverse1->j = bwt_length1 - 1; normal2->i = 0; normal2->j = bwt_length2 - 1; reverse2->i = 0; reverse2->j = bwt_length2 - 1; //create starting substring substring* new_substring1 = &state->current[0], *substring1 = create_substring(normal1, reverse1, 0, 0); substring* new_substring2 = &state->current[1], *substring2 = create_substring(normal2, reverse2, 0, 0); substring* temp; while (1) { //if size of the interval is 1, it cannot be a right-maximal string //if(substring->normal->i == substring->normal->j) continue; // Determine characters that precede the interval alpha_data1 = create_alphabet_interval(&substring1->normal, bwt1, alpha_data1); alpha_data2 = create_alphabet_interval(&substring2->normal, bwt2, alpha_data2); c_array1 = create_c_array(bwt1, &substring1->normal, 0, 0, c_array1); c_array2 = create_c_array(bwt2, &substring2->normal, 0, 0, c_array2); common_alphabet = combine_alphabets_intersection(alpha_data1, alpha_data2, common_alphabet); for (i = 0; i < common_alphabet->length; i++) { state->current_extension = common_alphabet->alphabet[i]; //print_node(substring1->normal); //printf("letter added to the left: %c \n", common_alphabet[i]); normal1 = backward_search_interval(bwt1, &substring1->normal, state->current_extension, normal1); if (normal1 == NULL) continue; //print_node(substring2->normal); normal2 = backward_search_interval(bwt2, &substring2->normal, state->current_extension, normal2); if (normal2 == NULL) continue; reverse1 = update_reverse_interval(&substring1->reverse, normal1, alpha_data1->alphabet, alpha_data1->length, c_array1, state->current_extension, reverse1); reverse2 = update_reverse_interval(&substring2->reverse, normal2, alpha_data2->alphabet, alpha_data2->length, c_array2, state->current_extension, reverse2); new_substring1 = create_substring(normal1, reverse1, substring1->length + 1, new_substring1); new_substring2 = create_substring(normal2, reverse2, substring2->length + 1, new_substring2); // callback function pointers callback(state, result); push(stack1, new_substring1); push(stack2, new_substring2); create_substring(&new_substring1->normal, &new_substring1->reverse, new_substring1->length, &state->prev[0]); create_substring(&new_substring2->normal, &new_substring2->reverse, new_substring2->length, &state->prev[1]); } temp = pop(stack1); if (temp == NULL) break; substring1 = create_substring(&temp->normal, &temp->reverse, temp->length, substring1); temp = pop(stack2); if (temp == NULL) break; substring2 = create_substring(&temp->normal, &temp->reverse, temp->length, substring2); } free(substring1); free(substring2); return result; }
void ui() { int choice, len = 0; char* input = malloc(sizeof(char)*MAX_INPUT_STRING_LENGTH); char* res = malloc(sizeof(char)); int* array = calloc(20, sizeof(int)); print_choices(); printf("Write the number of the operation you want to do:\n"); scanf("%d", &choice); printf("Give the input string: (max size %d) ", MAX_INPUT_STRING_LENGTH); print_instructions(choice); scanf("%s", input); wavelet_tree* root = create_wavelet_tree(input); wavelet_tree* res_root; if (choice == 1) { char** strings = malloc(sizeof(char*)); strings[0] = input; iterator_state* state = initialize_iterator(strings, 1); single_iterate(state, &print_node, 0); free_iterator_state(state); free(strings); } else if (choice == 2) { res_root = s_to_bwt(input); print_wavelet_tree(res_root); } else if (choice == 3) { res = bwt_to_s(root); printf("%s\n", res); } else if (choice == 4) { res_root = reverse_bwt(input); print_wavelet_tree(res_root); } else if (choice == 5) { array = create_c_array(root,0,0,0,0); int len = strlen(determine_alphabet(input)); print_int_array(array, len); } else if (choice == 6) { bit_vector* runs = create_runs_vector(root,0); print_runs_vector(runs, strlen(input)+1); free_bit_vector(runs); } else if (choice == 7) { printf("Give the second input string: "); char* input2 = malloc(sizeof(char)*MAX_INPUT_STRING_LENGTH); scanf("%s", input2); char** strings = malloc(2 * sizeof(char*)); strings[0] = input; strings[1] = input2; parameter_struct* params = initialize_for_mums(strings, 0); iterator_state* state = iterate(params); mum_results* results = (mum_results*) params->ret_data; triplet* nodes = results->data; print_mums(input, results, state); mum_print_bit_vectors(input,input2, results, state); free(strings); free(results->data); free_iterator_state(state); } else if (choice == 8) { printf("Not supported yet\n"); } else if (choice == 9) { printf("%d\n", distinct_substrings(input)); } else if (choice == 10) { parameter_struct* params = initialize_for_max_repeats(input, 0); iterator_state* state = iterate(params); max_repeat_results* results = (max_repeat_results*) params->ret_data; //maximals_print_nodes(input); print_maximal_repeat_substrings(input, results, state); //compare_quick_sort() } else if (choice == 11) { printf("Give the second input string: "); char* input2 = malloc(sizeof(char)*MAX_INPUT_STRING_LENGTH); scanf("%s", input2); char** strings = malloc(2 * sizeof(char*)); strings[0] = input; strings[1] = input2; parameter_struct* params = initialize_for_mems(strings, 0); iterator_state* state = iterate(params); mem_results* results = (mem_results*) params->ret_data; triplet* nodes = results->data; print_mems(input, results, state); free(strings); free(results->data); free_iterator_state(state); }else { printf("Invalid choice\n"); } }