added example code for lec 5

Author: joshHug

lec4/live2/Sort.java

@@ -0,0 +1,59 @@
+/** We will provide methods for printing out args in sorted order.
+ *  @author Josh Hug
+ */
+
+public class Sort {
+    /** Puts A into sorted order. */
+    public static void sort(String[] a) {
+        sort(a, 0);
+    }
+
+    /** Sorts the array A starting from START. */
+    private static void sort(String[] a, int start) {
+        if (start == a.length)
+            return;
+
+        // Find the smallest thing (location).
+        int mindex = indexOfSmallest(a, start);
+
+        // Swap it to the front.
+        swap(a, start, mindex);
+
+        // Selection sort the remaining N-1 things. [done]
+        sort(a, start + 1);        
+    }
+
+    /** Swaps the items in IX and IY of A. */
+    public static void swap(String[] a, int ix, int iy) {
+        String temp = a[ix];
+        a[ix] = a[iy];
+        a[iy] = temp;
+    }
+
+    /** Returns the smallest item in A's position, starting from
+      * position START. */
+    public static int indexOfSmallest(String[] a, int start) {
+        int mindex = start;
+        int i = start;
+        while (i < a.length) {
+            int compareNumber = a[i].compareTo(a[mindex]);
+
+            if (compareNumber < 0) {
+                mindex = i;
+            }
+            i = i + 1;
+        }
+        return mindex;
+    }
+
+    /** Prints out A. */
+    public static void print(String[] a) {
+
+    }
+
+    /**  Prints ARGS in sorted order.
+     */
+    public static void main(String[] args) {
+        
+    }
+} 

lec4/live2/TestSort.java

@@ -0,0 +1,86 @@
+/** Tests the methods in the Sort class.
+ *  @author Josh Hug
+ */
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+/** current annoyances:
+ * 1. We have to manually invoke all of our tests in main.
+ * 2. We have to comment things out that we don't actaully want to run.
+ * 2b (alternate statement). Test failure causes entire thing to stop.
+ * 3. Output is hard to read.
+ 
+  To fix these:
+  1. Prepend each test with @org.junit.Test
+  2. Let's make all tests non-static (!!??)
+  3. Replace manual invocations with jh61b.junit.textui.runClasses
+ 
+Remaining annoyances:
+1. It is annoying to write org.junit all over the place
+2. org.junit.Assert is also annoying.
+
+To fix these, use MORE MAGIC:
+import org.junit.Test; <-- means you can just type @Test
+import static org.junit.Assert.*; <-- you can omit org.junit.Assert
+ */
+
+public class TestSort {
+    /** Tests the sort method of the Sort class. */
+    @Test
+    public void testSort() {
+        String[] input = {"a", "clever", "happy", "dog"};
+        String[] expected = {"a", "clever", "dog", "happy"};
+        Sort.sort(input);
+
+        // Check that input is equal to expected.
+        // If it is not, then print out a useful message for
+        // the programmer (to be used for fixing code).
+        assertArrayEquals(expected, input);
+    }
+
+    @Test
+    public void testIndexOfSmallest() {
+        String[] input = {"a", "clever", "happy", "dog"};
+        int actual = Sort.indexOfSmallest(input, 0);
+        int expected = 0;
+
+        assertEquals(expected, actual);
+        actual = Sort.indexOfSmallest(input, 2);
+        expected = 3;
+
+        assertEquals(expected, actual);
+
+    }
+
+    @Test
+    public void testSwap() {
+        String[] input = {"a", "clever", "happy", "dog"};        
+        Sort.swap(input, 0, 2);
+        String[] expected = {"happy", "clever", "a", "dog"};        
+        assertArrayEquals(input, expected);
+    }
+
+    /** Run tests.
+     */
+    public static void main(String[] args) {
+        jh61b.junit.textui.runClasses(TestSort.class);
+    }
+} 
+
+/** Graveyard of forgotten dreams and sadness.
+        // Check that input is equal to expected.
+        // If it is not, then print out a useful message for
+        // the programmer (to be used for fixing code).
+        if (input.length != expected.length) {
+            System.out.println("testSort(): Lengths did not match!");
+            System.out.println("input length: " + input.length);            
+            System.out.println("expected length: " + expected.length);        
+        }
+
+        int i = 0;
+        while (i < input.length) {
+            if (input[i] != expected[i]) {
+                ...
+                
+            }
+        } */

lec5/examples/FloatingPoint.java

@@ -0,0 +1,16 @@
+/** Some Java mysteries involving floating point numbers.
+ *  Won't talk about today (phew...)
+ *  @author Josh Hug
+ */
+
+public class FloatingPoint {
+    /** 
+     */
+
+    public static void main(String[] args) {
+        System.out.println(0.1);
+        System.out.println(0.2);
+        System.out.println(0.1 + 0.2);
+        System.out.println(0.1 + 0.2 - 0.1);
+    }
+} 

lec5/examples/Integers.java

@@ -0,0 +1,11 @@
+/** Some Java mysteries involving integers.
+ *  @author Josh Hug
+ */
+
+public class Integers {
+    public static void main(String[] args) {
+        System.out.println(2147483647 + 1);
+        System.out.println(1000000000 * 5);
+        System.out.println(29 & 15);
+    }
+} 

lec5/examples/PowerTour.java

@@ -0,0 +1,19 @@
+import java.io.IOException;
+/** Experimentation with integers
+ *  @author Josh Hug
+ */
+
+public class PowerTour {
+    private static void powerTour(int x) throws IOException {
+        int acc = x;
+        while (true) {
+            System.out.println(acc);
+            System.in.read();
+            acc = acc * x;
+        }
+    }   
+
+    public static void main(String[] args) throws IOException {
+        powerTour(32);
+    }
+}