Simplify and speed up relevance analysis and relaxation heuristics

Grounding relevance analysis:
- Test whether an operator has a relevant effect with set.isdisjoint
  instead of building the throwaway union (add | del) and its
  intersection with the relevant facts on every operator and round.
- Detect the fixpoint by comparing the size of the relevant-fact set
  before and after each pass (the set only grows) instead of copying the
  whole set each round to compare it.

Relaxation heuristics (evaluated once per generated node):
- Use the node's state set directly instead of copying it; it is only
  read, never mutated.
- Pass generators to the sum/max evaluator instead of materializing
  intermediate lists of precondition/goal distances.

All changes preserve behavior (identical grounded operators and plans;
full test suite still passes).

Author: jendrikseipp

pyperplan/grounding.py

@@ -112,13 +112,20 @@ def _relevance_analysis(operators, goals):
     are removed, and operators left without any effect are pruned entirely.
     """
     relevant_facts = set(goals)
-    changed = True
-    while changed:
-        old_relevant_facts = relevant_facts.copy()
+    # Iterate to a fixpoint: an operator with a relevant effect makes its
+    # preconditions relevant too. relevant_facts only grows, so a pass that adds
+    # nothing means we have reached the fixpoint.
+    while True:
+        size_before = len(relevant_facts)
         for op in operators:
-            if (op.add_effects | op.del_effects) & relevant_facts:
+            has_relevant_effect = not (
+                relevant_facts.isdisjoint(op.add_effects)
+                and relevant_facts.isdisjoint(op.del_effects)
+            )
+            if has_relevant_effect:
                 relevant_facts |= op.preconditions
-        changed = old_relevant_facts != relevant_facts
+        if len(relevant_facts) == size_before:
+            break
 
     relevant_operators = []
     for op in operators:

pyperplan/heuristics/relaxation.py

@@ -111,7 +111,7 @@ def __init__(self, task):
 
     def __call__(self, node):
         """Compute the heuristic value for the state stored in ``node``."""
-        state = set(node.state)
+        state = node.state
 
         # Reset distance and set to default values.
         self.init_distance(state)
@@ -169,9 +169,7 @@ def get_cost(self, operator, pre):
         """
         if operator.preconditions:
             # Sum / maximize over the heuristic values of all preconditions.
-            cost = self.eval(
-                [self.facts[pre].distance for pre in operator.preconditions]
-            )
+            cost = self.eval(self.facts[pre].distance for pre in operator.preconditions)
         else:
             # An operator without preconditions has cost 0.
             cost = 0
@@ -187,7 +185,7 @@ def calc_goal_h(self):
         hSA and hFF. Returns 0 if the goal is empty.
         """
         if self.goals:
-            return self.eval([self.facts[fact].distance for fact in self.goals])
+            return self.eval(self.facts[fact].distance for fact in self.goals)
         else:
             return 0
 
@@ -328,7 +326,7 @@ def __init__(self, task):
 
     def calc_h_with_plan(self, node):
         """Calculate the hFF value together with a relaxed plan."""
-        state = set(node.state)
+        state = node.state
         # Reset distance and set to default values.
         self.init_distance(state)