def test_run_basic(self):
graph = Graph('../input/3_airports_input.csv')
solver = GraphACO(graph.G, ants=5)
path, cost = solver.search(10)
self.assertEqual(cost, 0)
# self.assertEquals(len(np.unique(path)), len(graph.G.nodes()))
self.assertEqual(path[0], Flight("QSA", "EFQ", 0, 0))
self.assertEqual(path[1], Flight("EFQ", "KCA", 1, 0))
self.assertEqual(path[2], Flight("KCA", "QSA", 2, 0))
graph = Graph('../input/3_airports_backtrace.csv')
solver = GraphACO(graph.G, ants=5)
path, cost = solver.search(10)
self.assertEqual(cost, 300)
# self.assertEquals(len(np.unique(path)), len(graph.G.nodes()))
self.assertEqual(path[0], Flight("PRG", "TXL", 0, 100))
self.assertEqual(path[1], Flight("TXL", "BCN", 1, 100))
self.assertEqual(path[2], Flight("BCN", "PRG", 2, 100))
graph = Graph('../input/4_airports_backtrace.csv')
solver = GraphACO(graph.G, ants=5)
path, cost = solver.search(10)
self.assertEqual(cost, 400)
# self.assertEquals(len(np.unique(path)), len(graph.G.nodes()))
self.assertEqual(path[0], Flight("PRG", "TXL", 0, 100))
self.assertEqual(path[1], Flight("TXL", "BCN", 1, 100))
self.assertEqual(path[2], Flight("BCN", "DEL", 2, 100))
self.assertEqual(path[3], Flight("DEL", "PRG", 3, 100))
def test_forward(self):
graph = Graph('../input/3_airports_input.csv')
solver = GraphBackTracker(graph.G)
cost, path = solver.search()
self.assertEquals(cost, 0)
# self.assertEquals(len(np.unique(path)), len(graph.G.nodes()))
self.assertEqual(path[0], Flight("QSA", "EFQ", 0, 0))
self.assertEqual(path[1], Flight("EFQ", "KCA", 1, 0))
self.assertEqual(path[2], Flight("KCA", "QSA", 2, 0))
def test_forward(self):
dataset = load_data('../input/3_airports_input.csv')
b = BackTracker()
r = b.search(dataset)
self.assertEqual(r[0], Flight("QSA", "EFQ", 0, 0))
self.assertEqual(r[1], Flight("EFQ", "KCA", 1, 0))
self.assertEqual(r[2], Flight("KCA", "QSA", 2, 0))
def test_backward(self):
dataset = load_data('../input/3_airports_backtrace.csv')
b = BackTracker()
r = b.search(dataset)
self.assertEqual(r[0], Flight("PRG", "TXL", 0, 100))
self.assertEqual(r[1], Flight("TXL", "BCN", 1, 100))
self.assertEqual(r[2], Flight("BCN", "PRG", 2, 100))
def test_backward(self):
graph = Graph('../input/3_airports_backtrace.csv')
solver = GraphBackTracker(graph.G)
cost, path = solver.search()
self.assertEquals(cost, 300)
# self.assertEquals(len(np.unique(path)), len(graph.G.nodes()))
self.assertEqual(path[0], Flight("PRG", "TXL", 0, 100))
self.assertEqual(path[1], Flight("TXL", "BCN", 1, 100))
self.assertEqual(path[2], Flight("BCN", "PRG", 2, 100))
graph = Graph('../input/4_airports_backtrace.csv')
solver = GraphBackTracker(graph.G)
cost, path = solver.search()
self.assertEquals(cost, 400)
# self.assertEquals(len(np.unique(path)), len(graph.G.nodes()))
self.assertEqual(path[0], Flight("PRG", "TXL", 0, 100))
self.assertEqual(path[1], Flight("TXL", "BCN", 1, 100))
self.assertEqual(path[2], Flight("BCN", "DEL", 2, 100))
self.assertEqual(path[3], Flight("DEL", "PRG", 3, 100))
# def test_run(self):
graph = Graph('../input/300_airports_input.csv')
solver = GraphBackTracker(graph.G)
cost, path = solver.search()
# self.assertEquals(len(np.unique(path)), len(graph.G.nodes()))
print(cost)
for p in path:
print(p)
def search(self):
to_visit = self.G.nodes()
cost = 0
path = []
tabu = {}
current_day = 0
current_city = self.start_city
while to_visit:
# select all edges/flights to unvisited cities from current city on current day
possible_flights = [
(city_from, city_to, data)
for (city_from, city_to,
data) in self.G.edges(current_city, data=True)
if data['day'] == current_day and city_to in to_visit
and not tabu.get((city_from, city_to, data['day'],
data['weight']), False)
]
if possible_flights:
# weight == prize
best_flight = min(possible_flights,
key=lambda d: d[2]['weight'])
cost += best_flight[2]['weight']
current_city = best_flight[1]
current_day += 1
to_visit.remove(current_city)
path.append(
Flight(best_flight[0], best_flight[1],
best_flight[2]['day'], best_flight[2]['weight']))
else:
# remove last flight from path
if path:
last_flight = path.pop(-1)
else:
return cost, path
to_visit.append(current_city)
cost -= last_flight.price
current_city = last_flight.city_from
current_day -= 1
tabu[(last_flight.city_from, last_flight.city_to,
last_flight.day, last_flight.price)] = 1
return cost, path
def test_run_basic(self):
sp = ShortestPath()
dataset = DictDataset()
dataset.load_data('../input/3_airports_input.csv')
path, price = sp.search(dataset)
self.assertEquals(price, 0)
self.assertEquals(len(path), 3)
self.assertEqual(path[0], Flight("QSA", "EFQ", 0, 0))
self.assertEqual(path[1], Flight("EFQ", "KCA", 1, 0))
self.assertEqual(path[2], Flight("KCA", "QSA", 2, 0))
dataset = DictDataset()
dataset.load_data('../input/3_airports_backtrace.csv')
path, price = sp.search(dataset)
self.assertEquals(price, 300)
self.assertEquals(len(path), 3)
self.assertEqual(path[0], Flight("PRG", "TXL", 0, 100))
self.assertEqual(path[1], Flight("TXL", "BCN", 1, 100))
self.assertEqual(path[2], Flight("BCN", "PRG", 2, 100))
dataset = DictDataset()
dataset.load_data('../input/4_airports_backtrace.csv')
path, price = sp.search(dataset)
self.assertEquals(price, 400)
self.assertEquals(len(path), 4)
self.assertEqual(path[0], Flight("PRG", "TXL", 0, 100))
self.assertEqual(path[1], Flight("TXL", "BCN", 1, 100))
self.assertEqual(path[2], Flight("BCN", "DEL", 2, 100))
self.assertEqual(path[3], Flight("DEL", "PRG", 3, 100))
def _shortest_path(self):
dists = {}
paths = {(self.start_city, 0): []}
visited = {(self.start_city, 0): []}
seen = {(self.start_city, 0): 0}
fringe = []
heappush(fringe, (0, 0, self.start_city))
while fringe:
(price, today, city_from) = heappop(fringe)
if (city_from, today) in dists:
continue
else:
dists[(city_from, today)] = price
# connections to start city MUST be on last day only
if city_from == self.start_city and today != 0:
break
flights = []
for city_to, flight_data in self.G[city_from].items():
possible_flights = [(data['weight'], data['day']) for _, data in flight_data.items() if
data['day'] == today]
if possible_flights:
best_flight = min(possible_flights, key=itemgetter(0))
flights.append((city_to, {'weight': best_flight[0], 'day': best_flight[1]}))
for city_to, flight_data in flights:
dist = dists[(city_from, flight_data['day'])] + flight_data['weight']
tomorrow = today + 1
if ((city_to, tomorrow) not in seen or dist < seen[(city_to, tomorrow)]) and city_to not in visited[
(city_from, today)]:
seen[(city_to, tomorrow)] = dist
paths[(city_to, tomorrow)] = paths[(city_from, today)] + [
Flight(city_from, city_to, today, flight_data['weight'])]
visited[(city_to, tomorrow)] = visited[(city_from, today)] + [city_to]
heappush(fringe, (dist, tomorrow, city_to))
return paths, dists
def _process_line(self, line):
lst = line.rstrip().split(' ')
return Flight(lst[0], lst[1], int(lst[2]), int(lst[3]))
def _format_path(self, path, dap):
formatted_path = []
for i, (city_from, city_to) in enumerate(zip(path[:-1], path[1:])):
formatted_path.append(
Flight(city_from, city_to, dap[i][0], dap[i][1]))
return formatted_path