def h(self, node): """h function is straight-line distance from a node's state to goal.""" locs = getattr(self.graph, 'locations', None) if locs: return int(distance(locs[node.state], locs[self.goal])) else: return infinity
def RandomGraph(nodes=list(range(10)), min_links=2, width=400, height=300, curvature=lambda: random.uniform(1.1, 1.5)): """Construct a random graph, with the specified nodes, and random links. The nodes are laid out randomly on a (width x height) rectangle. Then each node is connected to the min_links nearest neighbors. Because inverse links are added, some nodes will have more connections. The distance between nodes is the hypotenuse times curvature(), where curvature() defaults to a random number between 1.1 and 1.5.""" g = UndirectedGraph() g.locations = {} # Build the cities for node in nodes: g.locations[node] = (random.randrange(width), random.randrange(height)) # Build roads from each city to at least min_links nearest neighbors. for i in range(min_links): for node in nodes: if len(g.get(node)) < min_links: here = g.locations[node] def distance_to_node(n): if n is node or g.get(node, n): return infinity return distance(g.locations[n], here) neighbor = argmin(nodes, key=distance_to_node) d = distance(g.locations[neighbor], here) * curvature() g.connect(node, neighbor, int(d)) return g
def h(self, node): "h function is straight-line distance from a node's state to goal." locs = getattr(self.graph, 'locations', None) if locs: return int(distance(locs[node.state], locs[self.goal])) else: return infinity
def h(self, node): "h function is straight-line distance from a node's state to goal." locs = getattr(self.graph, 'locations', None) if locs: # changed to observe heuristics # return int(distance(locs[node.state], locs[self.goal])) d2g = distance(locs[node.state], locs[self.goal]) return d2g else: return infinity
def value(self,state): #list_temp=self.actions(node) #print(list_temp) #return list_temp "h function is straight-line distance from a node's state to goal." locs = getattr(self.graph, 'locations', None) if locs: #print (int(distance(locs[state], locs[self.goal]))) #print (state) return int(distance(locs[state], locs[self.goal])) else: return infinity
def validate(self, state): if "Move" not in self.element["abilities"]: logger.debug("%s does not have the ability to Move") return False if grid.distance(self.target, state.find(self.element)) != 2: return False if self.target not in grid.VALID_CELLS: return False if self.target in state: logger.debug("%s tried to move to %s, which is occupied by %s", self.element, self.target, state[self.target]) return False return True
def A(matrix, start, goal, weight, H): fringe = [] closed = set() cost = 0 nodeStart = Node(start, start) nodeStart.W = weight fringe.append(nodeStart) while fringe: fringe.sort() node = fringe.pop(0) if node not in closed: closed.add(node.position) if node.position == goal: path = [] while node != nodeStart: mem = sys.getsizeof(fringe) + sys.getsizeof(closed) path.append(node.position) mX, mY = node.position node = node.parentNode cost += getCostA(matrix, node, Node(0, (mX, mY))) return path, cost, mem, len(closed) n = getNeighborsA(node, closed) for x in n: if x not in closed: mX, mY = x if matrix[mX][mY] != "0": suc = Node(node, x) suc.W = weight nodeCost = getCostA(matrix, node, suc) if H == "D": suc.H = optimalHeuristic(suc, closed, goal) elif H == "N": suc.H = math.trunc(distance((suc.position, goal))) if suc not in fringe: suc.G = sys.maxsize if node.G + nodeCost < suc.G: suc.G = node.G + nodeCost suc.parentNode = node suc.cost = suc.G + suc.W * suc.H if suc in fringe: fringe.remove(suc) fringe.append(suc) return None
def distance_to_node(n): if n is node or g.get(node, n): return infinity return distance(g.locations[n], here)
def h(self, node): state = node.state coor1 = self.location[state] coor2 = self.location[self.goal] return distance(coor1, coor2)
def h(self, node): state = node.state loc1 = self.locations[state] loc2 = self.locations[self.finish] return distance(loc1, loc2)
def h(self, node): state = node.state coor1 = self.location[state] coor2 = self.location[self.goal] return distance(coor1,coor2)