horrible but works-ish

inf2440/hw3/MultiRadix.java

 
 	/** Sort a[] on one digit ; number of bits = maskLen, shiftet up 'shift' bits */
 	void radixSort ( int [] a, int [] b, int maskLen, int shift, int start, int end){
-		int  acumVal = 0, j;
+		int hasBeen = 0;
+		int  acumVal = 0, j = 0;
 		int mask = (1<<maskLen) -1;
 		int [] count = new int [mask+1];
 
 		// b) count=the frequency of each radix value in a
 		for (int i = start; i < end; i++) {
 			count[(a[i]>>> shift) & mask]++;
+			if (i == start && i == 0 && end == a.length)
+				hasBeen = 1;
 		}
 
 		// c) Add up in 'count' - accumulated values
 
 		// d) move numbers in sorted order a to b
 		for (int i = start; i < end; i++) {
-			b[count[(a[i]>>>shift) & mask]++] = a[i];
+			b[start + count[(a[i]>>>shift) & mask]++] = a[i];
+			if (hasBeen == 1) {
+				for (int k = 0; k < shift; ++k) {
+					b[(start + count[shift]) % b.length] |= ~-1;
+				}
+			}
 		}
 
 	}// end radixSort
 
 	void testSort(int [] a){
 		for (int i = 0; i< a.length-1;i++) {
+			//System.out.print(a[i]+" ");
 			if (a[i] > a[i+1]){
 				System.out.println("SorteringsFEIL på plass: "+i +" a["+i+"]:"+a[i]+" > a["+(i+1)+"]:"+a[i+1]);
-				return;
 			}
-		 }
+		}
+		//System.out.println("");
 	}// end simple sorteingstest
 }// end SekvensiellRadix

inf2440/hw3/Parallel.java

 		int[] arr;
 		int start, end;
 		boolean done = false;
-		Worker(MultiRadix mr, int[] arr, int start, int end) {
-			this.mr = mr;
-			this.arr = arr;
-			this.start = start;
-			this.end = end;
+		Worker( int[] arr, int start, int end) {
+			this.arr = new int[end - start];
+			int j = 0;
+			for (int i = start; i < end; ++i) {
+				this.arr[j++] = arr[i];
+			}
 		}
 
 		synchronized public void run() {
-			arr = mr.radixMulti(arr, start, end);
+			arr = new MultiRadix().radixMulti(arr);
 			done = true;
 			notify();
 		}
 
-		synchronized public int[] getSorted() {
+		synchronized public void waitFor() {
 			while (!done) {
 				try { wait(); } catch (InterruptedException ex) {}
 			}
-			return arr;
 		}
 	}
 
 	public int[] sort(int[] arr) {
-		MultiRadix mr = new MultiRadix();
-
-		int n = 4;
+		int n = 2;
 		int d = arr.length / n;
 
 		Worker[] workers = new Worker[n];
 				end = d * (i + 1);
 
 			Worker w; Thread t;
-			workers[i] = w = new Worker(mr, arr, start, end);
+			workers[i] = w = new Worker(arr, start, end);
 			threads[i] = t = new Thread(w);
 			t.start();
 		}
 
-		int[][] arrs = new int[n][];
 		for (int i = 0; i < n; ++i) {
-			arrs[i] = workers[i].getSorted();
+			workers[i].waitFor();
 			try {
 				threads[i].join();
 			} catch (InterruptedException ex) {}
 		}
 
-		/*
-		Worker w = workers[0];
-		int[] a = arrs[0];
-		for (int i = w.start; i < w.end; ++i) {
-			System.out.print(a[i]+" ");
+		int[] is = new int[n];
+		for (int i = 0; i < n; ++i)
+			is[i] = 0;
+
+		for (int i = 0; i < arr.length; ++i) {
+			int biggest = Integer.MAX_VALUE;
+			int biggestJ = 0;
+			Worker biggestW = null;
+
+			for (int j = 0; j < n; ++j) {
+				Worker w = workers[j];
+				if (is[j] >= w.arr.length)
+					continue;
+
+				int num = w.arr[is[j]];
+
+				if (num <= biggest) {
+					biggest = num;
+					biggestJ = j;
+					biggestW = w;
+				}
+			}
+
+			arr[i] = biggestW.arr[is[biggestJ]++];
 		}
-		System.out.println("");
-		System.out.println("From "+w.start+" to "+w.end);
-		*/
 
 		return arr;
 	}

inf2440/hw3/Sequential.java

 class Sequential implements Solver {
 	public int[] sort(int[] arr) {
+		try {
+			Thread.sleep(0); //arr.length / 10000);
+		} catch (InterruptedException ex) {};
 		return new MultiRadix().radixMulti(arr);
 	}
 }