def answer_value(name): answer = parse_answer(name + '.out') N, M, D, U, drivers, users = rif.parse_in(name + '.in') if not legal_answer(answer, D, drivers, users): return 0 value = 0 for driver in answer: passengers = get_driver_passengers_idx(driver) # driver only counts if not alone if passengers: actual_distance = driven_distance(driver) min_distance = manhattan_distance(drivers[driver[0][0]][1], drivers[driver[0][0]][2]) value += MAX_DISTANCE - (actual_distance - min_distance) # passengers for passenger in passengers: if passenger >= D: # passenger that's not a driver value += manhattan_distance( users[passenger - D][1], users[passenger - D][2]) + MAX_DISTANCE else: value += manhattan_distance( drivers[passenger][1], drivers[passenger][2]) + MAX_DISTANCE return value
def test_manhattan_distance(self): """ A test to ensure that the distance between points is being properly computed. You do not need to make any changes to this test, instead, in utils.py, you must complete the `eucliden_distance` function so that the correct values are returned. Something to think about: Why might you want to test different cases, e.g. all positive integers, positive and negative floats, coincident points? """ point_a = (3, 7) point_b = (1, 9) distance = utils.manhattan_distance(point_a, point_b) self.assertEqual(4.0, distance) point_a = (-1.25, 2.35) point_b = (4.2, -3.1) distance = utils.manhattan_distance(point_a, point_b) self.assertEqual(10.9, distance) point_a = (0, 0) point_b = (0, 0) distance = utils.manhattan_distance(point_b, point_a) self.assertAlmostEqual(0.0, distance, 4)
def preprocess_data(couriers, orders): impossible_orders = 0 filtered_orders = [] for order in orders: distance = manhattan_distance(order['pickup_location_x'], order['pickup_location_y'], order['dropoff_location_x'], order['dropoff_location_y']) closest_courier = None closest_courier_distance = np.inf for courier in couriers: courier_distance = manhattan_distance(courier['location_x'], courier['location_y'], order['pickup_location_x'], order['pickup_location_y']) if courier_distance < closest_courier_distance: closest_courier = courier closest_courier_distance = courier_distance max_window = order['dropoff_to'] - max(order['pickup_from'], 360 + closest_courier_distance) if distance >= max_window: impossible_orders += 1 else: filtered_orders.append(order) print( f"Total orders: {len(orders)}, Impossible without depot: {impossible_orders}" ) # fix order's time windows bad_order_counter = 0 for order in filtered_orders: if order['pickup_to'] < order['pickup_from']: print( f"Bad time window order: {(order['pickup_from'], order['pickup_to'])}" ) # order['pickup_to'], order['pickup_from'] = order['pickup_from'], order['pickup_to'] order['pickup_to'] = 24 * 60 bad_order_counter += 1 if order['dropoff_to'] < order['dropoff_from']: print( f"Bad time window order: {(order['dropoff_from'], order['dropoff_to'])}" ) # order['dropoff_to'], order['dropoff_from'] = order['dropoff_from'], order['dropoff_to'] order['dropoff_from'] = 6 * 60 bad_order_counter += 1 # courier initial time windows for i, courier in enumerate(couriers): courier['from'] = 6 * 60 courier['to'] = 24 * 60 return couriers, filtered_orders
def process(self): # if status is inactive, activate self.activate_if_inactive() # only moves (not captures) are a valid goal if self.owner.captures: self.status = self.FAILED return # identify player and enemy plr_color = self.owner.to_move enemy_color = self.owner.enemy player = self.owner.get_pieces(plr_color)[0] p_idx, _ = player p_row, p_col = self.owner.row_col_for_index(p_idx) enemy = self.owner.get_pieces(enemy_color)[0] e_idx, _ = enemy e_row, e_col = self.owner.row_col_for_index(e_idx) # pick DC that isn't blocked by enemy lowest_dist = sys.maxsize dc = 0 for i in self.dc: dc_row, dc_col = self.owner.row_col_for_index(i) pdist = manhattan_distance(dc_row, dc_col, p_row, p_col) edist = manhattan_distance(dc_row, dc_col, e_row, e_col) if pdist < lowest_dist and edist > pdist: lowest_dist = pdist dc = i # if lowest distance is 0, then goal is complete. if lowest_dist == 0: self.status = self.COMPLETED return # select the available move that decreases the distance # between the original player position and the chosen double corner. # If no such move exists, the goal has failed. dc_row, dc_col = self.owner.row_col_for_index(dc) good_move = None for m in self.owner.moves: # try a move and gather the new row & col for the player self.owner.make_move(m, False, False) plr_update = self.owner.get_pieces(plr_color)[0] pu_idx, _ = plr_update pu_row, pu_col = self.owner.row_col_for_index(pu_idx) self.owner.undo_move(m, False, False) new_diff = abs(pu_row - dc_row) + abs(pu_col - dc_col) if new_diff < lowest_dist: good_move = m break if good_move: self.owner.make_move(good_move, True, True) else: self.status = self.FAILED
def predict(self, datum): min_distance = manhattan_distance(self.centroid[0], datum) min_idx = 0 for i in range(0, self.n_clusters): distance = manhattan_distance(datum, self.centroid[i]) if (distance < min_distance): min_distance = distance min_idx = i return min_idx
def path_cost(path): # return total path length # consecutive nodes of the path are either along x-axis or y-axis so distance = manhattan distance cost = 0 for i in range(len(path) - 1): cost += manhattan_distance(path[i], path[i + 1]) return cost
def update(self, color, sensor_position, model): """ Update the belief distribution based on new evidence: our agent detected the given color at sensor location: sensor_position. :param color: (string) color detected :param sensor_position: (tuple) position of the sensor :param model (Model object) models the relationship between the treasure location and the sensor data :return: None """ # Iterate over ALL positions in the grid and update the # probability of finding the treasure at that position - given # the new evidence. # The probability of the evidence given the Manhattan distance # to the treasure is given by calling model.pcolorgivendist. # Don't forget to normalize. # Don't forget to update self.open since sensor_position has # now been observed. for p in self.current_distribution: a = utils.manhattan_distance(p, sensor_position) self.current_distribution[ p] = self.current_distribution[p] * model.pcolorgivendist( color, a) # Don't forget to normalize! for p in self.current_distribution: self.current_distribution[p] = self.current_distribution[p] / sum( self.current_distribution.values()) # Don't forget to update self.open since sensor_position has now been observed. self.open.discard(sensor_position)
def update(self, sensor_position, color, model): """ Update the belief distribution based on new evidence: our agent detected the given color at sensor location: sensor_position. :param sensor_position: (tuple) position of the sensor :param color: (string) color detected :param model (Model object) models the relationship between the treasure location and the sensor data :return: None """ # Iterate over ALL positions in the grid and update the probability # of finding the treasure at that position - given the new evidence # The probability of the evidence given the Manhattan distance to the # treasure may be accessed by calling model.get_pcolorgivendist. # Don't forget to normalize. # Don't forget to update self.open since sensor_position has now been # observed. # !!! update all positions instead of open positions # iterate over all keys # ??? If updating all probabilities, why need to update self.open? What is that for? for recommend? sum = 0 for any_position in self.tprob: # multiply P(effect_k|cause), then normalize # estimate the probability of treasure in open_position given all effects m_dist = utils.manhattan_distance(any_position, sensor_position) # should be proportional to this value self.tprob[any_position] *= model.get_pcolorgivendist( color, m_dist) #sum(dict.values()) sum += self.tprob[any_position] self.tprob = {k: v / sum for k, v in self.tprob.items()} self.open.discard(sensor_position)
def update(self, color, sensor_position, model): """ Update the belief distribution based on new evidence: our agent detected the given color at sensor location: sensor_position. :param color: (string) color detected :param sensor_position: (tuple) position of the sensor :param model (Model object) models the relationship between the treasure location and the sensor data :return: None """ # Iterate over ALL positions in the grid and update the # probability of finding the treasure at that position - given # the new evidence. # The probability of the evidence given the Manhattan distance # to the treasure id given by calling model.psonargivendist. # Don't forget to normalize. # Don't forget to update self.open since sensor_position has # now been observed. self.open.remove(sensor_position) sumProb = float(0) for x, y in self.current_distribution: dist = utils.manhattan_distance((x, y), sensor_position) # P(S|T), float probability cp = model.psonargivendist(color, dist) self.current_distribution[x, y] *= cp sumProb += self.current_distribution[x, y] for w, z in self.current_distribution: self.current_distribution[ w, z] = self.current_distribution[w, z] / sumProb
def update(self, color, sensor_position, model): """ Update the belief distribution based on new evidence: our agent detected the given color at sensor location: sensor_position. :param color: (string) color detected :param sensor_position: (tuple) position of the sensor :param model (Model object) models the relationship between the treasure location and the sensor data :return: None """ # Iterate over ALL positions in the grid and update the probability # of finding the treasure at that position - given the new evidence # The probability of the evidence given the Manhattan distance to the # treasure may be accessed by calling model.pcolorgivendist. # Don't forget to normalize. # Don't forget to update self.open since sensor_position has now been # observed # Iterate over All positions in the grid and update the probability of finding treasure for p in self.current_distribution: self.current_distribution[p] *= model.pcolorgivendist(color, utils.manhattan_distance(p, sensor_position)) # Normalize for p in self.current_distribution: self.current_distribution[p] = self.current_distribution[p]/sum(self.current_distribution.values()) # Quick check that the values are normalized # print('CHECK', sum(self.current_distribution.values())) # Remove sensor_position from the open set self.open.discard(sensor_position)
def part2(instructions): ship = Ant(0, 0, 90) waypoint = Ant(10, 1) for ins in instructions: i, value = ins[0], int(ins[1:]) if i == "F": x, y = waypoint.pos() ship.x += value * x ship.y += value * y elif i == "N": waypoint.north(value) elif i == "S": waypoint.south(value) elif i == "E": waypoint.east(value) elif i == "W": waypoint.west(value) elif i in "LR": dist = waypoint.dist() angle = waypoint.angle() waypoint.x = 0 waypoint.y = 0 if i == "L": waypoint.heading = angle + value else: waypoint.heading = angle - value waypoint.forward(dist) return manhattan_distance((0, 0), ship.pos())
def distance_intra_cluster(transformed_df, main_df, centroids): zones = ["D1", "D2", "D3", "D4", "D5", "D6"] centroids_map = dict(zip(zones, centroids)) centroids_df = pd.DataFrame.from_dict( centroids_map, orient="index", columns=["lat_centroids", "lon_centroids"]) centroids_df = centroids_df.reset_index().rename( columns={"index": "zones"}) unpivoted_df = pd.melt(transformed_df, id_vars=['Id_Cliente'], var_name="zones") unpivoted_df = unpivoted_df[unpivoted_df.value > 0] joined_df = unpivoted_df.merge(main_df[["Id_Cliente", "lat", "lon"]], on="Id_Cliente", how = "left")\ .merge(centroids_df, on="zones", how = "left") joined_df["manhattan"] = manhattan_distance(joined_df["lat"], joined_df["lon"], joined_df["lat_centroids"], joined_df["lon_centroids"]) joined_df["haversine"] = haversine_distance(joined_df["lat"], joined_df["lon"], joined_df["lat_centroids"], joined_df["lon_centroids"]) print("Manhattan Distance") print(joined_df.groupby("zones")["manhattan"].sum()) print("Haversine Distance") print(joined_df.groupby("zones")["haversine"].sum()) return (joined_df["manhattan"].sum(), joined_df["haversine"].sum())
def distance_between_nodes_with_headings(self, start, start_heading, goal, goal_heading): dist, final_heading = self.distance_between_nodes( start, goal, start_heading) if not opposite_headings(final_heading, goal_heading): return dist # Goal heading is opposite of final_heading perimeter = 4 + 2 * (self.corridor_len + 1) if start_heading in [(1, 0), (-1, 0)]: start_junc = self.get_junction(start, start_heading) gj = self.get_junction(goal, start_heading) goal_junc = self.get_junction(goal, (-goal_heading[0], goal_heading[1])) # the agent has to move atleast this distance min_dist = manhattan_distance( start, start_junc) + manhattan_distance( start_junc, goal_junc) + manhattan_distance( goal_junc, goal) # if start and goal are in the same column if start[1] == goal[1]: # same block if start_junc[0] == gj[0]: # top or bottom block if start_junc[0] == 0 or start_junc[0] == self.shape[0] - 1: extra = perimeter + 4 else: extra = perimeter # different blocks else: extra = 4 # start and goal are in adjacent sampling columns elif abs(start[1] - goal[1]) == 2: if start_heading == goal_heading: extra = 4 else: extra = 0 else: extra = 0 else: raise NotImplementedError return min_dist + extra
def complete_link(cls, cluster_a, cluster_b): max_distance = -1 for a in cluster_a: for b in cluster_b: distance = manhattan_distance(a, b) min_distance = max(distance, min_distance) return max_distance
def avg_group_link(cls, cluster_a, cluster_b): total_a = reduce(lambda a, b: [x[0] + x[1] for x in zip(a, b)], cluster_a, [0 for x in range(len(cluster_a[0]))]) total_b = reduce(lambda a, b: [x[0] + x[1] for x in zip(a, b)], cluster_b, [0 for x in range(len(cluster_b[0]))]) avg_a = list(map(lambda x: x / len(cluster_a), total_a)) avg_b = list(map(lambda x: x / len(cluster_b), total_b)) return manhattan_distance(avg_a, avg_b)
def single_link(cls, cluster_a, cluster_b): min_distance = 9999999999999 for a in cluster_a: for b in cluster_b: distance = manhattan_distance(a, b) min_distance = min(distance, min_distance) return min_distance
def avg_link(cls, cluster_a, cluster_b): total_distance = 0 counter = 0 for a in cluster_a: for b in cluster_b: total_distance += manhattan_distance(a, b) counter += 1 return total_distance / counter
def calc_dist(wires): p0 = points_from_wire(wires[0]) p1 = points_from_wire(wires[1]) dist = 2**32 for point in set(p0).intersection(set(p1)): d = manhattan_distance((0, 0), point) if d < dist: dist = d return dist
def observe(self, pos, problem): """ Return the color returned when the sonar is aimed at the given location :param pos: (tuple) sonar position :param problem: (Problem object) :return: color (string) : sensor reading """ dist = utils.manhattan_distance(pos, problem.treasure) color = self.sample(dist) return color
def closest_point(x, y, points): dist = 1000000000000 point = -1 for i in range(len(points)): dist_ = manhattan_distance((x, y), points[i]) if dist_ < dist: dist = dist_ point = i elif dist_ == dist: point = -1 return point
def manhatten_freq(vectorizer, text1, text2): try: tfidf = vectorizer.fit_transform([text1, text2]) except: vectorizer = TfidfVectorizer(stop_words=None, use_idf=True, tokenizer=tokenize_and_stem) tfidf = vectorizer.fit_transform([text1, text2]) return float( manhattan_distance(list(tfidf[0].toarray()[0]), list(tfidf[1].toarray()[0])))
def execute_search(self): """ Corre el algoritmo A* sobre la cuadrícula para encontrar el objetivo. """ path = [] self.color[self.start[0]][self.start[1]] =\ 'GRAY' self.distance[self.start[0]][self.start[1]] = 0 self.parent[self.start[0]][self.start[1]] = None self.open_list.put((0, self.start)) self.f_score[self.start[0]][self.start[1]] =\ manhattan_distance(self.start, self.goal) while not self.open_list.empty(): current_square = self.open_list.get() current_square_coordinates =\ current_square[1] if current_square_coordinates == self.goal: break if self.parent[current_square_coordinates[0]][ current_square_coordinates[1]]: current_path = self.get_path(current_square_coordinates) path += current_path path += self.get_reverse_path(current_path) up_square = self.move_up(current_square_coordinates) left_square = self.move_to_the_left(current_square_coordinates) right_square = self.move_to_the_right(current_square_coordinates) down_square = self.move_down(current_square_coordinates) successors = [up_square, left_square, right_square, down_square] for successor in successors: if successor: f = self.distance[successor[0]][successor[1]] +\ manhattan_distance(successor, self.goal) if self.f_score[successor[0]][successor[1]] >= f: self.f_score[successor[0]][successor[1]] = f self.open_list.put((f, successor)) return path
def execute_search(self): """ Realiza la búsqueda primero en anchura. :return: una lista con la trayectoria más corta del inicio al objetivo. :return type: list """ path = [] self.color[self.start[0]][self.start[1]] =\ 'GRAY' self.distance[self.start[0]][self.start[1]] = 0 self.parent[self.start[0]][self.start[1]] = None self.my_bests.put((manhattan_distance(self.start, self.goal),\ self.start)) while not self.my_bests.empty(): current_square = self.my_bests.get() current_square = current_square[1] if current_square == self.goal: break if self.parent[current_square[0]][current_square[1]]: current_path = self.get_path(current_square) path += current_path path += self.get_reverse_path(current_path) up_square = self.move_up(current_square) if up_square: self.my_bests.put((manhattan_distance(up_square, self.goal), up_square)) left_square = self.move_to_the_left(current_square) if left_square: self.my_bests.put((manhattan_distance(left_square, self.goal), left_square)) right_square = self.move_to_the_right(current_square) if right_square: self.my_bests.put((manhattan_distance(right_square, self.goal), right_square)) down_square = self.move_down(current_square) if down_square: self.my_bests.put((manhattan_distance(down_square, self.goal), down_square)) self.color[current_square[0]][current_square[1]] = 'BLACK' return path
def pair_triplet_accuracy(y_true: TensorLike, y_pred: TensorLike, margin: FloatTensorLike = 1.0, distance_metric: Union[str, Callable] = "L2"): """ Calculates how often predictions matches the cut/non cut labels. Convert two embeddings into label `labels_pred` by calculating distance and threshold using margin. It computes the frequency with which `labels_pred` matches `y_true`. This frequency is ultimately returned as `pair accuracy`. Args: y_true: Integer ground truth values. y_pred: 3-D float `Tensor` of representational embedding of RNA and gRNA. [batch, 2, embedding_dim] margin: Float, threshold distance. distance_metric: String, distance metric in use. Returns: Float, accuracy values. """ embeddings = ops.convert_to_tensor_v2_with_dispatch(y_pred) labels = ops.convert_to_tensor_v2_with_dispatch(y_true) convert_to_float32 = ( embeddings.dtype == tf.dtypes.float16 or \ embeddings.dtype == tf.dtypes.bfloat16 ) precise_embeddings = ( tf.cast(embeddings, tf.dtypes.float32) \ if convert_to_float32 else embeddings ) if distance_metric == "L2": dist = euclidean_distance(precise_embeddings[:, 0], precise_embeddings[:, 1]) elif distance_metric == "squared-L2": dist = tf.square( euclidean_distance(precise_embeddings[:, 0], precise_embeddings[:, 1])) elif distance_metric == "L1": dist = manhattan_distance(precise_embeddings[:, 0], precise_embeddings[:, 1]) else: # Callable dist = distance_metric(precise_embeddings[:, 0], precise_embeddings[:, 1]) labels_pred = dist <= margin return math_ops.cast( math_ops.equal(tf.cast(tf.math.floormod(y_true, 2), tf.dtypes.bool), labels_pred), K.floatx())
def select_element(self, cell): contained = list(cell.contained) is_selected = False selected = None while not is_selected: if not contained: return selected = random.choice(contained) destination = self.get_destination_cell(selected) distance = manhattan_distance(cell.index, destination) if distance != 0: is_selected = True else: contained.remove(selected) return selected
def get_user_shop_distance(result): result['feature_user_shop_lon_sub'] = (result['user_longitude'] - result['shop_longitude']) result['feature_user_shop_lat_sub'] = (result['user_latitude'] - result['shop_latitude']) result['feature_user_shop_lon_sub_abs'] = abs( result['feature_user_shop_lon_sub']) result['feature_user_shop_lat_sub_abs'] = abs( result['feature_user_shop_lat_sub']) result['feature_user_shop_uclidean_dis'] = euclidean_distance( result['user_latitude'], result['user_longitude'], result['shop_latitude'], result['shop_longitude']) result['feature_user_shop_haversine_dis'] = haversine_distance( result['user_latitude'], result['user_longitude'], result['shop_latitude'], result['shop_longitude']) result['feature_user_shop_manhattan_dis'] = manhattan_distance( result['user_latitude'], result['user_longitude'], result['shop_latitude'], result['shop_longitude']) return result
def part1(instructions): ship = Ant(0, 0, heading=0) for ins in instructions: i, value = ins[0], int(ins[1:]) if i == "F": ship.forward(value) elif i == "N": ship.north(value) elif i == "S": ship.south(value) elif i == "E": ship.east(value) elif i == "W": ship.west(value) elif i == "L": ship.turn(value) elif i == "R": ship.turn(-value) return manhattan_distance((0, 0), ship.pos())
def get_user_shop_average_distance(refer, result): shop_longitude = refer.groupby(['shop_id'], as_index=False)['longitude'].agg( {'shop_average_longitude': 'mean'}) shop_latitude = refer.groupby(['shop_id'], as_index=False)['latitude'].agg( {'shop_average_latitude': 'mean'}) result = pd.merge(result, shop_longitude, on=['shop_id'], how='left') result = pd.merge(result, shop_latitude, on=['shop_id'], how='left') result['feature_user_shop_aver_uclidean_dis'] = euclidean_distance( result['user_latitude'], result['user_longitude'], result['shop_average_latitude'], result['shop_average_longitude']) result['feature_user_shop_aver_haversine_dis'] = haversine_distance( result['user_latitude'], result['user_longitude'], result['shop_average_latitude'], result['shop_average_longitude']) result['feature_user_shop_aver_manhattan_dis'] = manhattan_distance( result['user_latitude'], result['user_longitude'], result['shop_average_latitude'], result['shop_average_longitude']) del result['shop_average_longitude'] del result['shop_average_latitude'] return result
def main(puzzle_input): points = [] for line in puzzle_input: points.append(tuple(get_numbers((line)))) # compute the distance between every pair of points distances = { p: {q: manhattan_distance(p, q) for q in points} for p in points } # for each point, find the constellation of points that it contains constellations = 0 points_in_constellation = set() points_remaining = set(points) # basically we pick a point that isn't in a constellation, and then keep working # away from that point until we've found the entire constellation while True: # no more points remaining! if len(points_remaining) == 0: break p = points_remaining.pop() to_process = set([p]) points_in_constellation.add(p) while len(to_process) > 0: p = to_process.pop() # get all the points that are within a distance of 3 of our current processing points qs = {q for q in points_remaining if distances[p][q] <= 3} points_remaining = points_remaining.difference(qs) points_in_constellation = points_in_constellation.union(qs) to_process = to_process.union(qs) constellations += 1 return constellations
def dirt_heuristic(state, problem): """ Heuristic to search all locations in the map Uses distance to furthest dirt as heuristic :param state: Current state of the robot/world (RobotState) :param problem: Search problem to be completed (e.g., MapEnvironmentProblem) :return: Heuristic value of the current state (RobotState, Grid) """ unvisited = state.getDirt() cell_costs = [] for cell in unvisited: cell_costs.append( utils.manhattan_distance(state.getRobotPosition(), cell)) if len(cell_costs) > 0: max_cost = max(cell_costs) min_cost = min(cell_costs) else: max_cost = 0 min_cost = 0 return min_cost + (len(unvisited) * len(unvisited))
def dfs_visit(self, current_square): if current_square == self.goal or self.done: self.done = True return self.distance[current_square[0]][current_square[1]] = self.time self.time += 1 self.color[current_square[0]][current_square[1]] = 'GRAY' up_square = self.move_up(current_square) left_square = self.move_to_the_left(current_square) right_square = self.move_to_the_right(current_square) down_square = self.move_down(current_square) candidates = [up_square, left_square, right_square, down_square] candidates = [(manhattan_distance(candidates[idx], self.goal), idx)\ for idx in range(4) if candidates[idx]] for candidate in sorted(candidates): if self.done: break if candidate[1] == 0: self.path.append('U') self.dfs_visit(up_square) # if not self.done: self.path.append('D') if candidate[1] == 2: self.path.append('R') self.dfs_visit(right_square) # if not self.done: self.path.append('L') if candidate[1] == 1: self.path.append('L') self.dfs_visit(left_square) # if not self.done: self.path.append('R') if candidate[1] == 3: self.path.append('D') self.dfs_visit(down_square) # if not self.done: self.path.append('U') self.color[current_square[0]][current_square[1]] = 'BLACK'
from scenarios import flatland_from_file from utils import manhattan_distance ITERATIONS = 5000 TEMPERATURE = 1.0 N = 1 if __name__ == '__main__': times = { 2: [], 3: [] } flatland = flatland_from_file('../scenarios/5-even-bigger.txt') backup_x = int(sqrt(manhattan_distance((0, 0), (flatland.w, flatland.h)))) for i in xrange(N): print(2, i) agent = FlatlandAgent( world=deepcopy(flatland), step_limit=flatland.w * flatland.h, backup_x=backup_x, temperature=TEMPERATURE, delta_t=TEMPERATURE / ITERATIONS ) agent.Q = Q2() start = time() agent.train() finish = time()
def get_h_val(self, node): return manhattan_distance(node.xy, self.goal_node.xy)