def setUp(self):
self.p = have_cake()
self.pg = PlanningGraph(self.p, self.p.initial)
# some independent nodes for testing mutex
self.na1 = PgNode_a(
Action(expr('Go(here)'), [[], []], [[expr('At(here)')], []]))
self.na2 = PgNode_a(
Action(expr('Go(there)'), [[], []], [[expr('At(there)')], []]))
self.na3 = PgNode_a(
Action(expr('Noop(At(there))'), [[expr('At(there)')], []],
[[expr('At(there)')], []]))
self.na4 = PgNode_a(
Action(expr('Noop(At(here))'), [[expr('At(here)')], []],
[[expr('At(here)')], []]))
self.na5 = PgNode_a(
Action(expr('Reverse(At(here))'), [[expr('At(here)')], []],
[[], [expr('At(here)')]]))
self.ns1 = PgNode_s(expr('At(here)'), True)
self.ns2 = PgNode_s(expr('At(there)'), True)
self.ns3 = PgNode_s(expr('At(here)'), False)
self.ns4 = PgNode_s(expr('At(there)'), False)
self.na1.children.add(self.ns1)
self.ns1.parents.add(self.na1)
self.na2.children.add(self.ns2)
self.ns2.parents.add(self.na2)
self.na1.parents.add(self.ns3)
self.na2.parents.add(self.ns4)
def setUp(self):
self.cake_problem = have_cake()
self.ac_problem_1 = air_cargo_p1()
self.ac_problem_2 = air_cargo_p2()
self.ac_problem_3 = air_cargo_p3()
self.ac_problem_4 = air_cargo_p4()
self.cake_node = Node(self.cake_problem.initial)
self.ac_node_1 = Node(self.ac_problem_1.initial)
self.ac_node_2 = Node(self.ac_problem_2.initial)
self.ac_node_3 = Node(self.ac_problem_3.initial)
self.ac_node_4 = Node(self.ac_problem_4.initial)
def test_add_action_level(self):
p = have_cake()
for a in p.actions_list:
print(' {}{}'.format(a.name, a.args))
print("Fluents in this problem are:")
for f in p.state_map:
print(' {}'.format(f))
print("Goal requirement for this problem are:")
for g in p.goal:
print(' {}'.format(g))
run_search(p, breadth_first_search)
def setUp(self):
self.cake_problem = have_cake()
self.ac_problem_1 = air_cargo_p1()
self.ac_problem_2 = air_cargo_p2()
self.ac_problem_3 = air_cargo_p3()
self.ac_problem_4 = air_cargo_p4()
self.cake_node = Node(self.cake_problem.initial)
self.ac_node_1 = Node(self.ac_problem_1.initial)
self.ac_node_2 = Node(self.ac_problem_2.initial)
self.ac_node_3 = Node(self.ac_problem_3.initial)
self.ac_node_4 = Node(self.ac_problem_4.initial)
self.msg = "Make sure all your mutex tests pass before troubleshooting this function."
def setUp(self):
self.cake_problem = have_cake()
self.cake_pg = PlanningGraph(self.cake_problem,
self.cake_problem.initial,
serialize=False).fill()
self.eat_action, self.bake_action = [
a for a in self.cake_pg._actionNodes if not a.no_op
]
no_ops = [a for a in self.cake_pg._actionNodes if a.no_op]
self.null_action = make_node(
Action(expr('Null()'), [set(), set()], [set(), set()]))
# some independent nodes for testing mutexes
at_here = expr('At(here)')
at_there = expr('At(there)')
self.pos_literals = [at_here, at_there]
self.neg_literals = [~x for x in self.pos_literals]
self.literal_layer = LiteralLayer(
self.pos_literals + self.neg_literals, ActionLayer())
self.literal_layer.update_mutexes()
# independent actions for testing mutex
self.actions = [
make_node(
Action(expr('Go(here)'), [set(), set()],
[set([at_here]), set()])),
make_node(
Action(expr('Go(there)'), [set(), set()],
[set([at_there]), set()]))
]
self.no_ops = [
make_node(x)
for x in chain(*(makeNoOp(l) for l in self.pos_literals))
]
self.action_layer = ActionLayer(self.no_ops + self.actions,
self.literal_layer)
self.action_layer.update_mutexes()
for action in self.no_ops + self.actions:
self.action_layer.add_inbound_edges(action, action.preconditions)
self.action_layer.add_outbound_edges(action, action.effects)
def setUp(self):
self.p = have_cake()
self.pg = PlanningGraph(self.p, self.p.initial)
# some independent nodes for testing mutex
self.na1 = PgNode_a(Action(expr('Go(here)'),
[[], []], [[expr('At(here)')], []]))
self.na2 = PgNode_a(Action(expr('Go(there)'),
[[], []], [[expr('At(there)')], []]))
self.na3 = PgNode_a(Action(expr('Noop(At(there))'),
[[expr('At(there)')], []], [[expr('At(there)')], []]))
self.na4 = PgNode_a(Action(expr('Noop(At(here))'),
[[expr('At(here)')], []], [[expr('At(here)')], []]))
self.na5 = PgNode_a(Action(expr('Reverse(At(here))'),
[[expr('At(here)')], []], [[], [expr('At(here)')]]))
self.ns1 = PgNode_s(expr('At(here)'), True)
self.ns2 = PgNode_s(expr('At(there)'), True)
self.ns3 = PgNode_s(expr('At(here)'), False)
self.ns4 = PgNode_s(expr('At(there)'), False)
self.na1.children.add(self.ns1)
self.ns1.parents.add(self.na1)
self.na2.children.add(self.ns2)
self.ns2.parents.add(self.na2)
self.na1.parents.add(self.ns3)
self.na2.parents.add(self.ns4)
def setUp(self):
self.cake_problem = have_cake()
self.cake_pg = PlanningGraph(self.cake_problem,
self.cake_problem.initial,
serialize=False).fill()
eat_action, bake_action = [
a for a in self.cake_pg._actionNodes if not a.no_op
]
no_ops = [a for a in self.cake_pg._actionNodes if a.no_op]
# bake has the effect Have(Cake) which is the logical negation of the effect
# ~Have(cake) from the persistence action ~NoOp::Have(cake)
self.inconsistent_effects_actions = [bake_action, no_ops[3]]
# the persistence action ~NoOp::Have(cake) has the effect ~Have(cake), which is
# the logical negation of Have(cake) -- the precondition for the Eat(cake) action
self.interference_actions = [eat_action, no_ops[3]]
# eat has precondition Have(cake) and bake has precondition ~Have(cake)
# which are logical inverses, so eat & bake should be mutex at every
# level of the planning graph where both actions appear
self.competing_needs_actions = [eat_action, bake_action]
self.ac_problem = air_cargo_p1()
self.ac_pg_serial = PlanningGraph(self.ac_problem,
self.ac_problem.initial).fill()
# In(C1, P2) and In(C2, P1) have inconsistent support when they first appear in
# the air cargo problem,
self.inconsistent_support_literals = [
expr("In(C1, P2)"), expr("In(C2, P1)")
]
# some independent nodes for testing mutexes
at_here = expr('At(here)')
at_there = expr('At(there)')
self.pos_literals = [at_here, at_there]
self.neg_literals = [~x for x in self.pos_literals]
self.literal_layer = LiteralLayer(
self.pos_literals + self.neg_literals, ActionLayer())
self.literal_layer.update_mutexes()
# independent actions for testing mutex
self.actions = [
make_node(
Action(expr('Go(here)'), [set(), set()],
[set([at_here]), set()])),
make_node(
Action(expr('Go(there)'), [set(), set()],
[set([at_there]), set()]))
]
self.no_ops = [
make_node(x)
for x in chain(*(makeNoOp(l) for l in self.pos_literals))
]
self.action_layer = ActionLayer(self.no_ops + self.actions,
self.literal_layer)
self.action_layer.update_mutexes()
for action in self.no_ops + self.actions:
self.action_layer.add_inbound_edges(action, action.preconditions)
self.action_layer.add_outbound_edges(action, action.effects)
# competing needs tests -- build two copies of the planning graph: one where
# A, B, and C are pairwise mutex, and another where they are not
A, B, C = expr('A'), expr('B'), expr('C')
self.fake_competing_needs_actions = [
make_node(
Action(expr('FakeAction(A)'), [set([A]), set()],
[set([A]), set()])),
make_node(
Action(expr('FakeAction(B)'), [set([B]), set()],
[set([B]), set()])),
make_node(
Action(expr('FakeAction(C)'), [set([C]), set()],
[set([C]), set()]))
]
competing_layer = LiteralLayer([A, B, C], ActionLayer())
for a1, a2 in combinations([A, B, C], 2):
competing_layer.set_mutex(a1, a2)
self.competing_action_layer = ActionLayer(competing_layer.parent_layer,
competing_layer, False, True)
for action in self.fake_competing_needs_actions:
self.competing_action_layer.add(action)
competing_layer |= action.effects
competing_layer.add_outbound_edges(action, action.preconditions)
self.competing_action_layer.add_inbound_edges(
action, action.preconditions)
self.competing_action_layer.add_outbound_edges(
action, action.effects)
not_competing_layer = LiteralLayer([A, B, C], ActionLayer())
self.not_competing_action_layer = ActionLayer(
not_competing_layer.parent_layer, not_competing_layer, False, True)
for action in self.fake_competing_needs_actions:
self.not_competing_action_layer.add(action)
not_competing_layer |= action.effects
not_competing_layer.add_outbound_edges(action,
action.preconditions)
self.not_competing_action_layer.add_inbound_edges(
action, action.preconditions)
self.not_competing_action_layer.add_outbound_edges(
action, action.effects)
def setUp(self):
#print("in GH setup")
self.p = have_cake()
self.pg = PlanningGraph(self.p, self.p.initial)
from example_have_cake import have_cake
from my_planning_graph import PlanningGraph
if __name__ == '__main__':
p = have_cake()
graph = PlanningGraph(p, p.initial)
def setUp(self):
self.p = have_cake()
self.pg = PlanningGraph(self.p, self.p.initial)
print("Setup is good")
if not pa1.is_mutex(pa2):
return False
return True
def h_levelsum(self) -> int:
"""The sum of the level costs of the individual goals (admissible if goals independent)
:return: int
"""
level_sum = 0
# for each goal in the problem, determine the level cost, then add them together
for goal in self.problem.goal:
found = False # indicate that the goal was found
for l, sl in enumerate(self.s_levels):
for s in sl:
if goal == s.symbol and s.is_pos:
level_sum += l
found = True
break
if found:
break
return level_sum
if __name__ == '__main__':
from example_have_cake import have_cake
pc = have_cake()
pg = PlanningGraph(pc, pc.initial)
def setUp(self):
# print("\n===================== TestPlanningGraphHeuristics.....test_inconsistent_support_mutex")
self.p = have_cake()
self.pg = PlanningGraph(self.p, self.p.initial)
def setUp(self):
# print("\n===================== TestPlanningGraphLevels.....setUp")
self.p = have_cake()
self.pg = PlanningGraph(self.p, self.p.initial)
def setUp(self):
self.p = have_cake()
self.pg = PlanningGraph(self.p, self.p.initial)
def setUp(self):
#import pdb;pdb.set_trace()
self.p = have_cake()
self.pg = PlanningGraph(self.p, self.p.initial)
def setUp(self):
self.p = have_cake()
self.pg = PlanningGraph(self.p, self.p.initial)
def setUp(self):
self.p = have_cake() #Run have_cake constructor function to create new instance of have cake problem
self.pg = PlanningGraph(self.p, self.p.initial) #Create planning graph based on have cake problem passing
