Several bugs fixed in State (for planning).

Author: RuedigerLunde

aima-core/src/main/java/aima/core/logic/planning/State.java

@@ -3,6 +3,7 @@
 import aima.core.logic.fol.kb.data.Literal;
 
 import java.util.ArrayList;
+import java.util.Comparator;
 import java.util.List;
 
 /**
@@ -15,6 +16,7 @@
  * in a package delivery problem might be At(Truck1 , Melbourne) ∧ At(Truck2 , Sydney).
  *
  * @author samagra
+ * @author Ruediger Lunde
  */
 public class State {
     List<Literal> fluents;
@@ -38,16 +40,20 @@ public State(String fluents) {
      * that are positive literals in the action’s effects (what we call the add list or ADD(a)):
      * RESULT(s, a) = (s − DEL(a)) ∪ ADD(a).
      *
-     * @param a The applicable action.
+     * @param action The applicable action.
      * @return The new state.
      */
-    public State result(ActionSchema a) {
-        if (this.isApplicable(a)) {
-            for (Literal fluent : a.getEffectsNegativeLiterals()) {
-                Literal tempFluent = new Literal(fluent.getAtomicSentence());
-                fluents.remove(tempFluent);
+    public State result(ActionSchema action) {
+        if (isApplicable(action)) {
+            List<Literal> result = new ArrayList<>(fluents);
+            for (Literal literal : action.getEffect()) {
+                if (literal.isNegativeLiteral())
+                    result.remove(literal.getComplementaryLiteral());
+                else if (!result.contains(literal))
+                    result.add(literal);
             }
-            fluents.addAll(a.getEffectsPositiveLiterals());
+            result.sort(Comparator.comparing(Literal::toString));
+            return new State(result);
         }
         return this;
     }
@@ -56,16 +62,12 @@ public State result(ActionSchema a) {
      * Returns the state obtained by the application of a list of applicable actions to
      * the current state. This method does not change the original state and in fact returns
      * a new state representing the changed state.
-     *
-     * @param actions
-     * @return
      */
     public State result(List<ActionSchema> actions) {
-        State resultState = new State(new ArrayList<>(this.getFluents()));
-        for (ActionSchema action : actions) {
-            resultState = resultState.result(action);
-        }
-        return resultState;
+        State state = this;
+        for (ActionSchema action : actions)
+            state = state.result(action);
+        return state;
     }
 
 
@@ -74,11 +76,20 @@ public State result(List<ActionSchema> actions) {
      * <p>
      * We say that action a is applicable in state s if the preconditions are satisfied by s.
      *
-     * @param a an action
+     * @param action an action
      * @return a boolean stating if the action is applicable.
      */
-    public boolean isApplicable(ActionSchema a) {
-        return this.getFluents().containsAll(a.getPrecondition());
+    public boolean isApplicable(ActionSchema action) {
+        boolean result = true;
+        for (Literal literal : action.getPrecondition()) {
+            if (literal.isPositiveLiteral()
+                    ? !fluents.contains(literal)
+                    : fluents.contains(literal.getComplementaryLiteral())) {
+                result = false;
+                break;
+            }
+        }
+        return result;
     }
 
     public List<Literal> getFluents() {

aima-core/src/main/java/aima/core/logic/planning/hierarchicalsearch/HierarchicalSearchAlgorithm.java

@@ -42,7 +42,7 @@ public class HierarchicalSearchAlgorithm {
      * @param problem The planning problem.
      * @return A list of actions representing the plan.
      */
-    public List<ActionSchema> heirarchicalSearch(PlanningProblem problem) {
+    public List<ActionSchema> hierarchicalSearch(PlanningProblem problem) {
         // frontier ← a FIFO queue with [Act] as the only element
         LinkedList<List<ActionSchema>> frontier = new LinkedList<>();
         frontier.add(new ArrayList<>(Collections.singletonList(PlanningProblemFactory.getHlaAct(problem))));

aima-core/src/test/java/aima/test/core/unit/logic/planning/hierarchicalsearch/HierarchicalSearchTest.java

@@ -17,7 +17,7 @@ public void hierarchicalSearchTest() {
                 "At(Home)",
                 "~At(Home)^At(SFO)");
         for (ActionSchema action :
-                algo.heirarchicalSearch(PlanningProblemFactory.goHomeToSFOProblem())) {
+                algo.hierarchicalSearch(PlanningProblemFactory.goHomeToSFOProblem())) {
             Assert.assertEquals(action, taxiAction);
         }
     }