Local search implementations simplified. Success indication now confo…

…rms to standard search interface.

aima-core/src/main/java/aima/core/search/local/HillClimbingSearch.java

@@ -37,16 +37,11 @@
  */
 public class HillClimbingSearch<S, A> implements SearchForActions<S, A>, SearchForStates<S, A>, Informed<S, A> {
 
-    public enum SearchOutcome {
-        FAILURE, SOLUTION_FOUND
-    }
-
     public static final String METRIC_NODES_EXPANDED = "nodesExpanded";
     public static final String METRIC_NODE_VALUE = "nodeValue";
 
     private ToDoubleFunction<Node<S, A>> h = null;
     private final NodeExpander<S, A> nodeExpander;
-    private SearchOutcome outcome = SearchOutcome.FAILURE;
     private S lastState = null;
     private Metrics metrics = new Metrics();
 
@@ -83,58 +78,41 @@ public Optional<S> findState(Problem<S, A> p) {
     }
 
     /**
-     * Returns a node corresponding to a local maximum or empty if the search was
-     * cancelled by the user.
+     * Returns a node corresponding to a goal state or empty. Method {@link #getLastState()}
+     * provides the local maximum if result is empty.
      *
      * @param p the search problem
      * @return a node or empty
      */
-    // function HILL-CLIMBING(problem) returns a state that is a local maximum
+    /// function HILL-CLIMBING(problem) returns a state that is a local maximum
     public Optional<Node<S, A>> findNode(Problem<S, A> p) {
         clearMetrics();
-        outcome = SearchOutcome.FAILURE;
-        // current <- MAKE-NODE(problem.INITIAL-STATE)
+        /// current <- MAKE-NODE(problem.INITIAL-STATE)
         Node<S, A> current = nodeExpander.createRootNode(p.getInitialState());
         Node<S, A> neighbor;
-        // loop do
+        /// loop do
         while (!Tasks.currIsCancelled()) {
-            lastState = current.getState();
             metrics.set(METRIC_NODE_VALUE, getValue(current));
             List<Node<S, A>> children = nodeExpander.expand(current, p);
-            // neighbor <- a highest-valued successor of current
+            /// neighbor <- a highest-valued successor of current
             neighbor = getHighestValuedNodeFrom(children);
 
-            // if neighbor.VALUE <= current.VALUE then return current.STATE
+            /// if neighbor.VALUE <= current.VALUE then return current.STATE
             if (neighbor == null || getValue(neighbor) <= getValue(current)) {
-                if (p.testSolution(current))
-                    outcome = SearchOutcome.SOLUTION_FOUND;
-                return Optional.of(current);
+                lastState = current.getState();
+                return Optional.ofNullable(p.testSolution(current) ? current : null);
             }
-            // current <- neighbor
+            /// current <- neighbor
             current = neighbor;
         }
+        lastState = current.getState();
         return Optional.empty();
     }
 
     /**
-     * Returns SOLUTION_FOUND if the local maximum is a goal state, or FAILURE
-     * if the local maximum is not a goal state.
-     *
-     * @return SOLUTION_FOUND if the local maximum is a goal state, or FAILURE
-     * if the local maximum is not a goal state.
-     */
-    public SearchOutcome getOutcome() {
-        return outcome;
-    }
-
-    /**
-     * Returns the last state from which the hill climbing search found the
-     * local maximum.
-     *
-     * @return the last state from which the hill climbing search found the
-     * local maximum.
+     * Returns the last explored state which is at least a local maximum if search was not cancelled by the user.
      */
-    public S getLastSearchState() {
+    public S getLastState() {
         return lastState;
     }
 

aima-core/src/main/java/aima/core/search/local/SimulatedAnnealingSearch.java

@@ -7,7 +7,6 @@
 
 import java.util.List;
 import java.util.Optional;
-import java.util.Random;
 import java.util.function.Consumer;
 import java.util.function.ToDoubleFunction;
 
@@ -41,19 +40,14 @@
  */
 public class SimulatedAnnealingSearch<S, A> implements SearchForActions<S, A>, SearchForStates<S, A> {
 
-	public enum SearchOutcome {
-		FAILURE, SOLUTION_FOUND
-	}
-
     public static final String METRIC_NODES_EXPANDED = "nodesExpanded";
 	public static final String METRIC_TEMPERATURE = "temp";
 	public static final String METRIC_NODE_VALUE = "nodeValue";
 
 	private final ToDoubleFunction<Node<S, A>> h;
 	private final Scheduler scheduler;
 	private final NodeExpander<S, A> nodeExpander;
-
-	private SearchOutcome outcome = SearchOutcome.FAILURE;
+
 	private S lastState;
 	private Metrics metrics = new Metrics();
 
@@ -100,69 +94,49 @@ public Optional<S> findState(Problem<S, A> p) {
 		return SearchUtils.toState(findNode(p));
 	}
 
-	// function SIMULATED-ANNEALING(problem, schedule) returns a solution state
+	/**
+	 * Returns a node corresponding to a goal state or empty. Method {@link #getLastState()}
+	 * provides the last explored state if result is empty.
+	 */
+	/// function SIMULATED-ANNEALING(problem, schedule) returns a solution state
 	public Optional<Node<S, A>> findNode(Problem<S, A> p) {
 		clearMetrics();
-		outcome = SearchOutcome.FAILURE;
-		lastState = null;
-		// current <- MAKE-NODE(problem.INITIAL-STATE)
+		/// current <- MAKE-NODE(problem.INITIAL-STATE)
 		Node<S, A> current = nodeExpander.createRootNode(p.getInitialState());
-		// for t = 1 to INFINITY do
+		/// for t = 1 to INFINITY do
 		int timeStep = 0;
 		while (!Tasks.currIsCancelled()) {
-			// temperature <- schedule(t)
+			/// temperature <- schedule(t)
 			double temperature = scheduler.getTemp(timeStep);
 			timeStep++;
 			lastState = current.getState();
-			// if temperature = 0 then return current
+			/// if temperature = 0 then return current
 			if (temperature == 0.0) {
-				if (p.testSolution(current))
-					outcome = SearchOutcome.SOLUTION_FOUND;
-				return Optional.of(current);
+				lastState = current.getState();
+				return Optional.ofNullable(p.testSolution(current) ? current : null);
 			}
 
 			updateMetrics(temperature, getValue(current));
 			List<Node<S, A>> children = nodeExpander.expand(current, p);
 			if (children.size() > 0) {
-				// next <- a randomly selected successor of current
+				/// next <- a randomly selected successor of current
 				Node<S, A> next = Util.selectRandomlyFromList(children);
-				// /\E <- next.VALUE - current.value
+				/// /\E <- next.VALUE - current.value
 				double deltaE = getValue(next) - getValue(current);
-
-				if (shouldAccept(temperature, deltaE)) {
+				/// if /\E &gt; 0 then current &lt;- next
+				/// else current &lt;- next only with probability e&circ;(/\E/T)
+				if (deltaE > 0.0 || Math.random() <= Math.exp(deltaE / temperature))
 					current = next;
-				}
 			}
 		}
+		lastState = current.getState();
 		return Optional.empty();
 	}
 
 	/**
-	 * Returns <em>e</em><sup>&delta<em>E / T</em></sup>
-	 * 
-	 * @param temperature
-	 *            <em>T</em>, a "temperature" controlling the probability of
-	 *            downward steps
-	 * @param deltaE
-	 *            VALUE[<em>next</em>] - VALUE[<em>current</em>]
-	 * @return <em>e</em><sup>&delta<em>E / T</em></sup>
+	 * Returns the last explored state.
 	 */
-	public double probabilityOfAcceptance(double temperature, double deltaE) {
-		return Math.exp(deltaE / temperature);
-	}
-
-	public SearchOutcome getOutcome() {
-		return outcome;
-	}
-
-	/**
-	 * Returns the last state from which the simulated annealing search found a
-	 * solution state.
-	 * 
-	 * @return the last state from which the simulated annealing search found a
-	 *         solution state.
-	 */
-	public Object getLastSearchState() {
+	public Object getLastState() {
 		return lastState;
 	}
 
@@ -202,13 +176,6 @@ public boolean removeNodeListener(Consumer<Node<S, A>> listener) {
 	// PRIVATE METHODS
 	//
 
-	// if /\E > 0 then current <- next
-	// else current <- next only with probability e^(/\E/T)
-	private boolean shouldAccept(double temperature, double deltaE) {
-		return (deltaE > 0.0)
-				|| (Math.random() <= probabilityOfAcceptance(temperature, deltaE));
-	}
-
 	private double getValue(Node<S, A> n) {
 		// assumption greater heuristic value =>
 		// HIGHER on hill; 0 == goal state;

aima-core/src/test/java/aima/test/core/unit/search/SearchTestSuite.java

@@ -10,7 +10,6 @@
 import aima.test.core.unit.search.informed.AStarSearchTest;
 import aima.test.core.unit.search.informed.GreedyBestFirstSearchTest;
 import aima.test.core.unit.search.informed.RecursiveBestFirstSearchTest;
-import aima.test.core.unit.search.local.SimulatedAnnealingSearchTest;
 import aima.test.core.unit.search.nondeterministic.AndOrSearchTest;
 import aima.test.core.unit.search.online.LRTAStarAgentTest;
 import aima.test.core.unit.search.online.OnlineDFSAgentTest;
@@ -21,7 +20,7 @@
 @RunWith(Suite.class)
 @Suite.SuiteClasses({ AssignmentTest.class, CSPTest.class, MapCSPTest.class, MetricsTest.class, TreeCspSolverTest.class,
 		AStarSearchTest.class, GreedyBestFirstSearchTest.class, RecursiveBestFirstSearchTest.class,
-		SimulatedAnnealingSearchTest.class, AndOrSearchTest.class, LRTAStarAgentTest.class, OnlineDFSAgentTest.class,
+		AndOrSearchTest.class, LRTAStarAgentTest.class, OnlineDFSAgentTest.class,
 		BidirectionalSearchTest.class, BreadthFirstSearchTest.class, DepthFirstSearchTest.class,
 		DepthLimitedSearchTest.class, IterativeDeepeningSearchTest.class, UniformCostSearchTest.class, NodeTest.class,
 		SolutionTesterTest.class })

aima-gui/src/main/java/aima/gui/demo/search/EightPuzzleDemo.java

@@ -119,8 +119,7 @@ private static void eightPuzzleSimulatedAnnealingDemo() {
 					(EightPuzzleFunctions::getManhattanDistance);
 			SearchAgent<Object, EightPuzzleBoard, Action> agent = new SearchAgent<>(problem, search);
 			printActions(agent.getActions());
-			System.out.println("Search Outcome=" + search.getOutcome());
-			System.out.println("Final State:\n" + search.getLastSearchState());
+			System.out.println("Final State:\n" + search.getLastState());
 			printInstrumentation(agent.getInstrumentation());
 		} catch (Exception e) {
 			e.printStackTrace();

aima-gui/src/main/java/aima/gui/demo/search/NQueensDemo.java

@@ -101,8 +101,7 @@ private static void solveNQueensWithSimulatedAnnealingSearch() {
 
 		actions.ifPresent(qActions -> qActions.forEach(System.out::println));
 		System.out.println(search.getMetrics());
-		System.out.println("Search Outcome=" + search.getOutcome());
-		System.out.println("Final State:\n" + search.getLastSearchState());
+		System.out.println("Final State:\n" + search.getLastState());
 	}
 
 	private static void solveNQueensWithHillClimbingSearch() {
@@ -116,8 +115,7 @@ private static void solveNQueensWithHillClimbingSearch() {
 
 		actions.ifPresent(qActions -> qActions.forEach(System.out::println));
 		System.out.println(search.getMetrics());
-		System.out.println("Search Outcome=" + search.getOutcome());
-		System.out.println("Final State:\n" + search.getLastSearchState());
+		System.out.println("Final State:\n" + search.getLastState());
 	}
 
 	private static void solveNQueensWithGeneticAlgorithmSearch() {

aima-gui/src/main/java/aima/gui/fx/applications/search/NQueensSearchDemo.java

@@ -105,7 +105,7 @@ public void startHillClimbingExperiment() {
 		search.addNodeListener(n -> notifyProgressTrackers(n.getState(), search.getMetrics()));
 		search.findActions(problem);
 
-		board = (NQueensBoard) ((HillClimbingSearch) search).getLastSearchState();
+		board = (NQueensBoard) ((HillClimbingSearch) search).getLastState();
 		notifyProgressTrackers(board, search.getMetrics());
 	}
 
@@ -117,7 +117,7 @@ public void startSimulatedAnnealingExperiment() {
 		search.addNodeListener(n -> notifyProgressTrackers(n.getState(), search.getMetrics()));
 		search.findActions(problem);
 
-		board = (NQueensBoard) ((SimulatedAnnealingSearch) search).getLastSearchState();
+		board = (NQueensBoard) ((SimulatedAnnealingSearch) search).getLastState();
 		notifyProgressTrackers(board, search.getMetrics());
 	}
 

aima-gui/src/main/java/aima/gui/fx/applications/search/local/SimulatedAnnealingMaximumFinderApp.java

@@ -114,7 +114,7 @@ public void startExperiment() {
 		search = new SimulatedAnnealingSearch<>(n -> 1 - func.apply(n.getState()), scheduler);
 		search.addNodeListener(n -> updateStateView(n.getState()));
 		search.findActions(problem);
-		updateStateView(search.getLastSearchState());
+		updateStateView(search.getLastState());
 	}
 
 	/** Creates a random initial state for the maximum search problem. */