def tester_run():
grid = u_grid.gen_symmetric_grid(4)
start = 0
goal = 12
astar = KAStar(grid, start, {goal})
astar.run()
closed_true = {Node(0), Node(4), Node(8), Node(12)}
p1 = closed_true == astar._closed
grid = u_grid.gen_symmetric_grid(4)
start = 0
goals = {7, 12}
astar = KAStar(grid, start, goals)
astar.run()
closed_true = {
Node(0),
Node(4),
Node(8),
Node(12),
Node(5),
Node(6),
Node(7)
}
p2 = closed_true == astar._closed
fname = sys._getframe().f_code.co_name[7:]
if (p1 and p2):
print('OK: {0}'.format(fname))
else:
print('Failed: {0}'.format(fname))
def tester_gen_grid_h():
grid = u_grid.gen_symmetric_grid(3)
grid[1][2] = -1
idd_1 = 0
grid_h = gen_grid_h(grid, idd_1)
li_0 = [0, 1, 2]
li_1 = [1, 2, -1]
li_2 = [2, 3, 4]
lists = [li_0, li_1, li_2]
grid_h_true = u_grid.lists_to_grid(lists)
p1 = (grid_h == grid_h_true).all()
grid = u_grid.gen_symmetric_grid(3)
grid[1][1] = -1
grid[2][1] = -1
goal = 3
lookup = {1, 2, 5}
grid_lookup = np.array([[1, 2, 3], [0, -1, 4], [1, -1, 5]], dtype=int)
grid_h = gen_grid_h(grid, goal, lookup, grid_lookup)
grid_h_true = np.array([[1, 2, 3], [0, -1, 4], [1, -1, 3]], dtype=int)
p2 = (grid_h == grid_h_true).all()
fname = sys._getframe().f_code.co_name[7:]
if p1 and p2:
print('OK: {0}'.format(fname))
else:
print('Failed: {0}'.format(fname))
def tester_get_path():
grid = u_grid.gen_symmetric_grid(4)
start = 0
goal = 12
astar = KAStar(grid, start, {goal})
astar.run()
optimal_path = [0, 4, 8, 12]
p1 = astar.get_path(goal) == optimal_path
grid = u_grid.gen_symmetric_grid(4)
grid[1][1] = -1
grid[2][1] = -1
start = 8
goal = 10
astar = KAStar(grid, start, {goal})
astar.run()
optimal_path = [8, 12, 13, 14, 10]
p2 = astar.get_path(goal) == optimal_path
p3 = True
for i in range(1000):
n = u_random.get_random_int(4, 4)
grid = u_grid.gen_symmetric_grid(n)
idds_valid = u_grid.get_valid_idds(grid)
random.shuffle(idds_valid)
start = idds_valid[0]
goals = idds_valid[1:3]
kastar = KAStar(grid, start, goals)
kastar.run()
for goal in goals:
len_optimal = u_grid.manhattan_distance(grid, start, goal) + 1
if len(kastar.get_path(goal)) != len_optimal:
p3 = False
print('start={0}'.format(start))
print('goal={0}'.format(goals))
print('grid:')
for row in range(grid.shape[0]):
li = list()
for col in range(grid.shape[1]):
li.append(grid[row][col])
li = [str(x) for x in li]
print(','.join(li))
print('goal[{0}]: {1}'.format(goal, kastar.get_path(goal)))
fname = sys._getframe().f_code.co_name[7:]
if (p1 and p2 and p3):
print('OK: {0}'.format(fname))
else:
print('Failed: {0}'.format(fname))
def tester_get_far_node():
grid = u_grid.gen_symmetric_grid(5)
src = 0
dist_min = 2
dist_max = 3
far_nodes = set()
for i in range(1000):
far_nodes.add(get_far_node(grid, src, dist_min, dist_max))
far_nodes_true = {2, 3, 6, 7, 10, 11, 15}
p1 = far_nodes == far_nodes_true
src = 18
dist_min = 2
dist_max = 2
far_nodes = set()
for i in range(1000):
far_nodes.add(get_far_node(grid, src, dist_min, dist_max))
far_nodes_true = {8, 12, 14, 16, 22, 24}
p2 = far_nodes == far_nodes_true
fname = sys._getframe().f_code.co_name[7:]
if (p1 and p2):
print('OK: {0}'.format(fname))
else:
print('Failed: {0}'.format(fname))
def tester_get_expanded_nodes():
grid = u_grid.gen_symmetric_grid(5)
grid[0][0] = -1
grid[1][1] = -1
grid[1][2] = -1
grid[1][4] = -1
grid[2][1] = -1
grid[3][1] = -1
grid[3][2] = -1
grid[3][4] = -1
grid_g = np.array(
[[-1, 5, 4, 3, 4], [9, -1, -1, 2, -1], [8, -1, 0, 1, 2],
[7, -1, -1, 2, -1], [6, 5, 4, 3, 4]],
dtype=int)
grid_h = np.array(
[[-1, 3, 4, 5, 6], [1, -1, -1, 4, -1], [0, -1, 2, 3, 4],
[1, -1, -1, 4, -1], [2, 3, 4, 5, 6]],
dtype=int)
goal = 10
expanded_nodes = get_expanded_nodes(grid, grid_g, grid_h, goal)
fname = sys._getframe().f_code.co_name[7:]
if (expanded_nodes == {8, 10, 12, 13, 14, 15, 18, 20, 21, 22, 23}):
print('OK: {0}'.format(fname))
else:
print('Failed: {0}'.format(fname))
def tester_get_shape():
grid = u_grid.gen_symmetric_grid(5)
idds = {2, 4, 6}
shape = get_shape(grid, idds)
fname = sys._getframe().f_code.co_name[7:]
if (shape == (2, 4)):
print('OK: {0}'.format(fname))
else:
print('Failed: {0}'.format(fname))
def tester_get_centroid():
grid = u_grid.gen_symmetric_grid(3)
idds = {2, 4, 6}
centroid, total = get_centroid(grid, idds)
fname = sys._getframe().f_code.co_name[7:]
if (centroid == 4 and total == 4):
print('OK: {0}'.format(fname))
else:
print('Failed: {0}'.format(fname))
def tester_get_total_distances_between():
grid = u_grid.gen_symmetric_grid(3)
idds = {4, 6, 8}
total = get_total_distances_between(grid, idds)
fname = sys._getframe().f_code.co_name[7:]
if (total == 6):
print('OK: {0}'.format(fname))
else:
print('Failed: {0}'.format(fname))
def tester_get_total_distances_to():
grid = u_grid.gen_symmetric_grid(3)
start = 0
goals = {4, 8}
total = get_total_distances_to(grid, start, goals)
fname = sys._getframe().f_code.co_name[7:]
if (total == 6):
print('OK: {0}'.format(fname))
else:
print('Failed: {0}'.format(fname))
def tester_get_farthest():
grid = u_grid.gen_symmetric_grid(3)
start = 0
goals = {4, 8}
farthest, distance = get_farthest(grid, start, goals)
fname = sys._getframe().f_code.co_name[7:]
if (farthest == 8 and distance == 4):
print('OK: {0}'.format(fname))
else:
print('Failed: {0}'.format(fname))
def tester_get_path():
grid = u_grid.gen_symmetric_grid(4)
start = 0
goal = 12
astar = AStar(grid,start,goal)
astar.run()
optimal_path = [0,4,8,12]
p1 = astar.get_path() == optimal_path
grid = u_grid.gen_symmetric_grid(4)
grid[1][1] = -1
grid[2][1] = -1
start = 8
goal = 10
astar = AStar(grid,start,goal)
astar.run()
optimal_path = [8,12,13,14,10]
p2 = astar.get_path() == optimal_path
p3 = True
for i in range(1000):
n = u_random.get_random_int(3,10)
grid = u_grid.gen_symmetric_grid(n)
idds_valid = u_grid.get_valid_idds(grid)
random.shuffle(idds_valid)
start = idds_valid[0]
goal = idds_valid[1]
astar = AStar(grid,start,goal)
astar.run()
len_optimal = u_grid.manhattan_distance(grid,start,goal)+1
if len(astar.get_path()) != len_optimal:
p3 = False
fname = sys._getframe().f_code.co_name[7:]
if (p1 and p2 and p3):
print('OK: {0}'.format(fname))
else:
print('Failed: {0}'.format(fname))
def tester_gen_random_pairs():
grid = u_grid.gen_symmetric_grid(3)
grid[0][0] = -1
pairs = gen_random_pairs(grid, 4, 100)
f1 = frozenset({(2, 6)})
f2 = frozenset({(6, 2)})
f3 = frozenset({(2, 6), (6, 2)})
fname = sys._getframe().f_code.co_name[7:]
if (pairs in {f1, f2, f3}):
print('OK: {0}'.format(fname))
else:
print('Failed: {0}'.format(fname))
def tester_run():
grid = u_grid.gen_symmetric_grid(4)
start = 0
goal = 12
astar = AStar(grid,start,goal)
astar.run()
closed_true = {Node(0),Node(4),Node(8),Node(12)}
p1 = closed_true == astar.closed
grid = u_grid.gen_symmetric_grid(4)
grid[0][2] = -1
grid[1][2] = -1
start = 0
goal = 3
astar = AStar(grid,start,goal)
astar.run()
closed_true = {Node(0),Node(1),Node(3),Node(4),Node(5),Node(7),Node(9),Node(10),Node(11)}
p2 = closed_true == astar.closed
fname = sys._getframe().f_code.co_name[7:]
if (p1 and p2):
print('OK: {0}'.format(fname))
else:
print('Failed: {0}'.format(fname))
def tester_get_random_idds():
grid = u_grid.gen_symmetric_grid(3)
grid[1][1] = -1
idds = get_random_idds(grid, idd_center=4, radius=2, amount=2)
p1 = idds in {frozenset((0, 1)), frozenset((0, 3)), frozenset((1, 3))}
idds = get_random_idds(grid, 4, 2, 4)
p2 = idds is None
idds = get_random_idds(grid, 1, 3, 2)
p3 = idds is None
fname = sys._getframe().f_code.co_name[7:]
if (p1 and p2 and p3):
print('OK: {0}'.format(fname))
else:
print('Failed: {0}'.format(fname))
def tester_gen_grid_g():
grid = u_grid.gen_symmetric_grid(3)
grid[1][1] = -1
idd_1 = 3
grid_g = gen_grid_g(grid, idd_1)
li_0 = [1, 2, 3]
li_1 = [0, -1, 4]
li_2 = [1, 2, 3]
lists = [li_0, li_1, li_2]
grid_g_true = u_grid.lists_to_grid(lists)
fname = sys._getframe().f_code.co_name[7:]
if (grid_g == grid_g_true).all():
print('OK: {0}'.format(fname))
else:
print('Failed: {0}'.format(fname))