def test_breadth_first_tree_search():
"""
Test breadth first tree search (i.e., with duplicates).
"""
for goal in range(1, 10):
p = AnnotatedProblem(EasyProblem(0, goal))
sol = next(breadth_first_search(p, graph=False))
assert sol.state_node.state == goal
assert p.nodes_expanded == pow(2, goal + 1) - 2
assert p.goal_tests == pow(2, goal)
p = AnnotatedProblem(EasyProblem(0, goal))
sol = next(
breadth_first_search(p, graph=False, forward=False, backward=True))
assert sol.state_node == sol.goal_node
assert p.nodes_expanded == pow(2, goal + 1) - 2
assert p.goal_tests == pow(2, goal)
def test_breadth_first_graph_search():
"""
Test breadth first graph search (i.e., no duplicates). For this test
problem it performs similar to breadth first.
"""
for goal in range(1, 10):
p = AnnotatedProblem(EasyProblem(0, goal))
sol = next(breadth_first_search(p, graph=True))
assert sol.state_node.state == goal
assert p.nodes_expanded == goal * 2
assert p.goal_tests == goal + 1
p = AnnotatedProblem(EasyProblem(0, goal))
sol = next(
breadth_first_search(p, graph=True, forward=False, backward=True))
assert sol.state_node == sol.goal_node
assert p.nodes_expanded == goal * 2
assert p.goal_tests == goal + 1
def test_bidirectional_tree_search():
for goal in range(1, 14):
p = AnnotatedProblem(EasyProblem(0, goal))
sol = next(
breadth_first_search(p, graph=False, forward=True, backward=True))
assert sol.state_node == sol.goal_node
if goal % 2 == 0:
assert p.nodes_expanded == 2 * (pow(2, goal / 2 + 1) - 2)
assert p.goal_tests == pow(2, goal)
else:
assert p.nodes_expanded == pow(2, goal // 2 + 2) - 2
def specialize(h,
constraints,
args,
pset,
neg,
neg_mapping,
gensym,
depth_limit=10):
"""
Returns the set of most general specializations of h that does NOT
cover x.
"""
problem = SpecializationProblem(h,
extra=(args, constraints, pset, neg,
neg_mapping, gensym))
sol_set = set()
for sol in breadth_first_search(problem, depth_limit=depth_limit):
sol_set.add(sol.state)
if len(sol_set) >= 25:
break
return sol_set
def test_solution_node():
ep = EasyProblem(0, 8)
sol1 = next(depth_first_search(ep))
assert sol1.depth() == 8
assert sol1.path() == tuple(['expand'] * 8)
assert str(sol1) == ("StateNode={State: 8, Extra: None}, "
"GoalNode={State: 8, Extra: None}")
assert repr(sol1) == "SolutionNode(Node(8), GoalNode(8))"
assert hash(sol1) == hash((8, 8))
sol2 = next(breadth_first_search(ep, forward=True, backward=True))
assert sol2.depth() == 8
print(sol2.path())
assert sol2.path() == tuple(['expand'] * 8)
assert sol2.goal_node.path() == tuple(['expand'] * 4)
assert str(sol2) == ("StateNode={State: 4, Extra: None}, "
"GoalNode={State: 4, Extra: None}")
assert repr(sol2) == "SolutionNode(Node(4), GoalNode(4))"
assert hash(sol2) == hash((4, 4))
assert sol1 == sol1
assert sol1 != sol2
def bidirectional(x):
return breadth_first_search(x, forward=True, backward=True)
def regression(x):
return breadth_first_search(x, forward=False, backward=True)
def breadth(self, x):
return breadth_first_search(x, forward=True, backward=False)
