def __construction(self):
# la lista RLC contiene los k mejores candidatos
# la otra lista contiene el resto de las arista que no pertenecen al camino ni a la RLC
RCL = []
visited = initialize_array(self.cities_count())
other_edges = PriorityQueue()
for i in range(0, len(self.coordinates) - 1):
for j in range(i + 1, len(self.coordinates)):
x, y = self.coordinates[i], self.coordinates[j]
distance = euclidean_distance(x, y)
other_edges.push((x, y), distance)
for i in range(0, self.RCL_lenght):
if other_edges.isEmpty():
break
RCL.append(other_edges.pop())
tour = {}
edges = 0
while edges != self.cities_count() - 1:
r = int(round(random.uniform(0, len(RCL) - 1)))
(city1, city2) = RCL[r]
if visited[self.mapped_cities[city1]] < 2 and visited[
self.mapped_cities[city2]] < 2:
if not city1 in tour:
tour[city1] = []
if not city2 in tour:
tour[city2] = []
tour[city1].append(city2)
tour[city2].append(city1)
if not self.__DFS(tour):
edges += 1
visited[self.mapped_cities[city1]] += 1
visited[self.mapped_cities[city2]] += 1
else:
tour[city1].remove(city2)
tour[city2].remove(city1)
# ya sea porque la arista se agrego al tour o porque la ciudad ya estaba visitada, removerla de la lista de candidatos y agregar otro elemento
RCL.remove((city1, city2))
if not other_edges.isEmpty():
RCL.append(other_edges.pop())
result = []
for i in range(0, len(visited)):
if visited[i] == 1:
result = self.sort_tour(tour, current=self.mapped_cities[i])
break
return result
def breadth_first(self, xy1, xy2):
"""Execute a breadth first search"""
tile_col1, tile_row1 = self.the_map.xy_to_cr(xy1[0], xy1[1])
tile_col2, tile_row2 = self.the_map.xy_to_cr(xy2[0], xy2[1])
successor_to_parent_map = {}
start_state = (tile_col1, tile_row1)
successor_to_parent_map[(
start_state,
None)] = None # (Successor, Action) -> (Parent, Action)
open_list = PriorityQueue()
open_list.update((start_state, None), 0)
closed = []
while not open_list.isEmpty():
current_state, action_to_current_state = open_list.pop()
if current_state == (tile_col2, tile_row2):
return self.__get_action_path(
(current_state, action_to_current_state),
successor_to_parent_map)
if current_state not in closed:
for successor_state, action, step_cost in self.__get_successors(
current_state):
open_list.update((successor_state, action), 0)
if successor_state not in closed:
successor_to_parent_map[(successor_state, action)] = (
current_state, action_to_current_state)
closed.append(current_state)
return []
def least_constraining_value(var, assignment, csp):
"""
Implements Least Constraining Value Heuristic (LCV), which order the domain
values in the order in which they rule out the fewest values in the remaining
variables
"""
variables = csp.unassigned_variables()
variables.remove(var)
for X in assignment:
if X in variables:
variables.remove(X)
minpq = PriorityQueue()
for val in csp.domain(var):
csp.assign_variable(var, val)
values_ruled_out = 0
for X in variables:
for v in csp.domain(X):
csp.assign_variable(X, v)
if not csp.check_consistency():
values_ruled_out += 1
csp.assign_variable(X, None)
csp.assign_variable(var, None)
minpq.push(val, values_ruled_out)
domain_ordered = []
while not minpq.isEmpty():
domain_ordered.append(minpq.pop())
return domain_ordered
def aStarSearch(pos, goal):
fringe, visited, best = PriorityQueue(), set(), {}
fringe.push((pos, [], 0), manhattanDistance(pos, goal))
while not fringe.isEmpty():
current_point, actions, total_cost = fringe.pop()
if current_point in visited or \
(current_point in best and best[current_point] <= total_cost):
continue
visited.add(current_point)
best[current_point] = total_cost
# current vertex is a solution
if current_point == goal:
return actions
for (point, action) in getSuccessors(current_point):
# if node not visited add it to the fringe
if point not in visited:
actions_copy = list(actions)
actions_copy.append(action)
cost = total_cost + 1
fringe.push((point, actions_copy, cost), \
cost + manhattanDistance(point, goal))
raise Exception('Problem Not Solved')
def uc_search(self, initial_state):
""" Uniform-Cost Search.
It returns the path as a list of directions among
{ Direction.left, Direction.right, Direction.up, Direction.down }
"""
# use a priority queue with the minimum queue.
from utils import PriorityQueue
open_list = PriorityQueue()
open_list.push([(initial_state, None)], 0)
closed_list = set([initial_state]) # keep already explored positions
while not open_list.isEmpty():
# Get the path at the top of the queue
current_path, cost = open_list.pop()
# Get the last place of that path
current_state, current_direction = current_path[-1]
#print("current_state -> ", current_state._position, " direction -> ", current_state._direction, " cost -> ", cost)
# Check if we have reached the goal
if current_state.is_goal_state():
return (list(map(lambda x: x[1], current_path[1:])))
else:
# Check were we can go from here
next_steps = current_state.get_successor_states()
# Add the new paths (one step longer) to the queue
for state, direction, weight in next_steps:
# Avoid loop!
if state not in closed_list:
closed_list.add(state)
open_list.push((current_path + [(state, direction)]),
cost + weight)
return []
def optimum_policy2D(grid, init, goal, cost):
Nr = len(grid)
Nc = len(grid[0])
inf = 999
policy2D = [[' ' for j in range(Nc)] for i in range(Nr)]
value2D = [[inf for j in range(Nc)] for i in range(Nr)]
value3D = [[[inf for j in range(Nc)] for i in range(Nr)] for o in range(4)]
policy3D = [[[' ' for j in range(Nc)] for i in range(Nr)]
for o in range(4)]
visited = []
frontier = PriorityQueue()
cumcost = 0
frontier.push([init, ' ', cumcost],
cumcost + heuristic_fun(init[0:2], goal))
while not frontier.isEmpty():
loc, move_name, cumcost = frontier.pop()
if not loc in visited:
visited.append(loc)
value3D[loc[2]][loc[0]][loc[1]] = cumcost
policy3D[loc[2]][loc[0]][loc[1]] = move_name
if loc[0:2] == goal:
# print 'Value:'
# for row in value:
# print '---'
# for i in row:
# print i
# print 'Policy:'
# for row in policy3D:
# print '---'
# for i in row:
# print i
# return policy2D
policy2D[goal[0]][goal[1]] = '*'
value2D[goal[0]][goal[1]] = value3D[loc[2]][goal[0]][goal[1]]
while loc[0:2] != init[0:2]:
loc, loc_move = reverse_move(
loc, policy3D[loc[2]][loc[0]][loc[1]])
policy2D[loc[0]][loc[1]] = loc_move
value2D[loc[0]][loc[1]] = value3D[loc[2]][loc[0]][loc[1]]
print('Value')
for i in value2D:
print(i)
return policy2D
for nextloc, move_name, move_cost in childNode(
grid, loc, forward, forward_name):
if not nextloc in visited:
nextcumcost = cumcost + move_cost
frontier.push([nextloc, move_name, nextcumcost],
nextcumcost +
heuristic_fun(nextloc[0:2], goal))
return 'fail'
def aStarSearch(task, heuristic, useHelpfulAction=False, noDel=False):
extendedPathsCount = 0
root = SearchNode(task.initial_state, None, None, 0)
open_set = PriorityQueue()
open_set.push(root, 0)
state_cost = {task.initial_state: 0}
while not open_set.isEmpty():
pop_node = open_set.pop()
pop_state = pop_node.state
# Extend only if the cost of the node is the cheapest found so far.
# Otherwise ignore, since we've found a better one.
if state_cost[pop_state] == pop_node.cost:
extendedPathsCount += 1
if task.goal_reached(pop_state):
print "Finished searching. Found a solution. "
return (extendedPathsCount, pop_node.cost, pop_node.path(),
pop_state)
relaxedPlan = None
if useHelpfulAction:
relaxedPlan = heuristic.getRelaxedPlan(
SearchNode(pop_state, None, None, 0))
for op, succ_state in task.get_successor_states(pop_state, noDel):
# If we're using helpful actions, ignore op that is not in the helpful actions
if useHelpfulAction:
if relaxedPlan and not op.name in relaxedPlan:
#print str(op.name) + " not in " + str(relaxedPlan)
continue
# Assume each action (operation) has cost of one
succ_node = SearchNode(succ_state, pop_node, op, 1)
h = heuristic(succ_node)
#print "\nHeuristic values for " + ', '.join(map(format_string, succ_node.state)) + " is " + str(h)
if h == float('inf'):
# Don't bother with states that can't reach the goal anyway
continue
old_succ_cost = state_cost.get(succ_state, float("inf"))
if succ_node.cost < old_succ_cost:
# Found a cheaper state or never saw this state before
open_set.push(succ_node, succ_node.cost + h)
state_cost[succ_state] = succ_node.cost
print "No more operations left. Cannot solve the task"
# (extendedPathsCount, cost, path, final_state)
return (extendedPathsCount, None, None, None)
def aStarSearch(problem, heuristic=manhattanHeuristic):
"""Search the node that has the lowest combined cost and heuristic first."""
priority_q = PriorityQueue()
visited = []
node = {}
root = problem.getStartState()
node["parent"] = None
node["action"] = None
node["goal"] = 0
node["heuristic"] = heuristic(root, problem)
node["state"] = root
priority_q.push(node, node["goal"] + node["heuristic"]) #push root
while (not priority_q.isEmpty()):
node = priority_q.pop()
state = node["state"]
if (problem.isGoalState(state)):
break
if (state in visited):
continue
visited.append(state)
children = problem.getSuccessors(state)
if (children):
for i in range(len(children)):
if (children[i][0] not in visited):
sub_node = {}
sub_node["parent"] = node
sub_node["action"] = children[i][1]
sub_node["state"] = children[i][0]
sub_node["goal"] = children[i][2] + node["goal"]
sub_node["heuristic"] = heuristic(sub_node["state"],
problem)
priority_q.push(sub_node,
sub_node["goal"] + sub_node["heuristic"])
path = []
while (node["action"] != None):
path.insert(0, node["action"])
node = node["parent"]
return path
def astarSearch(problem, heuristic = 'eqn'):
print bcolors.HEADER + "\n>> Running A* Search" + bcolors.ENDC
startState = problem.getStartState()
goalState = problem.getGoalState()
[T, r, Z] = problem.getTransform()
listOfPredicates = problem.listOfPredicates
goalCompliantConditions = problem.goalCompliantConditions
fval = float(heuristic(startState, problem))
print bcolors.OKGREEN + "--> Initial heuristic estimate = " + bcolors.OKBLUE + str(fval) + bcolors.ENDC
fringe = PriorityQueue()
closed = []
numberOfStatesExpanded = 0
printloop = 0
fringe.push([startState, [], 0.0], fval)
while not fringe.isEmpty():
printloop += 1
if printloop == 300:
printloop = 0
print bcolors.OKGREEN + "--> Number of states expanded > " + str(numberOfStatesExpanded) + bcolors.ENDC
node = fringe.pop()
if problem.isGoalState(node[0]):
print bcolors.OKGREEN + "--> Goal Found. Final number of states expanded = " + bcolors.OKBLUE + str(numberOfStatesExpanded) + bcolors.ENDC
return node
numberOfStatesExpanded += 1
successor_list = []
if node[0] not in closed:
closed.append(node[0])
successor_list = problem.getSuccessors(node)
while len(successor_list) > 0:
put = successor_list.pop()
if put[0] not in closed:
hval = heuristic(put[0], problem)
if hval != -1:
newnode = copy.deepcopy(node)
newnode[0] = put[0]
newnode[1] = newnode[1] + [put[1]]
newnode[2] = put[2] + hval
fringe.push(newnode,newnode[2])
print bcolors.OKGREEN + "--> Search Terminated. Final number of states expanded = " + bcolors.OKBLUE + str(numberOfStatesExpanded) + bcolors.ENDC
return None
def UCS(self, s):
pq = PriorityQueue()
visited = []
visited.append(s)
for v, w in self.graph[s]:
pq.update(item=v, priority=w)
while not pq.isEmpty():
(pri,it) = pq.pop()
visited.append(it)
for v,w in self.graph[it]:
if v not in visited:
pq.update(item=v, priority=w+pri)
print(visited)
def a_star(self, xy1, xy2):
"""Search the node that has the lowest combined cost and heuristic first."""
tile_col1, tile_row1 = self.the_map.xy_to_cr(xy1[0], xy1[1])
tile_col2, tile_row2 = self.the_map.xy_to_cr(xy2[0], xy2[1])
successor_to_parent_map = {}
start_state = (tile_col1, tile_row1)
#print('x=%d, y=%d to col=%d, row=%d (map row=%d, col= %d)' % (xy1[0], xy1[1], tile_col1, tile_row1,
# self.the_map.tile_speeds.shape[0], self.the_map.tile_speeds.shape[1]))
successor_to_parent_map[(
start_state,
None)] = None # (Successor, Action) -> (Parent, Action)
open_list = PriorityQueue()
open_list.update((start_state, None), 0)
closed = []
while not open_list.isEmpty():
current_state, action_to_current_state = open_list.pop()
if current_state == (tile_col2, tile_row2):
return self.__get_action_path(
(current_state, action_to_current_state),
successor_to_parent_map)
if current_state not in closed:
if current_state == start_state:
current_cost = 0
else:
current_cost = len(
self.__get_action_path(
(current_state, action_to_current_state),
successor_to_parent_map))
for successor_state, action, step_cost in self.__get_successors(
current_state):
cost = current_cost + step_cost + self.__cartesian_distance(
current_state, successor_state)
open_list.update((successor_state, action), cost)
if successor_state not in closed:
successor_to_parent_map[(successor_state, action)] = (
current_state, action_to_current_state)
closed.append(current_state)
return []
def aStarSearch(self, heuristicName = 'equality'):
method = getattr(self, 'heuristic_' + heuristicName)
print bcolors.HEADER + "\n>> Running A* Search" + bcolors.ENDC
startState = self.getStartState()
goalState = self.getGoalState()
[T, r, Z] = self.getTransform()
listOfPredicates = self.listOfPredicates
goalCompliantConditions = self.goalCompliantConditions
fval = float(method(startState))
print bcolors.OKGREEN + "--> Initial heuristic estimate = " + bcolors.OKBLUE + str(fval) + bcolors.ENDC
fringe = PriorityQueue()
closed = []
numberOfStatesExpanded = 0
printloop = 0
fringe.push([startState, [], 0.0], fval)
while not fringe.isEmpty():
if numberOfStatesExpanded%100 == 0: print bcolors.OKGREEN + "--> Number of states expanded > " + str(numberOfStatesExpanded) + bcolors.ENDC
node = fringe.pop()
if self.isGoalState(node[0]):
print bcolors.OKGREEN + "--> Goal Found. Final number of states expanded = " + bcolors.OKBLUE + str(numberOfStatesExpanded) + bcolors.ENDC
return [node[1], node[2]]
numberOfStatesExpanded += 1
successor_list = []
if node[0] not in closed:
closed.append(node[0])
successor_list = self.getSuccessors(node)
while len(successor_list) > 0:
put = successor_list.pop()
if put[0] not in closed:
hval = float(method(put[0]))
if hval != -1:
newnode = [put[0], node[1] + [put[1]], put[2] + hval]
fringe.push(newnode, newnode[2])
print bcolors.OKGREEN + "--> Search Terminated. Final number of states expanded = " + bcolors.OKBLUE + str(numberOfStatesExpanded) + bcolors.ENDC
return None
def aStarSearch(problem, heuristic=nullHeuristic):
"""Search the node that has the lowest combined cost and heuristic first."""
def frontier_last_states(frontier):
states = [path[2][-1][0] for path in frontier.heap]
return states
def path_cost(path):
last_state = path[-1][0]
cost = sum([cost for _, _, cost in path])
hcost = heuristic(last_state, problem)
return cost + hcost
frontier = PriorityQueue()
start_path = [(problem.initial_state(), 'START', 0.0)]
frontier.push(start_path, path_cost(start_path))
explored = set()
limit = 50000
while limit > 0:
if frontier.isEmpty():
return []
path = frontier.pop()
end_step = path[-1]
end_state = end_step[0]
explored.add(end_state.immutable())
if problem.goal_test(end_state):
return [action for _, action, _ in path[1:]], True, (len(explored),
len(frontier))
successors = problem.successors(end_state)
for successor in successors:
last_state = successor[0]
if (last_state not in frontier_last_states(frontier)
and last_state.immutable()
not in explored) or problem.goal_test(last_state):
extended_path = path.copy()
extended_path.append(successor)
frontier.push(extended_path, path_cost(extended_path))
else:
pass
limit -= 1
return [action for _, action, _ in frontier.pop()[1:]
], False, (len(explored), len(frontier))
def search(grid, init, goal, cost):
# ----------------------------------------
# insert code here
# ----------------------------------------
Nr = len(grid)
Nc = len(grid[0])
expand = [[-1 for j in range(Nc)] for i in range(Nr)]
count = 0
def childNode(grid, loc, delta, delta_name):
child = []
for i in range(len(delta)):
move = delta[i]
newloc = [loc[0] + move[0], loc[1] + move[1]]
if loc[0]+move[0]>=0 and loc[0]+move[0]<Nr \
and loc[1]+move[1]>=0 and loc[1]+move[1]<Nc \
and grid[newloc[0]][newloc[1]] ==0:
child.append([newloc, delta_name[i]])
return child
visited = []
frontier = PriorityQueue()
gv = 0 + heuristic_fun(init, goal)
frontier.push([init, 0], gv)
while not frontier.isEmpty():
loc, rlen = frontier.pop()
if not loc in visited:
visited.append(loc)
expand[loc[0]][loc[1]] = count
count += 1
if loc == goal:
return expand
for nextloc, move_name in childNode(grid, loc, delta, delta_name):
if not nextloc in visited:
gv = rlen + heuristic_fun(nextloc, goal)
frontier.push([nextloc, rlen + cost], gv)
return 'fail'
def branch_n_price(n, demands, capacity, distances, MasterProb):
queue = PriorityQueue()
MasterProb.RelaxOptimize()
obj_val = MasterProb.relax_modelo.ObjVal
queue.insert(obj_val, MasterProb)
best_int_obj = 1e3
best_relax_obj = 1e3
nodes_explored = 0
best_model = None
while not queue.isEmpty():
obj_val, MP_branch = queue.delete()
nodes_explored += 1
MP_branch.RelaxOptimize()
solution = MP_branch.getSolution()
duals = MP_branch.getDuals()
branch_cost = MP_branch.getCosts()
branch_routes = MP_branch.modelo.getA().toarray()
sol_is_int = all([float(round(s, 4)).is_integer() for s in solution])
# sol_is_int = all([False if i > 0.3 and np.abs(i - 1.0) > 0.3 else True for i in solution ])
if obj_val < best_int_obj and sol_is_int:
print(f"Best Integer Obj: {obj_val}")
print(f"Nodes explored: {nodes_explored}")
best_int_obj = obj_val
# print(f"best sol: {solution}")
best_model = copy_model(branch_cost, branch_routes, MP_branch)
if obj_val < best_relax_obj:
print(f"Best Relaxed Obj: {obj_val}")
print(f"Nodes explored: {nodes_explored}")
best_relax_obj = obj_val
# --- # --- # Column generation # --- # --- #
new_MP = column_generation(n, demands, capacity, distances, duals,
MP_branch)
if new_MP != None:
new_MP.RelaxOptimize()
branch_cost = new_MP.getCosts()
branch_routes = new_MP.modelo.getA().toarray()
if new_MP.relax_modelo.ObjVal <= best_relax_obj:
queue.insert(new_MP.relax_modelo.ObjVal,
copy_model(branch_cost, branch_routes, new_MP))
else:
# --- # If stopped col generation then branch if solution is not integer # --- #
if not sol_is_int:
# print("#--#--#--# Not integer solution ........Branching")
queue = branch(branch_cost, branch_routes, n, demands,
capacity, distances, duals, solution, MP_branch,
queue, best_relax_obj)
else:
# print(f"best sol: {solution}")
best_model = MP_branch
return best_model
def dijkstra_transect(data, s, t):
""" Calculate the optimal transect using Dijkstra's algorithm
Parameters
----------
data: array_like
data image to run Dijkstra on
s: tuple
start coordinate (row, col) corresponding to glacier head
t: tuple
terminal coordinate (row, col) corresponding to glacier terminus
Returns
-------
transect: array_like
Recovered array with list of row and column for each point in transect
vis: array_like
Image where each pixel stores the order that it was visited at when the
algorithm was run
"""
nrow, ncol = data.shape
x = np.arange(0, ncol)
y = np.arange(0, nrow)
coords = np.reshape(list(itertools.product(y, x)), (nrow, ncol, 2))
# min cumulative velocity from s to given pixel
dist = np.full((nrow, ncol), np.inf)
# backtracking info at each pixel back to s
back = np.full((nrow, ncol, 2), np.nan)
# priority queue for storing discovered paths
pq = PriorityQueue()
# order of nodes visited
vis = np.full((nrow, ncol), np.nan)
# Add source to pq
dist[s[0], s[1]] = data[s[0], s[1]]
pq.push(s, data[s[0], s[1]])
i = 0
# Keep going until terminus found
while np.isinf(dist[t[0], t[1]]) and not pq.isEmpty():
# Expand next shortest path
ui, uj = pq.pop()
for v in get_neighbors(ui, uj, coords):
# Found shorter path to v
vi, vj = v
vis[vi, vj] = int(i / 1e5)
i += 1
if vi == ui and vj == uj:
continue
if dist[vi, vj] > dist[ui, uj] + data[vi, vj]:
# Update distance of v
dist[vi, vj] = dist[ui, uj] + data[vi, vj]
# Update backtrack pointer from v to u
back[vi, vj] = [ui, uj]
# Insert v into pq
pq.push(coords[vi, vj], dist[vi, vj])
# backtrack path
return recover_transect(back, s, t), vis
def path_list(it): # this function is used to change -1 to _ again
String = ""
for i in it:
for j in i:
j = int(j)
if j == -1:
j = "_"
j = str(j)
String += j + " "
String += "\n"
print(String)
while not pq.isEmpty():
pri, it = pq.pop()
path_list(it)
if pri == 0:
print("Cost path:", cost)
break
closed_lst.append(it)
successors = generateSuccessors(it)
for successor in successors:
if puzzleExistence(
successor,
closed_lst) or pq.checkExistence(successor) == False:
successor_h = heuristic(successor, result)
pq.update(successor, successor_h)
cost += 1
