tests and exercise for random search

Author: arcuri82

Diff for: docs/exercises/ex10.md

@@ -1,5 +1,19 @@
 # Exercise 10
 
+## Part A
+
+The code of `RandomForKnapsack` is not particularly good, as it creates
+new arrays on the heap at each step.
+Write a new `RandomForKnapsackOptimized` class, in which __ONLY 2__ arrays
+are instantiated: one to keep the best solution seen so far, and one as
+a buffer to randomize at each step to evaluate a new configuration.
+When a new, better configuration is found, just swap the two array pointers.
+
+Create a new `RandomForKnapsackOptimizedTest`, based on `RandomForKnapsackTest`,
+to test this new implementation. 
+
+## Part B
+
 Consider the class `HillClimbingForQueens`. 
 Modify the Hill Climbing algorithm to use *Steepest Ascent*:
 instead of climbing to the first better element in the neighbourhood,

Diff for: lessons/src/main/java/org/pg4200/les10/knapsack/RandomForKnapsack.java

@@ -9,7 +9,7 @@
 public class RandomForKnapsack {
 
 
-    public boolean[] solve(int maxIterations, KnapsackProblem problem){
+    public static boolean[] solve(int maxIterations, KnapsackProblem problem){
 
         if(maxIterations < 1){
             throw new IllegalArgumentException("Invalid number of iterations");
@@ -37,8 +37,16 @@ public boolean[] solve(int maxIterations, KnapsackProblem problem){
         return solution;
     }
 
-    private boolean[] sample(int n, Random random){
+    private static boolean[] sample(int n, Random random){
 
+        /*
+            Note: the code here is not particularly good... as we are
+            instantiating a new array on the heap at each step.
+            Even if we store only the best array, we are still polluting
+            the heap, increasing the number of invocations of the
+            JVM Garbage Collector.
+            How to fix is given as exercise.
+         */
         boolean[] solution = new boolean[n];
         for(int i=0; i<solution.length; i++){
             solution[i] = random.nextBoolean();

Diff for: lessons/src/test/java/org/pg4200/les10/knapsack/RandomForKnapsackTest.java

@@ -0,0 +1,40 @@
+package org.pg4200.les10.knapsack;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class RandomForKnapsackTest {
+
+    private void test(int iterations, KnapsackInstanceWithSolution p, double optimum){
+
+        boolean[] res = RandomForKnapsack.solve(iterations, p.getProblem());
+
+        double fitness = p.getProblem().evaluate(res);
+
+        assertEquals(optimum, fitness, 0.001);
+
+        double best = p.getBestFitness();
+
+        assertEquals(best, fitness, 0.001);
+    }
+
+    /*
+        Note: here we put high enough number of iterations (compared to the size
+        of search space) that it is more likely to be hit on the head by a meteor
+        while reading this text than these tests will fail.
+     */
+
+    @Test
+    public void testP05(){
+
+        test(1000, KnapsackInstanceWithSolution.problemP05(), 51d);
+    }
+
+    @Test
+    public void testP15(){
+
+        test(1_000_000, KnapsackInstanceWithSolution.problemP15(), 1458d);
+    }
+
+}

Diff for: solutions/src/main/java/org/pg4200/sol10/RandomForKnapsackOptimized.java

@@ -0,0 +1,45 @@
+package org.pg4200.sol10;
+
+import org.pg4200.les10.knapsack.KnapsackProblem;
+
+import java.util.Objects;
+import java.util.Random;
+
+public class RandomForKnapsackOptimized {
+
+
+    public static boolean[] solve(int maxIterations, KnapsackProblem problem){
+
+        if(maxIterations < 1){
+            throw new IllegalArgumentException("Invalid number of iterations");
+        }
+        Objects.requireNonNull(problem);
+
+        Random random = new Random();
+
+        final int n = problem.getSize();
+
+        boolean[] solution = new boolean[n];
+        boolean[] buffer = new boolean[n];
+
+        sample(solution, random);
+
+        for(int i=1; i<maxIterations; i++){
+            sample(buffer, random);
+
+            if(problem.evaluate(buffer) > problem.evaluate(solution)){
+                boolean[] tmp = solution;
+                solution = buffer;
+                buffer = tmp;
+            }
+        }
+
+        return solution;
+    }
+
+    private static void sample(boolean[] buffer, Random random){
+        for(int i=0; i<buffer.length; i++){
+            buffer[i] = random.nextBoolean();
+        }
+    }
+}

Diff for: solutions/src/test/java/org/pg4200/sol10/RandomForKnapsackOptimizedTest.java

@@ -0,0 +1,42 @@
+package org.pg4200.sol10;
+
+import org.junit.jupiter.api.Test;
+import org.pg4200.les10.knapsack.KnapsackInstanceWithSolution;
+import org.pg4200.les10.knapsack.RandomForKnapsack;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class RandomForKnapsackOptimizedTest {
+
+    private void test(int iterations, KnapsackInstanceWithSolution p, double optimum){
+
+        boolean[] res = RandomForKnapsackOptimized.solve(iterations, p.getProblem());
+
+        double fitness = p.getProblem().evaluate(res);
+
+        assertEquals(optimum, fitness, 0.001);
+
+        double best = p.getBestFitness();
+
+        assertEquals(best, fitness, 0.001);
+    }
+
+    /*
+        Note: here we put high enough number of iterations (compared to the size
+        of search space) that it is more likely to be hit on the head by a meteor
+        while reading this text than these tests will fail.
+     */
+
+    @Test
+    public void testP05(){
+
+        test(1000, KnapsackInstanceWithSolution.problemP05(), 51d);
+    }
+
+    @Test
+    public void testP15(){
+
+        test(1_000_000, KnapsackInstanceWithSolution.problemP15(), 1458d);
+    }
+
+}