int main()
{
/* sort 1..19, 30..20, 30..100 */
#define LEN 18
int arr[LEN] = {1, 5, 28, 4, 3, 2, 10, 20, 18, 25, 21, 29, 34, 35, 14, 100, 27, 19};
int ans[LEN] = {1, 2, 3, 4, 5, 10, 14, 18, 19, 29, 28, 27, 25, 21, 20, 34, 35, 100};
int tmp[LEN];
/* Region to invert: 20-30 (inclusive) */
int interval[2] = {20, 30};
int i, res = 1;
const int tlen = 100000;
int *tarray = NULL;
printf("Test 1:\n");
printf("sort_r\n");
memcpy(tmp, arr, LEN*sizeof(int));
print_list(tmp, LEN);
sort_r(tmp, LEN, sizeof(int), sort_r_cmp, interval);
print_list(tmp, LEN);
res &= check_list(tmp, ans, LEN);
printf("sort_r_simple\n");
memcpy(tmp, arr, LEN*sizeof(int));
print_list(tmp, LEN);
sort_r_simple(tmp, LEN, sizeof(int), sort_r_cmp, interval);
print_list(tmp, LEN);
res &= check_list(tmp, ans, LEN);
printf("Test 2:\n");
tarray = malloc(tlen * sizeof(int));
for(i = 0; i < tlen; i++) tarray[i] = i;
/* sort integers */
sort_r(tarray, tlen, sizeof(tarray[0]), cmp_int, NULL);
for(i = 0; i < tlen && tarray[i] == i; i++) {}
res &= (i == tlen);
sort_r_simple(tarray, tlen, sizeof(tarray[0]), cmp_int, NULL);
for(i = 0; i < tlen && tarray[i] == i; i++) {}
res &= (i == tlen);
/* reverse sort integers */
sort_r(tarray, tlen, sizeof(tarray[0]), cmpr_int, NULL);
for(i = 0; i < tlen && tarray[i] == tlen-i-1; i++) {}
res &= (i == tlen);
sort_r_simple(tarray, tlen, sizeof(tarray[0]), cmpr_int, NULL);
for(i = 0; i < tlen && tarray[i] == tlen-i-1; i++) {}
res &= (i == tlen);
free(tarray);
printf("return: %s\n", res ? "PASS" : "FAIL");
return res ? EXIT_SUCCESS : EXIT_FAILURE;
}
void smith_waterman_align2(const char *a, const char *b,
size_t len_a, size_t len_b,
const scoring_t *scoring, sw_aligner_t *sw)
{
aligner_t *aligner = &sw->aligner;
sw_history_t *hist = &sw->history;
aligner_align(aligner, a, b, len_a, len_b, scoring, 1);
size_t arr_size = aligner->score_width * aligner->score_height;
_ensure_history_capacity(hist, arr_size);
// Set number of hits
memset(hist->match_scores_mask.b, 0, (hist->match_scores_mask.l+31)/32);
hist->num_of_hits = hist->next_hit = 0;
size_t pos;
for(pos = 0; pos < arr_size; pos++) {
if(aligner->match_scores[pos] > 0)
hist->sorted_match_indices[hist->num_of_hits++] = pos;
}
// Now sort matched hits
MatrixSort tmp_struct = {aligner->match_scores, aligner->score_width};
sort_r(hist->sorted_match_indices, hist->num_of_hits,
sizeof(size_t), sort_match_indices, &tmp_struct);
}
static int
dict_order(Word dict, int ex ARG_LD)
{ Functor data = (Functor)dict;
int arity = arityFunctor(data->definition);
assert(arity%2 == 1);
sort_r(data->arguments+1, arity/2, sizeof(word)*2,
compare_dict_entry, LD);
return dict_ordered(data->arguments+1, arity/2, ex PASS_LD) == TRUE;
}
t_l *sort(t_l *list, char *flag, char *path)
{
t_l *base;
base = list;
sor(list);
if (isflag(flag, 't'))
list = sort_t(list, flag, base, path);
else if (isflag(flag, 'r'))
list = sort_r(list, base);
return (list);
}
t_l *sort_r(t_l *list, t_l *base)
{
t_l *tmp;
char *mtp;
tmp = list;
list = list->next;
while (list)
{
ft_putstr(list->str);
if (ft_strcmp(list->str, tmp->str) > 0)
{
mtp = tmp->str;
tmp->str = list->str;
list->str = mtp;
return (sort_r(base, base));
}
tmp = list;
list = list->next;
}
return (base);
}
int
dict_order_term_refs(term_t *av, int *indexes, int count ARG_LD)
{ order_term_refs ctx;
ctx.ld = LD;
ctx.av = av;
sort_r(indexes, count, sizeof(int), compare_term_refs, &ctx);
if ( count > 1 )
{ word k = *valTermRef(av[indexes[0]*2]);
int i;
for(i=1; i<count; i++)
{ word k2 = *valTermRef(av[indexes[i]*2]);
if ( k == k2 )
return i;
k = k2;
}
}
return 0;
}
int
permute_trans (permute_t *perm, state_info_t *state, perm_cb_f cb, void *ctx)
{
perm->call_ctx = ctx;
perm->real_cb = cb;
perm->state = state;
perm->nstored = perm->start_group_index = 0;
int count = 0;
state_data_t data = state_info_pins_state (state);
if (inhibit) {
int N = dm_nrows (perm->inhibit_matrix);
int class_count[N];
for (int i = 0; i < N; i++) {
class_count[i] = 0;
if (is_inhibited(perm, class_count, i)) continue;
if (perm->class_label >= 0) {
class_count[i] = GBgetTransitionsMatching (perm->model, perm->class_label, i, data, permute_one, perm);
} else if (perm->class_matrix != NULL) {
class_count[i] = GBgetTransitionsMarked (perm->model, perm->class_matrix, i, data, permute_one, perm);
} else {
Abort ("inhibit set, but no known classification found.");
}
count += class_count[i];
}
} else {
count = GBgetTransitionsAll (perm->model, data, permute_one, perm);
}
switch (perm->permutation) {
case Perm_Otf:
randperm (perm->pad, perm->nstored, state->ref + perm->shiftorder);
for (size_t i = 0; i < perm->nstored; i++)
perm_do (perm, perm->pad[i]);
break;
case Perm_Random:
for (size_t i = 0; i < perm->nstored; i++)
perm_do (perm, perm->rand[perm->nstored][i]);
break;
case Perm_Dynamic:
sort_r (perm->tosort, perm->nstored, sizeof(int), dyn_cmp, perm);
perm_do_all (perm);
break;
case Perm_RR:
sort_r (perm->tosort, perm->nstored, sizeof(int), rr_cmp, perm);
perm_do_all (perm);
break;
case Perm_SR:
sort_r (perm->tosort, perm->nstored, sizeof(int), rand_cmp, perm);
perm_do_all (perm);
break;
case Perm_Sort:
sort_r (perm->tosort, perm->nstored, sizeof(int), sort_cmp, perm);
perm_do_all (perm);
break;
case Perm_Shift:
perm_do_all (perm);
break;
case Perm_Shift_All:
for (size_t i = 0; i < perm->nstored; i++) {
size_t j = (perm->start_group_index + i);
j = j < perm->nstored ? j : 0;
perm_do (perm, j);
}
break;
case Perm_None:
break;
default:
Abort ("Unknown permutation!");
}
return count;
}
