Finish basic functionality

Author: danielsource

GNUmakefile

@@ -9,7 +9,7 @@ objs := $(srcs:%=out/%.o)
 .PHONY: all
 all: test
 
-test: $(objs) GNUmakefile
+test: $(objs)
 	$(CC) $(objs) -o $@ $(LDFLAGS)
 
 out/%.c.o: %.c test.h config.h

config.h

@@ -1,3 +1,27 @@
+static int *init_asc(int len) {
+	int *a = malloc(len * sizeof(int));
+	for (int i = 0; i < len; ++i)
+		a[i] = i;
+	return a;
+}
+
+static int *init_des(int len) {
+	int *a = malloc(len * sizeof(int));
+	for (int i = 0; i < len; ++i)
+		a[i] = len-i-1;
+	return a;
+}
+
+#if RAND_MAX <= 32767
+#warning "RAND_MAX is less than or equal to 32767."
+#endif
+static int *init_ran(int len) {
+	int *a = malloc(len * sizeof(int)), c = RAND_MAX/len + 1;
+	for (int i = 0; i < len; ++i)
+		a[i] = rand() / c;
+	return a;
+}
+
 Metric sort_bubble(Sequence seq);
 Metric sort_insert(Sequence seq);
 Metric sort_quick(Sequence seq);
@@ -7,15 +31,15 @@ Metric sort_heap(Sequence seq);
 int repeattest = 3;	      /* repeat x times and get the average */
 
 Sequence seqs[] = {
-	{"ascending", init_asc, 100},
-	{"ascending", init_asc, 1000},
-	{"ascending", init_asc, 10000},
-	{"descending", init_des, 100},
-	{"descending", init_des, 1000},
-	{"descending", init_des, 10000},
-	{"random", init_ran, 100},
-	{"random", init_ran, 1000},
-	{"random", init_ran, 10000}
+	{"ascending", init_asc, 2000},
+	{"ascending", init_asc, 16000},
+	{"ascending", init_asc, 128000},
+	{"descending", init_des, 2000},
+	{"descending", init_des, 16000},
+	{"descending", init_des, 128000},
+	{"random", init_ran, 2000},
+	{"random", init_ran, 16000},
+	{"random", init_ran, 128000}
 };
 
 struct TestCase {

sorts/bubble.c

@@ -1,21 +1,27 @@
 #include "test.h"
 
-static void sort_bubble_(int *a, int len) {
-    int i, t, s = 1;
-    while (s) {
-        s = 0;
-        for (i = 1; i < len; i++) {
-            if (a[i] < a[i - 1]) {
-                t = a[i];
-                a[i] = a[i - 1];
-                a[i - 1] = t;
-                s = 1;
-            }
-        }
-        --len;
-    }
+static Metric M;
+
+static void bubblesort(int *a, int len) {
+	int i, t, s = 1;
+	while (s) {
+		s = 0;
+		for (i = 1; i < len; i++) {
+			if (a[i] < a[i-1]) {
+				t = a[i];
+				a[i] = a[i-1];
+				a[i-1] = t;
+				s = 1;
+				++M.swap;
+			}
+			++M.comp;
+		}
+		--len;
+	}
 }
 
 Metric sort_bubble(Sequence seq) {
-	return (Metric){0};
+	M.comp = M.swap = M.ptime = 0;
+	bubblesort(seq.data, seq.len);
+	return M;
 }

sorts/heap.c

@@ -1,8 +1,50 @@
 #include "test.h"
 
-static void sort_heap_(int *a, int len) {
+static Metric M;
+
+static int max(int *a, int len, int i, int j, int k) {
+	int m = i;
+	if (j < len && a[j] > a[m]) {
+		m = j;
+		++M.comp;
+	}
+	if (k < len && a[k] > a[m]) {
+		m = k;
+		++M.comp;
+	}
+	return m;
+}
+
+static void downheap(int *a, int len, int i) {
+	while (1) {
+		int j = max(a, len, i, 2*i + 1, 2*i + 2);
+		if (j == i) {
+			break;
+		}
+		int t = a[i];
+		a[i] = a[j];
+		a[j] = t;
+		i = j;
+		++M.swap;
+	}
+}
+
+static void heapsort(int *a, int len) {
+	int i;
+	for (i = (len - 2) / 2; i >= 0; i--) {
+		downheap(a, len, i);
+	}
+	for (i = 0; i < len; i++) {
+		int t = a[len - i - 1];
+		a[len - i - 1] = a[0];
+		a[0] = t;
+		++M.swap;
+		downheap(a, len - i - 1, 0);
+	}
 }
 
 Metric sort_heap(Sequence seq) {
-	return (Metric){0};
+	M.comp = M.swap = M.ptime = 0;
+	heapsort(seq.data, seq.len);
+	return M;
 }

sorts/insert.c

@@ -1,8 +1,28 @@
 #include "test.h"
 
-static void sort_insert_(int *a, int len) {
+static Metric M;
+
+static void insertsort(int *a, int len) {
+	int i, j, key;
+	for (i = 1; i < len; ++i) {
+		key = a[i];
+		j = i;
+		if (j > 0 && key < a[j-1]) {
+			do {
+				a[j] = a[j-1];
+				--j;
+				++M.swap;
+				++M.comp;
+			} while (j > 0 && key < a[j-1]);
+		}
+		a[j] = key;
+		++M.comp;
+		++M.swap;
+	}
 }
 
 Metric sort_insert(Sequence seq) {
-	return (Metric){0};
+	M.comp = M.swap = M.ptime = 0;
+	insertsort(seq.data, seq.len);
+	return M;
 }

sorts/merge.c

@@ -1,8 +1,50 @@
+#include <stdlib.h>
+
 #include "test.h"
 
-static void sort_merge_(int *a, int len) {
+static Metric M;
+
+static void merge(int *a, int len, int m, int *x) {
+	int i, j, k;
+	for (i = 0; i < m; i++) {
+		x[i] = a[i];
+	}
+	M.swap += m;
+	for (i = 0, j = m, k = 0;;) {
+		++M.comp;
+		++M.swap;
+		if (a[j] < x[i]) {
+			a[k++] = a[j++];
+			if (j >= len)
+				break;
+		} else {
+			a[k++] = x[i++];
+			if (i >= m)
+				return;
+		}
+	}
+	while (i < m)
+		a[k++] = x[i++];
+	M.swap += m;
+}
+
+static void mergesort(int *a, int len, int *x) {
+	if (len < 2)
+		return;
+	int m = len / 2;
+	if (len > 2) {
+		mergesort(a, m, x);
+		mergesort(a + m, len - m, x);
+	}
+	merge(a, len, m, x);
 }
 
 Metric sort_merge(Sequence seq) {
-	return (Metric){0};
+	M.comp = M.swap = M.ptime = 0;
+	if (seq.len < 2)
+		return M;
+	int *x = malloc(seq.len/2 * sizeof(int));
+	mergesort(seq.data, seq.len, x);
+	free(x);
+	return M;
 }

sorts/quick.c

@@ -1,8 +1,40 @@
 #include "test.h"
 
-static void sort_quick_(int *a, int len) {
+static Metric M;
+
+static void quicksort(int *a, int len) {
+	if (len < 2)
+		return;
+	int pivot = a[len / 2];
+	int i, j, t;
+	for (i = 0, j = len - 1; ; ++i, --j) {
+		if (a[i] < pivot) {
+			do  {
+				++i;
+				++M.comp;
+			} while (a[i] < pivot);
+		}
+		++M.comp;
+		if (a[j] > pivot) {
+			do  {
+				--j;
+				++M.comp;
+			} while (a[j] > pivot);
+		}
+		++M.comp;
+		if (i >= j)
+			break;
+		t = a[i];
+		a[i] = a[j];
+		a[j] = t;
+		++M.swap;
+	}
+	quicksort(a, i);
+	quicksort(a + i, len - i);
 }
 
 Metric sort_quick(Sequence seq) {
-	return (Metric){0};
+	M.comp = M.swap = M.ptime = 0;
+	quicksort(seq.data, seq.len);
+	return M;
 }

test.c

@@ -6,29 +6,7 @@
 
 #include "test.h"
 
-static int *init_asc(int len) {
-	int *a = malloc(len * sizeof(int));
-	for (int i = 0; i < len; ++i)
-		a[i] = i;
-	return a;
-}
-
-static int *init_des(int len) {
-	int *a = malloc(len * sizeof(int));
-	for (int i = 0; i < len; ++i)
-		a[i] = len-i-1;
-	return a;
-}
-
-#if RAND_MAX <= 32767
-#warning "RAND_MAX is less than or equal to 32767."
-#endif
-static int *init_ran(int len) {
-	int *a = malloc(len * sizeof(int)), c = RAND_MAX/len + 1;
-	for (int i = 0; i < len; ++i)
-		a[i] = rand() / c;
-	return a;
-}
+typedef struct TestCase TestCase;
 
 #include "config.h"
 
@@ -41,34 +19,41 @@ static bool is_array_sorted(int *a, int len) {
 
 static void test(TestCase t) {
 	for (int i = 0; i < LENGTH(seqs); ++i) {
-		Metric aux = {0};
-		bool unsorted = false;
+		Sequence seq = seqs[i];
 		int repeat = repeattest;
-
-		printf("%s,%d,%s,", t.name, seqs[i].len, seqs[i].name);
+		seq.data = NULL;
 
 		while (repeat--) {
-			Sequence seq = {0};
-			seq.name = seqs[i].name;
-			seq.len = seqs[i].len;
+			free(seq.data);
 			seq.data = malloc(seq.len * sizeof(int));
 			memcpy(seq.data, seqs[i].data, seq.len * sizeof(int));
 
+			Metric aux = {0};
+			clock_t t_beg, t_end;
+			t_beg = clock();
 			aux = t.sort(seq);
-			t.mets[i].comp += aux.comp;
-			t.mets[i].chan += aux.chan;
-			t.mets[i].wtime += aux.wtime;
+			t_end = clock();
+			aux.ptime = (double)(t_end - t_beg) / (CLOCKS_PER_SEC/1000);
 
-			if (!is_array_sorted(seq.data, seq.len))
-				unsorted = true;
-			free(seq.data);
+			t.mets[i].comp += aux.comp;
+			t.mets[i].swap += aux.swap;
+			t.mets[i].ptime += aux.ptime;
 		}
 
 		t.mets[i].comp /= repeattest;
-		t.mets[i].chan /= repeattest;
-		t.mets[i].wtime /= repeattest;
-		printf(unsorted ? "unsorted" : "sorted");
-		putchar('\n');
+		t.mets[i].swap /= repeattest;
+		t.mets[i].ptime /= repeattest;
+
+		printf("%s,%d,%s,%lld,%lld,%.3lf,%s\n",
+				t.name,
+				seqs[i].len,
+				seqs[i].name,
+				t.mets[i].comp,
+				t.mets[i].swap,
+				t.mets[i].ptime,
+				is_array_sorted(seq.data, seq.len) ? "sorted" : "UNSORTED");
+
+		free(seq.data);
 	}
 }
 
@@ -77,6 +62,7 @@ int main(void) {
 
 	for (int i = 0; i < LENGTH(seqs); ++i)
 		seqs[i].data = seqs[i].initpop(seqs[i].len);
+	printf("Algorithm,Load number,Init sort,Comparisons,Swaps,CPU time (ms),Is sorted?\n");
 	for (int i = 0; i < LENGTH(tests); ++i)
 		test(tests[i]);
 	for (int i = 0; i < LENGTH(seqs); ++i)

test.h

@@ -2,10 +2,9 @@
 
 typedef struct Sequence Sequence;
 
-typedef struct TestCase TestCase;
-
 typedef struct {
-	int comp, chan, wtime;	/* comparisons, changes, walltime (elapsed time) */
+	unsigned long long comp, swap;	/* comparisons, swaps, */
+	double ptime;			/* CPU time (in ms) */
 } Metric;
 
 struct Sequence {