// Quick sort routine to sort the words according to their selectivities.
static void quick_sort (double *selectivity, var_array *words, int left, int right)
{
int last, current;
if (left >= right)
{
return;
}
// Pick the pivot and isolate it at the leftmost position.
swap_elements (selectivity, words, left, (left+right)/2);
// Partitioning of arrays.
// last keeps track of the last position where an element smaller to the pivot was placed.
last = left;
for (current = left + 1; current <= right; current++)
{
if (selectivity[current] < selectivity[left])
{
swap_elements (selectivity, words, ++last, current);
}
}
// Place the pivot at its place.
swap_elements (selectivity, words, left, last);
// Recursively sort left and right partitions.
quick_sort(selectivity, words, left, last-1);
quick_sort(selectivity, words, last+1, right);
}
void decrease_key(position pos,element_type delta,PRIORITY_QUEUE H)
{
if(pos>H->size)
return;
position prev;
*H->elements[pos]+=delta;
for(prev=get_father(pos); prev>=1&&((*H->elements[prev])>(*H->elements[pos])); pos=prev,prev=get_father(prev)) {
swap_elements(prev,pos,H);
}
if(((*H->elements[prev])=(*H->elements[pos]))&&((*H->elements[prev])>(*H->elements[pos+1]))) {
swap_elements(prev,pos+1,H);
}
}
void increase_key(position pos,element_type delta,PRIORITY_QUEUE H)
{
if(pos>H->size)
return;
position child;
*H->elements[pos]-=delta;
for(chid=pos*2; child<H->size&&((*H->elements[child])<(*H->elements[pos])); pos=child,child=child*2) {
swap_elements(pos,child,H);
if((*H->elements[pos])>(*H->elements[child+1]))
swap_elements(pos,child+1,H);
}
if(((*H->elements[pos])=(*H->elements[child]))&&((*H->elements[pos])>(*H->elements[child+1]))) {
swap_elements(pos,child+1,H);
}
}
void ternary_hsort_r(void *base,
size_t nmemb,
size_t size,
compare_fun3 compare,
void *arg) {
if (nmemb <= 1) {
/* nothing to sort!! */
return;
}
ternary_heapify(base, nmemb, size, compare, arg);
size_t end = nmemb - 1;
for (end = nmemb - 1; end > 0; end--) {
void *end_ptr = POINTER(base, end, size);
swap_elements(base, end_ptr, size);
ternary_sift_down(base, 0, size, end-1, compare, arg);
}
}
void ternary_sift_down(void *base,
size_t start,
size_t size,
size_t max_index,
compare_fun3 compare,
void *arg) {
size_t root = start;
while (TRUE) {
size_t left_child = LEFT(root);
if (left_child > max_index) {
break;
}
void *root_ptr = POINTER(base, root, size);
size_t swap = root;
void *swap_ptr = root_ptr;
void *left_child_ptr = POINTER(base, left_child, size);
if (compare(swap_ptr, left_child_ptr, arg) < 0) {
swap = left_child;
swap_ptr = left_child_ptr;
}
size_t middle_child = MIDDLE(root);
size_t right_child = RIGHT(root);
if (middle_child <= max_index) {
void *middle_child_ptr = POINTER(base, middle_child, size);
if (compare(swap_ptr, middle_child_ptr, arg) < 0) {
swap = middle_child;
swap_ptr = middle_child_ptr;
}
if (right_child <= max_index) {
void *right_child_ptr = POINTER(base, right_child, size);
if (compare(swap_ptr, right_child_ptr, arg) < 0) {
swap = right_child;
swap_ptr = right_child_ptr;
}
}
}
if (swap != root) {
swap_elements(root_ptr, swap_ptr, size);
root = swap;
root_ptr = swap_ptr;
} else {
return;
}
}
}
static void sort_symbols(symbol_table_t* table) {
int no_swap = 1;
int i;
do
{
no_swap = 1;
for(i = 0; i<table->count-1; i++)
{
if(table->symbols[i].addr > table->symbols[i+1].addr)
{
swap_elements(table, i, i+1);
no_swap = 0;
}
}
}while(!no_swap);
}
void fsort_f(void *base,
size_t nmemb,
size_t size,
double factor,
compare_fun3 compare,
void *argc,
metric_fun2 metric,
void *argm) {
if (nmemb <= 1) {
/* nothing to sort */
return;
}
/* preparation: form classes */
/* use calculate_k for a purpose it has not been made for, but since it is identical with what is needed here it is correct */
size_t lsize = calculate_k(nmemb, factor, nmemb) + 1;
if (lsize < 2) {
lsize = 2;
}
size_t *l = (size_t *) malloc(lsize * sizeof(size_t));
handle_ptr_error(l, "malloc for l", PROCESS_EXIT);
for (size_t k = 0; k < lsize; k++) {
l[k] = 0;
}
//size_t idx_min = 0;
void *amin = POINTER(base, 0, size);
size_t idx_max = 0;
void *amax = POINTER(base, idx_max, size);
for (size_t i = 0; i < nmemb; i++) {
if (compare(POINTER(base, i, size), amin, argc) < 0) {
// idx_min = i;
amin = POINTER(base, i, size);
}
if (compare(POINTER(base, i, size), amax, argc) > 0) {
idx_max = i;
amax = POINTER(base, i, size);
}
}
if (compare(amin, amax, argc) == 0) {
/* min and max are the same --> already sorted */
free(l);
return;
}
double amin_metric = metric(amin, argm);
double amax_metric = metric(amax, argm);
double step = (lsize - 1)/(amax_metric - amin_metric);
/* size_t k_min = calculate_k(step, 0, lsize); */
/* size_t k_max = calculate_k(step, amax_metric - amin_metric, lsize); */
/* count the elements in each of the lsize classes */
for (size_t i = 0; i < nmemb; i++) {
double ai_metric = metric(POINTER(base, i, size), argm);
size_t k = calculate_k(step, ai_metric - amin_metric, lsize);
l[k]++;
}
/* find the start positions for each of the classes */
size_t *ll = (size_t *) malloc((lsize + 1) * sizeof(size_t));
handle_ptr_error(ll, "malloc for ll", PROCESS_EXIT);
ll[0] = 0;
ll[1] = l[0];
for (size_t k = 1; k < lsize; k++) {
l[k] += l[k-1];
ll[k+1] = l[k];
}
swap_elements(POINTER(base, 0, size), POINTER(base, idx_max, size), size);
// printf("prepared\n");
/* do the permutation */
size_t nmove = 0;
size_t j = 0;
size_t k = lsize - 1;
while (nmove < nmemb - 1) {
while (j >= l[k]) {
j++;
k = calculate_k(step, metric(POINTER(base, j, size), argm) - amin_metric, lsize);
}
/* now: j < l[k] */
void *flash_ptr = alloca(size);
handle_ptr_error(flash_ptr, "alloca for flash_ptr", PROCESS_EXIT);
/* flash_ptr takes element a[j] such that j > l[k] */
memcpy(flash_ptr, POINTER(base, j, size), size);
while (j != l[k]) {
k = calculate_k(step, metric(flash_ptr, argm) - amin_metric, lsize);
void *alkm_ptr = POINTER(base, l[k]-1, size);
swap_elements(flash_ptr, alkm_ptr, size);
l[k]--;
nmove++;
}
}
/* use qsort or hsort for each class */
for (k = 0; k < lsize; k++) {
size_t n = ll[k+1] - ll[k];
if (n > 1 && ll[k+1] < ll[k] || n > nmemb) {
char txt[4096];
sprintf(txt, "wrong order: k=%ld lsize=%ld nmemb=%ld n=%ld ll[k]=%ld ll[k+1]=%ld\n", k, lsize, nmemb, n, ll[k], ll[k+1]);
handle_error_myerrno(-1, EDOM, txt, PROCESS_EXIT);
}
if (n > 7) {
void *basek = POINTER(base, ll[k], size);
hsort_r(basek, n, size, compare, argc);
} else if (n > 1) {
void *basek = POINTER(base, ll[k], size);
isort_r(basek, n, size, compare, argc);
}
}
free(l);
l = NULL;
free(ll);
ll = NULL;
return;
}
