Browse Source

Make bitonic work for non powers of 2 (#24)

tags/1.0.0
Chris Cromer 10 months ago
parent
commit
03c1305f57
2 changed files with 134 additions and 22 deletions
  1. 88
    11
      src/bitonic_sort.c
  2. 46
    11
      test/test.c

+ 88
- 11
src/bitonic_sort.c View File

@@ -15,6 +15,39 @@

#include "swap.h"

/**
* Verificar si x es de 2^n
* @param x El valor a verificar
* @return Retorna 1 si es de 2^n ó 0 al contrario;
*/
int power_of_two(int n) {
if (n == 0) {
return 0;
}

while (n != 1) {
if (n % 2 != 0) {
return 0;
}
n = n / 2;
}
return 1;
}

/**
* Buscar un valor que es de potencia de 2 pero menor que n
* @param n El valor de n
* @return Un potencia de 2 que es menor que n
*/
int greatest_power_of_two_less_than(int n) {
int k = 1;
while (k > 0 && k < n) {
k = (int) ((unsigned int) k << 1);
}
k = (int) ((unsigned int) k >> 1);
return (int) k;
}

/**
* Comparar y intercambiar los valores para darle orden
* @param i El primer indice a comparar
@@ -31,16 +64,16 @@ void compare(int i, int j, int dir, int *array) { //
/**
* Unir la secuencia
* @param low El parte inferior
* @param c El parte superior
* @param c El parte superior n
* @param dir La dirección a ordenar, 1 para ascendentemente o 0 por descendentamente
* @param array El array a ordenar
*/
void bitonicmerge(int low, int c, int dir, int *array) {
void bitonicmerge(int low, int n, int dir, int *array) {
int i;
int k;

if (c > 1){
k = c / 2;
if (n > 1) {
k = n / 2;
for (i = low; i < low + k; i++){
compare(i, i + k, dir, array);
}
@@ -49,21 +82,60 @@ void bitonicmerge(int low, int c, int dir, int *array) {
}
}

/**
* Unir la secuencia cuando n no es de potencia 2
* @param low El parte inferior
* @param c El parte superior n
* @param dir La dirección a ordenar, 1 para ascendentemente o 0 por descendentamente
* @param array El array a ordenar
*/
void bitonicmerge_no2(int low, int n, int dir, int *array) {
int i;
int k;

if (n > 1) {
k = greatest_power_of_two_less_than(n);
for (i = low; i < low + n-k; i++){
compare(i, i + k, dir, array);
}
bitonicmerge_no2(low, k, dir, array);
bitonicmerge_no2(low + k, n - k, dir, array);
}
}

/**
* Generar la secuencia bitonica en forma de piramide
* @param low El parte inferior
* @param c El parte superior
* @param c El parte superior n
* @param dir La dirección a ordenar, 1 para ascendentemente o 0 por descendentamente
* @param array El array a ordenar
*/
void recbitonic(int low, int c, int dir, int *array) {
void recbitonic(int low, int n, int dir, int *array) {
int k;

if (c > 1){
k = c / 2;
if (n > 1){
k = n / 2;
recbitonic(low, k, 1, array);
recbitonic(low + k, k, 0, array);
bitonicmerge(low, c, dir, array);
bitonicmerge(low, n, dir, array);
}
}

/**
* Generar la secuencia bitonica en forma de piramide cuando n no es de potencia 2
* @param low El parte inferior
* @param c El parte superior n
* @param dir La dirección a ordenar, 1 para ascendentemente o 0 por descendentamente
* @param array El array a ordenar
*/
void recbitonic_no2(int low, int n, int dir, int *array) {
int k;

if (n > 1){
k = n / 2;
recbitonic_no2(low, k, !dir, array);
recbitonic_no2(low + k, n - k, dir, array);
bitonicmerge_no2(low, n, dir, array);
}
}

@@ -74,7 +146,12 @@ void recbitonic(int low, int c, int dir, int *array) {
* @param dir La dirección a ordenar, 1 para ascendentemente o 0 por descendentamente
*/
void sort(int *array, int n, int dir) {
recbitonic(0, n, dir, array);
if (power_of_two(n)) {
recbitonic(0, n, dir, array);
}
else {
recbitonic_no2(0, n, dir, array);
}
}

/**
@@ -83,5 +160,5 @@ void sort(int *array, int n, int dir) {
* @param n El tamaño del array
*/
void bitonic_sort(int *array, int n) {
sort(array, n, 1);
sort(array, n, 1);
}

+ 46
- 11
test/test.c View File

@@ -52,7 +52,8 @@ void cleanup() {
* El programa de test
*/
int main(int argc, char **argv) {
int n = 32768;
int n = 50000;
int n2 = 32768;
int i;
int gen;
int pass;
@@ -99,7 +100,7 @@ int main(int argc, char **argv) {

// Prepare for sort tests
for (i = 0; i < n; i++) {
test_case[i] = gen_rand(-100, 100);
test_case[i] = gen_rand(-1000000, 1000000);
}
memcpy(qarray, test_case, sizeof(int) * n);
qsort(qarray, n, sizeof(int), compar);
@@ -161,12 +162,12 @@ int main(int argc, char **argv) {
passed++;
}

// Test bitonic sort
// Test selection sort
pass = 1;
memcpy(test_array, test_case, sizeof(int) * n);
fprintf(stdout, "\tbitonic sort: ");
fprintf(stdout, "\tselection sort: ");
fflush(stdout);
bitonic_sort(test_array, n);
selection_sort(test_array, n);
for (i = 0; i < n; i++) {
if (test_array[i] != qarray[i]) {
fprintf(stdout, "fail\n");
@@ -180,12 +181,12 @@ int main(int argc, char **argv) {
passed++;
}

// Test selection sort
// Test merge sort
pass = 1;
memcpy(test_array, test_case, sizeof(int) * n);
fprintf(stdout, "\tselection sort: ");
fprintf(stdout, "\tmerge sort: ");
fflush(stdout);
selection_sort(test_array, n);
merge_sort(test_array, n);
for (i = 0; i < n; i++) {
if (test_array[i] != qarray[i]) {
fprintf(stdout, "fail\n");
@@ -199,12 +200,12 @@ int main(int argc, char **argv) {
passed++;
}

// Test merge sort
// Test bitonic sort without 2^n
pass = 1;
memcpy(test_array, test_case, sizeof(int) * n);
fprintf(stdout, "\tmerge sort: ");
fprintf(stdout, "\tbitonic sort: ");
fflush(stdout);
merge_sort(test_array, n);
bitonic_sort(test_array, n);
for (i = 0; i < n; i++) {
if (test_array[i] != qarray[i]) {
fprintf(stdout, "fail\n");
@@ -218,6 +219,40 @@ int main(int argc, char **argv) {
passed++;
}

// Test bitonic sort with 2^n
pass = 1;
int *bitonic_test_case = malloc(sizeof(int) * n2);
if (bitonic_test_case == NULL) {
fprintf(stderr, "Error: Out of heap space!\n");
exit(1);
}
int *bitonic_test_array = malloc(sizeof(int) * n2);
if (bitonic_test_array == NULL) {
fprintf(stderr, "Error: Out of heap space!\n");
exit(1);
}
for (i = 0; i < n; i++) {
bitonic_test_case[i] = gen_rand(-1000000, 1000000);
}
memcpy(qarray, bitonic_test_case, sizeof(int) * n2);
qsort(qarray, n2, sizeof(int), compar);
memcpy(bitonic_test_array, bitonic_test_case, sizeof(int) * n2);
fprintf(stdout, "\tbitonic sort 2^n: ");
fflush(stdout);
bitonic_sort(bitonic_test_array, n2);
for (i = 0; i < n2; i++) {
if (bitonic_test_array[i] != qarray[i]) {
fprintf(stdout, "fail\n");
failed++;
pass = 0;
break;
}
}
if (pass) {
fprintf(stdout, "pass\n");
passed++;
}

fprintf(stdout, "%d tests passed\n", passed);
fprintf(stdout, "%d tests failed\n", failed);


Loading…
Cancel
Save