def semideferred_best_first_search(start, goal, generator, priority, stack,
max_time, max_iterations, max_generations,
max_cost, max_length, debug):
state_space = StateSpace(generator, start, 1, max_generations, max_cost,
max_length)
sv = state_space.root
if sv.contained(goal): return state_space.plan(sv), state_space
queue = (FILOPriorityQueue if stack else FIFOPriorityQueue)([(None, sv)])
while not queue.empty() and (elapsed_time(state_space.start_time) <
max_time) and (state_space.iterations <
max_iterations):
cv = queue.pop()
if not cv.has_unexplored() and not cv.generate(): continue
state_space.iterations += 1
if debug is not None: debug(cv)
successors = list(cv.unexplored()) + [cv]
gv = first(lambda v: v.contained(goal), successors[:-1])
if gv is not None: return state_space.plan(gv), state_space
if stack: successors.reverse()
for i, v in enumerate(successors):
if v.generate():
queue.push(priority(v), v)
if priority(v) < priority(cv):
for dv in successors[i + 1:]:
queue.push(priority(cv), dv)
break
return None, state_space
def deferred_best_first_search(start,
goal,
generator,
priority,
stack=False,
max_time=INF,
max_iterations=INF,
max_generations=INF,
max_cost=INF,
max_length=INF,
debug=None):
state_space = StateSpace(generator, start, 1, max_generations, max_cost,
max_length)
sv = state_space.root
if sv.contained(goal):
return state_space.plan(sv), state_space
queue = (FILOPriorityQueue if stack else FIFOPriorityQueue)([(None, sv)])
while not queue.empty() and (elapsed_time(state_space.start_time) <
max_time) and (state_space.iterations <
max_iterations):
cv = queue.pop()
if not cv.generate():
continue
state_space.iterations += 1
if debug is not None:
debug(cv)
successors = list(cv.unexplored()) + [cv]
gv = first(lambda v: v.contained(goal), successors[:-1])
if gv is not None:
return state_space.plan(gv), state_space
for v in (reversed(successors) if stack else successors):
queue.push(priority(cv), v)
return None, state_space
def execute():
start_time = time()
try:
output = default_plan(initial, goal, randomize(operators))
except KeyboardInterrupt:
output = None, elapsed_time(start_time)
#make_dir(directory)
#print 'Created directory:', directory
return output
def a_star_search(start,
goal,
generator,
priority,
stack=False,
max_time=INF,
max_iterations=INF,
max_generations=INF,
max_cost=INF,
max_length=INF,
debug=None):
state_space = StateSpace(generator, start, INF, max_generations, max_cost,
max_length)
sv = state_space.root
if sv.contained(goal):
return state_space.plan(sv), state_space
if not sv.generate():
return None, state_space
queue = (FILOClassicPriorityQueue if stack else FIFOClassicPriorityQueue)([
(priority(sv), sv)
])
while not queue.empty() and (elapsed_time(state_space.start_time) <
max_time) and (state_space.iterations <
max_iterations):
cv = queue.pop()
state_space.iterations += 1
if debug is not None:
debug(cv)
if cv.contained(goal):
return state_space.plan(cv), state_space
while cv.generate():
pass # NOTE - A* is not optimal even for an admissible heuristic if you allow re-expansion of branches
if cv.h_cost is None:
break
for v in (reverse(cv.unexplored()) if stack else cv.unexplored()):
if v.generate():
queue.decrease_key(priority(v), v)
return None, state_space
def time_elapsed(self):
return elapsed_time(self.start_time)
