Most Done, Including the client

coms228/EnginesSmall.txt

+LockheedMartian,131.55|NorthrupGreenman,148.82
+LockheedMartian,135.68|LockheedMartian,153.28
+NorthrupGreenman,52.66|Boing,17.27
+Boing,119.86|Boing,3.57
+LockheedMartian,151.19|NorthrupGreenman,56.75
+Boing,16.38|NorthrupGreenman,114.84
+Boing,72.29|LockheedMartian,164.11
+Boing,137.93|Boing,160.69
+NorthrupGreenman,81.87|Boing,125.86
+NorthrupGreenman,85.36|NorthrupGreenman,26.04
+LockheedMartian,5.93|NorthrupGreenman,65.93
+LockheedMartian,96.27|LockheedMartian,75.10
+LockheedMartian,41.29|LockheedMartian,83.27
+NorthrupGreenman,32.37|Boing,11.47
+LockheedMartian,15.27|LockheedMartian,8.40
+NorthrupGreenman,57.90|NorthrupGreenman,117.96
+Boing,89.97|Boing,46.38
+Boing,27.99|NorthrupGreenman,68.01
+NorthrupGreenman,20.09|NorthrupGreenman,49.64
+LockheedMartian,85.91|Boing,97.19
+LockheedMartian,54.63|LockheedMartian,42.54
+Boing,59.45|NorthrupGreenman,21.91
+LockheedMartian,50.65|NorthrupGreenman,125.50
+NorthrupGreenman,131.17|LockheedMartian,134.29
+LockheedMartian,98.10|Boing,7.68
+Boing,82.39|NorthrupGreenman,37.00
+LockheedMartian,33.53|LockheedMartian,121.08
+LockheedMartian,12.50|NorthrupGreenman,97.55
+Boing,85.22|Boing,44.28
+NorthrupGreenman,85.06|NorthrupGreenman,34.97
+LockheedMartian,70.08|LockheedMartian,71.63
+LockheedMartian,32.71|LockheedMartian,141.91
+LockheedMartian,24.98|Boing,32.04
+NorthrupGreenman,136.65|Boing,120.27
+LockheedMartian,123.68|LockheedMartian,15.71
+LockheedMartian,111.78|NorthrupGreenman,29.78
+NorthrupGreenman,79.24|LockheedMartian,77.27
+NorthrupGreenman,37.70|NorthrupGreenman,24.33
+Boing,94.21|NorthrupGreenman,70.60
+LockheedMartian,86.71|Boing,87.46
+NorthrupGreenman,10.74|Boing,57.55
+LockheedMartian,71.29|LockheedMartian,2.15
+LockheedMartian,44.23|Boing,102.20
+Boing,19.78|LockheedMartian,22.81
+Boing,124.85|NorthrupGreenman,105.08
+NorthrupGreenman,111.12|LockheedMartian,41.16
+NorthrupGreenman,32.84|Boing,67.00
+Boing,70.97|LockheedMartian,74.09
+NorthrupGreenman,91.28|NorthrupGreenman,8.25
+LockheedMartian,44.32|LockheedMartian,159.05
+LockheedMartian,62.95|NorthrupGreenman,77.58
+LockheedMartian,143.72|LockheedMartian,123.73
+LockheedMartian,62.73|Boing,120.94
+NorthrupGreenman,94.32|NorthrupGreenman,82.86
+Boing,35.47|NorthrupGreenman,134.02
+LockheedMartian,49.37|Boing,144.86
+LockheedMartian,94.51|LockheedMartian,58.26
+NorthrupGreenman,122.73|LockheedMartian,96.34
+NorthrupGreenman,74.74|LockheedMartian,110.41
+LockheedMartian,67.16|Boing,67.86
+NorthrupGreenman,50.64|NorthrupGreenman,88.82
+Boing,77.86|LockheedMartian,145.31
+LockheedMartian,86.27|Boing,115.21
+Boing,74.54|LockheedMartian,10.64
+NorthrupGreenman,110.56|LockheedMartian,70.37
+LockheedMartian,50.83|NorthrupGreenman,24.21
+NorthrupGreenman,44.16|NorthrupGreenman,23.98
+LockheedMartian,101.64|NorthrupGreenman,146.25
+LockheedMartian,50.24|Boing,76.42
+NorthrupGreenman,38.90|LockheedMartian,108.29
+Boing,156.86|Boing,65.91
+Boing,137.08|Boing,39.76
+LockheedMartian,120.23|Boing,96.20
+NorthrupGreenman,124.32|NorthrupGreenman,156.33
+Boing,69.58|LockheedMartian,144.30
+Boing,89.91|LockheedMartian,108.56
+NorthrupGreenman,57.66|LockheedMartian,53.39
+Boing,57.49|LockheedMartian,102.48
+LockheedMartian,119.57|LockheedMartian,111.11
+NorthrupGreenman,145.98|Boing,91.39
+Boing,26.23|LockheedMartian,25.68
+LockheedMartian,60.44|Boing,2.56
+Boing,100.90|LockheedMartian,14.21
+LockheedMartian,55.45|NorthrupGreenman,43.73
+NorthrupGreenman,109.27|NorthrupGreenman,93.55
+Boing,22.31|NorthrupGreenman,28.55
+LockheedMartian,81.68|NorthrupGreenman,71.96
+LockheedMartian,89.33|LockheedMartian,25.45
+NorthrupGreenman,79.79|NorthrupGreenman,60.03
+Boing,72.46|LockheedMartian,75.58
+LockheedMartian,68.94|LockheedMartian,24.86
+Boing,96.34|LockheedMartian,56.14
+NorthrupGreenman,44.56|Boing,62.01
+Boing,34.24|NorthrupGreenman,27.04
+NorthrupGreenman,44.46|LockheedMartian,103.47
+Boing,120.76|LockheedMartian,64.24
+Boing,99.33|LockheedMartian,47.88
+LockheedMartian,157.25|NorthrupGreenman,17.46
+NorthrupGreenman,36.04|NorthrupGreenman,43.33
+NorthrupGreenman,157.33|NorthrupGreenman,145.70
\ No newline at end of file

coms228/src/edu/iastate/cs228/hw2/Boing.java

-package edu.iastate.cs228.hw2;
-
-public class Boing extends Engine {
-	public Boing(double size, String brandName){
-		super(size, brandName);
-	}
-	
-	@Override
-	public double getPrice() {
-		return 13.75*this.getSize();
-	}
-}

coms228/src/edu/iastate/cs228/hw2/Engine.java

 package edu.iastate.cs228.hw2;
 
-public abstract class Engine implements Comparable<Engine> {
+public class Engine implements Comparable<Engine> {
 	private double size;
 	private String brandName;
 	
@@ -23,7 +23,16 @@ public abstract class Engine implements Comparable<Engine> {
 		return brandName;
 	}
 	
-	public abstract double getPrice();
+	public double getPrice(){
+		if(brandName.equals("LockheedMartian"))
+			return 2.50*this.getSize();
+		else if (brandName.equals("NorthrupGreenman")){
+			return 9.50*this.getSize();
+		}
+		else {
+			return 13.75*this.getSize();
+		}
+	}
 	
 	@Override
 	public int compareTo(Engine other){

coms228/src/edu/iastate/cs228/hw2/EngineTest.java

@@ -20,6 +20,12 @@ public class EngineTest {
 	Pair<Integer, Double> pair4;
 	Pair<Integer, Double>[] pairArray;
 	Comparator<Pair<Integer, Double>> pairComparator;
+	Pair<Engine, Engine> pe1;
+	Pair<Engine, Engine> pe2;
+	Pair<Engine, Engine> pe3;
+	Pair<Engine, Engine> pe4;
+	Comparator<Pair<Engine, Engine>> peComparator;
+	Pair<Engine, Engine>[] peArray;
 
 	@Before
 	public void setup() {
@@ -39,13 +45,31 @@ public class EngineTest {
 				return o1.compareTo(o2);
 			}
 		};
+		peComparator = new Comparator<Pair<Engine, Engine>>() {
+
+			@Override
+			public int compare(Pair<Engine, Engine> o1, Pair<Engine, Engine> o2) {
+				return o1.compareTo(o2);
+			}
+		};
+		
+		pe1 = new Pair(new Engine(131.55, "LockheedMartian"), new Engine(148.82, "NorthrupGreenman"));
+		pe2 = new Pair(new Engine(135.68, "LockheedMartian"), new Engine(153.28, "LockheedMartian"));
+		pe3 = new Pair(new Engine(52.66, "NorthrupGreenman"), new Engine(17.27, "Boing"));
+		pe4 = new Pair(new Engine(119.86, "Boing"), new Engine(3.57, "Boing"));
+		
+		peArray = (Pair<Engine, Engine>[]) new Pair<?, ?>[4];
+		peArray[0] = pe4;
+		peArray[1] = pe3;
+		peArray[2] = pe2;
+		peArray[3] = pe1;
 	}
 
 	@Ignore
 	@Test
 	public void testCompare() {
-		LockheedMartian lh = new LockheedMartian(12, "LockheedMartian");
-		NorthrupGreenman ng = new NorthrupGreenman(12, "NorthrupGreenman");
+		Engine lh = new Engine(12, "LockheedMartian");
+		Engine ng = new Engine(12, "NorthrupGreenman");
 		assertTrue(ng.compareTo(lh) > 0);
 	}
 
@@ -66,7 +90,7 @@ public class EngineTest {
 	@Ignore
 	@Test
 	public void testInsertionSort() {
-		Sort.insertionSort(pairArray, pairComparator);
+		System.out.println(Sort.insertionSort(pairArray, pairComparator));
 		assertTrue(pairArray[1].compareTo(pairArray[2]) < 0);
 		assertTrue(pairArray[3].compareTo(pairArray[2]) > 0);
 	}
@@ -74,12 +98,12 @@ public class EngineTest {
 	@Ignore
 	@Test
 	public void testSelectionSort() {
-		Sort.selectionSort(pairArray, pairComparator);
+		System.out.println(Sort.selectionSort(pairArray, pairComparator));
 		assertTrue(pairArray[1].compareTo(pairArray[2]) < 0);
 		assertTrue(pairArray[3].compareTo(pairArray[2]) > 0);
 	}
 
-//	@Ignore
+	@Ignore
 	@Test
 	public void testQuickSortFirst() {
 		System.out.println(Sort.quickSort(pairArray, pairComparator, "first"));
@@ -87,5 +111,89 @@ public class EngineTest {
 		assertTrue(pairArray[3].compareTo(pairArray[2]) > 0);
 		
 	}
+	
+//	@Ignore
+	@Test
+	public void testQuickSortMedian() {
+		System.out.println(Sort.quickSort(pairArray, pairComparator, "median"));
+		assertTrue(pairArray[1].compareTo(pairArray[2]) < 0);
+		assertTrue(pairArray[3].compareTo(pairArray[2]) > 0);
+		
+	}
+	
+//	@Ignore
+	@Test
+	public void testQuickSortRandom() {
+		System.out.println(Sort.quickSort(pairArray, pairComparator, "random"));
+		assertTrue(pairArray[1].compareTo(pairArray[2]) < 0);
+		assertTrue(pairArray[3].compareTo(pairArray[2]) > 0);
+		
+	}
+	
+	@Ignore
+	@Test
+	public void testInsertionSortPE() {
+		System.out.println(Sort.insertionSort(peArray, peComparator));
+		assertTrue(peArray[1].compareTo(peArray[2]) < 0);
+		assertTrue(peArray[3].compareTo(peArray[2]) > 0);
+	}
+	
+	@Ignore
+	@Test
+	public void testSelectionSortPE() {
+		System.out.println(Sort.selectionSort(peArray, peComparator));
+		assertTrue(peArray[1].compareTo(peArray[2]) < 0);
+		assertTrue(peArray[3].compareTo(peArray[2]) > 0);
+	}
+	
+	@Ignore
+	@Test
+	public void testQuickSortFirstPE() {
+		System.out.println(Sort.quickSort(peArray, peComparator, "first"));
+		assertTrue(peArray[1].compareTo(peArray[2]) < 0);
+		assertTrue(peArray[3].compareTo(peArray[2]) > 0);
+		
+	}
+	
+//	@Ignore
+	@Test
+	public void testQuickSortMedianPE() {
+		System.out.println(Sort.quickSort(peArray, peComparator, "median"));
+		assertTrue(peArray[1].compareTo(peArray[2]) < 0);
+		assertTrue(peArray[3].compareTo(peArray[2]) > 0);
+		
+	}
+	
+//	@Ignore
+	@Test
+	public void testQuickSortRandomPE() {
+		System.out.println(Sort.quickSort(peArray, peComparator, "random"));
+		assertTrue(peArray[1].compareTo(peArray[2]) < 0);
+		assertTrue(peArray[3].compareTo(peArray[2]) > 0);
+		
+	}
+	
+	@Ignore
+	@Test
+	public void testArraysSortPE() {
+		Arrays.sort(peArray);
+		assertTrue(peArray[0].compareTo(peArray[1]) < 0);
+		assertTrue(peArray[3].compareTo(peArray[2]) > 0);
+	}
+	
+	@Ignore
+	@Test
+	public void testLineValid(){
+		String line1 = "LockheedMartian,36.03|NorthrupGreenman,16.56";
+		assertTrue(SortingClient.lineValid(line1));
+	}
+	
+	@Ignore
+	@Test
+	public void testLineReadPairs(){
+		String line1 = "LockheedMartian,36.03|NorthrupGreenman,16.56";
+		Pair<Engine, Engine> testPE1 = SortingClient.readPairEngines(line1);
+		assertTrue(testPE1.compareTo(pe1) < 0);
+	}
 
 }

coms228/src/edu/iastate/cs228/hw2/LockheedMartian.java

-package edu.iastate.cs228.hw2;
-
-public class LockheedMartian extends Engine {
-
-	public LockheedMartian(double size, String brandName){
-		super(size, brandName);
-	}
-	
-	@Override
-	public double getPrice() {
-		return 2.50*this.getSize();
-	}
-
-}

coms228/src/edu/iastate/cs228/hw2/NorthrupGreenman.java

-package edu.iastate.cs228.hw2;
-
-public class NorthrupGreenman extends Engine {
-	public NorthrupGreenman(double size, String brandName){
-		super(size, brandName);
-	}
-	
-	@Override
-	public double getPrice() {
-		return 9.50*this.getSize();
-	}
-}

coms228/src/edu/iastate/cs228/hw2/Pair.java

@@ -18,17 +18,17 @@ public class  Pair<E extends Comparable, T extends Comparable> implements Compar
 		else if(this.getFirst().compareTo(other.getFirst()) < 0){
 			return -1;
 		}
-		else if(this.getFirst().compareTo(other.getFirst()) == 0 && this.getSecond().compareTo(other.getSecond()) == 0){
-			return 0;
-		}
-		else if(this.getFirst().compareTo(other.getFirst()) == 0 && this.getSecond().compareTo(other.getSecond()) > 0){
-			return 1;
-		}
-		else if(this.getFirst().compareTo(other.getFirst()) == 0 && this.getSecond().compareTo(other.getSecond()) < 0){
-			return -1;
-		}
-		else{
-			return 0;
+		else {
+			if (this.getSecond().compareTo(other.getSecond()) > 0){
+				return 1;
+			}
+			else if(this.getSecond().compareTo(other.getSecond()) < 0){
+				return -1;
+				
+			}
+			else{
+				return 0;
+			}
 		}
 	}
 	

coms228/src/edu/iastate/cs228/hw2/Sort.java

@@ -88,6 +88,7 @@ public class Sort {
 			int rs = low;
 			int ls = high;
 			T pivotValue = arr[pivotPosition];
+			//Move the pivot to the end of the array
 			swap(arr, pivotPosition, ls);
 			pivotPosition = ls;
 			while (rs < ls){

coms228/src/edu/iastate/cs228/hw2/SortingClient.java

 package edu.iastate.cs228.hw2;
 
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.Scanner;
+
 public class SortingClient {
 
-	public static void main(String[] args) {
-		// TODO Auto-generated method stub
+	public static void main(String[] args) throws FileNotFoundException {
+		System.out
+				.println("Welcome to Boris and Natasha's engine sorting client ");
+
+		// Parse each file into an array
+		File smallEnginesFile = new File(args[0]);
+		File mediumEnginesFile = new File(args[1]);
+		File largeEnginesFile = new File(args[2]);
+		Pair<Engine, Engine>[] pairSmall = (Pair<Engine, Engine>[]) new Pair<?, ?>[countLines(smallEnginesFile)];
+		Pair<Engine, Engine>[] pairMedium = (Pair<Engine, Engine>[]) new Pair<?, ?>[countLines(mediumEnginesFile)];
+		Pair<Engine, Engine>[] pairLarge = (Pair<Engine, Engine>[]) new Pair<?, ?>[countLines(largeEnginesFile)];
+		createPairArray(pairSmall, smallEnginesFile);
+		createPairArray(pairMedium, mediumEnginesFile);
+		createPairArray(pairLarge, largeEnginesFile);
+
+		// Create two comparators
+		// Normal Comparator
+		Comparator<Pair<Engine, Engine>> peComparator = new Comparator<Pair<Engine, Engine>>() {
+
+			@Override
+			public int compare(Pair<Engine, Engine> o1, Pair<Engine, Engine> o2) {
+				return o1.compareTo(o2);
+			}
+		};
+
+		// Comparator by size
+		Comparator<Pair<Engine, Engine>> peSizeComparator = new Comparator<Pair<Engine, Engine>>() {
+
+			@Override
+			public int compare(Pair<Engine, Engine> o1, Pair<Engine, Engine> o2) {
+				if (o1.getFirst().getSize() > o2.getFirst().getSize()) {
+					return 1;
+				} else if (o1.getFirst().getSize() < o2.getFirst().getSize()) {
+					return -1;
+				} else {
+					return 0;
+				}
+			}
+		};
+
+		// Print out results
+		
+		//Process EnginesLarge using insertion sort
+		
+		//Output File
+		PrintWriter peLargeInsertionSortOut = new PrintWriter(new File(
+				"EnginesLargeInsertionSortPrice.txt"));
+		PrintWriter peLargeInsertionSizeSortOut = new PrintWriter(new File(
+				"EnginesLargeInsertionSortSize.txt"));
+		// Create temporary Arrays
+		Pair<Engine, Engine>[] pairLargeTemp1 = (Pair<Engine, Engine>[]) new Pair<?, ?>[pairLarge.length];
+		createTempArray(pairLarge, pairLargeTemp1);
+
+		Pair<Engine, Engine>[] pairLargeTemp2 = (Pair<Engine, Engine>[]) new Pair<?, ?>[pairLarge.length];
+		createTempArray(pairLarge, pairLargeTemp2);
+		
+		
+		// System.out.println(Sort.insertionSort(pairSmall, peComparator));
+		// System.out.println(Sort.insertionSort(pairMedium, peComparator));
+		// System.out.println(Sort.insertionSort(pairLarge, peComparator));
+		
+		//Sort in Normal Order
+		System.out.println(Sort.insertionSort(pairLargeTemp1, peComparator));
+		printSortedPairs(pairLargeTemp1, peLargeInsertionSortOut);
+		peLargeInsertionSortOut.close();
+		
+		//Sort by Size
+		System.out.println(Sort.insertionSort(pairLargeTemp2, peSizeComparator));
+		printSortedPairs(pairLargeTemp2, peLargeInsertionSizeSortOut);
+		peLargeInsertionSizeSortOut.close();
+		// System.out.println(Sort.selectionSort(pairSmall, peComparator));
+		// System.out.println(Sort.quickSort(pairSmall, peComparator, "first"));
+	}
+
+	private static void createTempArray(Pair<Engine, Engine>[] pairLarge,
+			Pair<Engine, Engine>[] tempArray) {
+		if (tempArray.length == pairLarge.length) {
+			System.arraycopy(pairLarge, 0, tempArray, 0, pairLarge.length);
+		}
+	}
+
+	private static void printSortedPairs(Pair<Engine, Engine>[] sortedPairs,
+			PrintWriter outFile) {
+		for (Pair<Engine, Engine> pairEngine : sortedPairs) {
+			String firstEngineStr = pairEngine.getFirst().getBrandName() + ","
+					+ pairEngine.getFirst().getSize() + ","
+					+ pairEngine.getFirst().getPrice();
+			String secondEngineStr = pairEngine.getSecond().getBrandName()
+					+ "," + pairEngine.getSecond().getSize() + ","
+					+ pairEngine.getSecond().getPrice();
+			outFile.println(firstEngineStr + "|" + secondEngineStr);
+		}
+	}
+
+	public static boolean lineValid(String line) {
+		ArrayList<String> pairs = extractPairsString(line);
+
+		if (pairs.equals(null) || pairs.size() != 2) {
+			return false;
+		}
+
+		for (String eng : pairs) {
+			ArrayList<String> engine = extractEngineString(eng);
+
+			if (engine.equals(null) || engine.size() != 2) {
+				return false;
+			}
 
+			try {
+				double size = Double.parseDouble(engine.get(1));
+			} catch (NumberFormatException e) {
+				return false;
+			}
+		}
+		return true;
 	}
 
+	private static ArrayList<String> extractEngineString(String eng) {
+		Scanner pairScanner = new Scanner(eng);
+		pairScanner.useDelimiter(",");
+		ArrayList<String> engine = new ArrayList<String>();
+		while (pairScanner.hasNext()) {
+			engine.add(pairScanner.next().trim());
+		}
+		return engine;
+	}
+
+	private static ArrayList<String> extractPairsString(String line) {
+		Scanner lineScanner = new Scanner(line);
+		lineScanner.useDelimiter("\\|");
+		ArrayList<String> pairs = new ArrayList<String>();
+		while (lineScanner.hasNext()) {
+			pairs.add(lineScanner.next().trim());
+		}
+		return pairs;
+	}
+
+	public static Pair<Engine, Engine> readPairEngines(String line) {
+		if (lineValid(line)) {
+			ArrayList<String> pairs = extractPairsString(line);
+			Engine[] enginePair = new Engine[2];
+
+			for (int i = 0; i < pairs.size(); i++) {
+				ArrayList<String> engine = extractEngineString(pairs.get(i));
+
+				String name = engine.get(0);
+				double size = Double.parseDouble(engine.get(1));
+
+				enginePair[i] = new Engine(size, name);
+			}
+
+			return new Pair<Engine, Engine>(enginePair[0], enginePair[1]);
+		} else {
+			System.out.println("The format is not correct");
+			return null;
+
+		}
+	}
+
+	private static int countLines(File file) throws FileNotFoundException {
+		Scanner lineScanner = new Scanner(file);
+		int lineNumber = 0;
+		// while there are more lines...
+		while (lineScanner.hasNextLine()) {
+			lineScanner.next();
+			lineNumber++;
+		}
+		// close the file
+		lineScanner.close();
+
+		return lineNumber;
+	}
+
+	private static void createPairArray(Pair<Engine, Engine>[] pairArray,
+			File file) throws FileNotFoundException {
+		Scanner lineScanner = new Scanner(file);
+		if (checkFileFormat(file)) {
+			int lineNumber = 0;
+			// while there are more lines...
+			while (lineScanner.hasNextLine()) {
+				pairArray[lineNumber] = readPairEngines(lineScanner.next()
+						.trim());
+				lineNumber++;
+			}
+			// close the file
+			lineScanner.close();
+		}
+	}
+
+	private static boolean checkFileFormat(File file)
+			throws FileNotFoundException {
+		if (file.equals(null)) {
+			return false;
+		} else {
+			Scanner lineScanner = new Scanner(file);
+			// while there are more lines...
+			while (lineScanner.hasNextLine()) {
+				if (!lineValid(lineScanner.next())) {
+					return false;
+				}
+			}
+			// close the file
+			lineScanner.close();
+		}
+		return true;
+	}
 }