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