RESULT
test_slist_sort ()
{
int i, j, mul;
GSList *list = NULL;
for (i = 0; i < N_ELEMS; ++i)
list = g_slist_prepend (list, GINT_TO_POINTER (i));
list = g_slist_sort (list, intcompare);
if (!verify_sort (list, N_ELEMS))
return FAILED ("decreasing list");
g_slist_free (list);
list = NULL;
for (i = 0; i < N_ELEMS; ++i)
list = g_slist_prepend (list, GINT_TO_POINTER (-i));
list = g_slist_sort (list, intcompare);
if (!verify_sort (list, N_ELEMS))
return FAILED ("increasing list");
g_slist_free (list);
list = g_slist_prepend (NULL, GINT_TO_POINTER (0));
for (i = 1; i < N_ELEMS; ++i) {
list = g_slist_prepend (list, GINT_TO_POINTER (-i));
list = g_slist_prepend (list, GINT_TO_POINTER (i));
}
list = g_slist_sort (list, intcompare);
if (!verify_sort (list, 2*N_ELEMS-1))
return FAILED ("alternating list");
g_slist_free (list);
list = NULL;
mul = 1;
for (i = 1; i < N_ELEMS; ++i) {
mul = -mul;
for (j = 0; j < i; ++j)
list = g_slist_prepend (list, GINT_TO_POINTER (mul * j));
}
list = g_slist_sort (list, intcompare);
if (!verify_sort (list, (N_ELEMS*N_ELEMS - N_ELEMS)/2))
return FAILED ("wavering list");
g_slist_free (list);
return OK;
}
EvecCache* init_EvecCache(int na, int nb, int nc, int num_bands, int G_order[3], int G_neg[3], UEInputFn UEfn) {
int num_ks = (na+1)*(nb+1)*(nc+1);
int i, j, k;
EvecCache *evCache = (EvecCache*)malloc(sizeof(EvecCache));
evCache->na = na;
evCache->nb = nb;
evCache->nc = nc;
evCache->num_bands = num_bands;
for (i = 0; i < 3; i++) {
evCache->G_order[i] = G_order[i];
evCache->G_neg[i] = G_neg[i];
}
evCache->UEfn = UEfn;
// Initialize and calculate the value of the band energies and
// eigenvectors at each k-point.
gsl_vector **energies = (gsl_vector**)malloc(num_ks * sizeof(gsl_vector*));
evCache->energies = energies;
gsl_matrix_complex **evecs = (gsl_matrix_complex**)malloc(num_ks * sizeof(gsl_matrix_complex*));
evCache->evecs = evecs;
for (k = 0; k < nc+1; k++) {
for (j = 0; j < nb+1; j++) {
for (i = 0; i < na+1; i++) {
int kN = submesh_ijk_index(na, nb, nc, i, j, k);
evCache->energies[kN] = gsl_vector_calloc(num_bands);
evCache->evecs[kN] = gsl_matrix_complex_calloc(num_bands, num_bands);
double k_opt[3] = {0, 0, 0};
double k_orig[3] = {0, 0, 0};
submesh_ijk_to_k(na, nb, nc, i, j, k, k_opt);
get_k_orig(k_opt, G_order, G_neg, k_orig);
UEfn(k_orig, evCache->energies[kN], evCache->evecs[kN]);
verify_sort(evCache->energies[kN]);
}
}
}
return evCache;
}
/* main - generate a list of random numbers
* and sort it a bunch of times. Display timings
* for each algorithm. */
int main(int argc, char ** argv)
{
int * numbers;
int len, i;
char * algo = NULL;
if(argc == 3)
{
algo = argv[2];
printf("Limiting algorithm to %s\n", algo);
}
srand(time(NULL));
if(argc >= 2)
len = atoi(argv[1]);
else
{
/* if unspecified, choose how long the list should be randomly.
* cap it at 100K elements for runtime's sake */
len = rand() % 100000;
}
printf("Generating array of %d random int's\n", len);
numbers = malloc(sizeof(int) * len);
if(!numbers)
return 1;
for(i = 0; i < len; i++)
numbers[i] = rand();
if(algo == NULL || strcmp(algo, "bubble") == 0)
{
/* sort ASC, verify the list is sorted ascending */
do_int_sort(numbers, len, "bubblesort",
&bubblesort, int_compare_asc);
verify_sort(numbers, len, 1);
/* sort DESC, verify the list is sorted descending */
do_int_sort(numbers, len, "bubblesort",
&bubblesort, int_compare_desc);
verify_sort(numbers, len, 0);
}
if(algo == NULL || strcmp(algo, "merge") == 0)
{
/* sort ASC, verify the list is sorted ascending */
do_int_sort(numbers, len, "mergesort",
&mergesort, int_compare_asc);
verify_sort(numbers, len, 1);
/* sort DESC, verify the list is sorted descending */
do_int_sort(numbers, len, "mergesort",
&mergesort, int_compare_desc);
verify_sort(numbers, len, 0);
}
if(algo == NULL || strcmp(algo, "mone") == 0)
{
/* sort ASC, verify the list is sorted ascending */
do_int_sort(numbers, len, "mergesort_onemalloc",
&mergesort_onemalloc, int_compare_asc);
verify_sort(numbers, len, 1);
/* sort DESC, verify the list is sorted descending */
do_int_sort(numbers, len, "mergesort_onemalloc",
&mergesort_onemalloc, int_compare_desc);
verify_sort(numbers, len, 0);
}
if(algo == NULL || strcmp(algo, "quick") == 0)
{
/* sort ASC, verify the list is sorted ascending */
do_int_sort(numbers, len, "quicksort",
&quicksort, int_compare_asc);
verify_sort(numbers, len, 1);
/* verify the list is sorted descending */
do_int_sort(numbers, len, "quicksort",
&quicksort, int_compare_desc);
verify_sort(numbers, len, 0);
}
if(algo == NULL || strcmp(algo, "qone") == 0)
{
/* sort ASC, verify the list is sorted ascending */
do_int_sort(numbers, len, "quicksort_onemalloc",
&quicksort_onemalloc, int_compare_asc);
verify_sort(numbers, len, 1);
/* verify the list is sorted descending */
do_int_sort(numbers, len, "quicksort_onemalloc",
&quicksort_onemalloc, int_compare_desc);
verify_sort(numbers, len, 0);
}
free(numbers);
return 0;
}
