def single_source_dijkstra(road_network, start):
"""
Compute the shortest paths from a vertex, whose id is start, to all other vertices using Dijkstra's algorithm.
:param road_network: RoadNetwork
:param start: int
:return: dict[int, int]
the "came from" array
"""
import time
start_time = time.clock()
frontier = PriorityQueue()
frontier.put(start, 0)
came_from = dict()
cost_so_far = dict()
came_from[start] = None
cost_so_far[start] = 0
while not frontier.empty():
current = frontier.get()
for neighbor in road_network.get_neighbors(current):
new_cost = cost_so_far[current] + road_network.get_weight(
current, neighbor)
if neighbor not in cost_so_far or new_cost < cost_so_far[neighbor]:
cost_so_far[neighbor] = new_cost # relax
priority = new_cost
frontier.put(neighbor, priority)
came_from[neighbor] = current
print("Elapsed time is %f seconds." % (time.clock() - start_time))
return came_from
def get_shortest_path(road_network, s_vid, e_vid):
"""
Return the shortest path from vertex s_vid to vertex e_vid using A* algorithm.
If s_vid-->e_vid is unreachable, return None.
:param road_network: RoadNetwork
:param s_vid: int
:param e_vid: int
:return: Path
"""
frontier = PriorityQueue()
frontier.put(s_vid, 0)
came_from = dict()
cost_so_far = dict()
came_from[s_vid] = None
cost_so_far[s_vid] = 0
while not frontier.empty():
current = frontier.get()
# Take a look at the number of lines of code:) date: 2016/12/13 23:12
if current == e_vid:
break
for neighbor in road_network.get_neighbors(current):
new_cost = cost_so_far[current] + road_network.get_weight(
current, neighbor)
if neighbor not in cost_so_far or new_cost < cost_so_far[neighbor]:
cost_so_far[neighbor] = new_cost
priority = new_cost + road_network.get_straight_distance(
neighbor, e_vid)
frontier.put(neighbor, priority)
came_from[neighbor] = current
return construct_path(road_network, s_vid, e_vid, came_from)
def greedy_bfs(road_network, s_vid, e_vid):
"""
Return the shortest path from vertex s_vid to vertex e_vid using Greedy-Best-First-Search.
In Greedy-BFS, the heuristic function is road_network.get_straight_distance().
:param road_network: RoadNetwork
:param s_vid: int
:param e_vid: int
:return: Path
"""
frontier = PriorityQueue()
frontier.put(s_vid, 0)
came_from = dict()
came_from[s_vid] = None
while not frontier.empty():
current = frontier.get()
if current == e_vid:
break
for neighbor in road_network.get_neighbors(current):
if neighbor not in came_from:
priority = road_network.get_straight_distance(neighbor, e_vid)
frontier.put(neighbor, priority)
came_from[neighbor] = current
return construct_path(road_network, s_vid, e_vid, came_from)
def dijkstra(road_network, s_vid, e_vid):
"""
Return the exact shortest path from vertex s_vid to vertex e_vid using Dijkstra's algorithm.
:param road_network: RoadNetwork
:param s_vid: int
:param e_vid: int
:return: Path
"""
frontier = PriorityQueue()
frontier.put(s_vid, 0)
came_from = dict()
cost_so_far = dict()
came_from[s_vid] = None
cost_so_far[s_vid] = 0
while not frontier.empty():
current = frontier.get()
if current == e_vid:
break
for neighbor in road_network.get_neighbors(current):
new_cost = cost_so_far[current] + road_network.get_weight(
current, neighbor)
if neighbor not in cost_so_far or new_cost < cost_so_far[neighbor]:
cost_so_far[neighbor] = new_cost # relax
priority = new_cost
frontier.put(neighbor, priority)
came_from[neighbor] = current
return construct_path(road_network, s_vid, e_vid, came_from)
def search_path(self):
frontier = PriorityQueue()
frontier.put(self.start_node, 0)
came_from = {}
cost_so_far = {}
visited_site = {}
came_from[self.start_node] = None
cost_so_far[self.start_node] = 0
self.real_end_node = None
s_t = time.clock()
while not frontier.empty():
if time.clock() - s_t > 60:
print("search path time out.")
return []
current = frontier.get() # type: Node
cur_site = (current.xid, current.yid)
if current.xid == self.target_xid and current.yid == self.target_yid:
self.real_end_node = current
break
# inspect five (include itself) neighbors
neighbors = self._get_neighbors(current)
for nb in neighbors:
new_cost = cost_so_far[current] + self._get_cost(current, nb)
next_site = (nb.xid, nb.yid)
if nb not in cost_so_far or new_cost < cost_so_far[nb]:
if next_site == cur_site and next_site in visited_site:
cost_so_far[nb] = new_cost + 2
else:
cost_so_far[nb] = new_cost
visited_site[next_site] = (nb.hour, nb.step)
priority = cost_so_far[nb] + self.heuristic(
nb, self.end_node)
frontier.put(nb, priority)
came_from[nb] = current
if self.real_end_node is None:
return []
path = [self.real_end_node]
now = self.real_end_node
while came_from[now] is not None:
now = came_from[now]
path.append(now)
path.reverse()
return path
def load_query():
"""
Load taxi queries from file.
:return: PriorityQueue[(int, Query)]
:rtype: [dict[int, Query], PriorityQueue]
"""
from datetime import datetime
import time
print("Loading queries and create query queue (will take about 20 sec)...")
start_time = time.clock()
query_set = dict()
query_queue = PriorityQueue()
start_time_tuple = datetime.strptime('00:00:00', '%H:%M:%S')
identifier = 0
i = 0
file_list = os.listdir("./data/queries")
for file_name in file_list:
i += 1
print("Loading the %d-th file..." % i)
cur_file = open("./data/queries/" + file_name)
for line in cur_file:
[time_str, ori_lat, ori_lon, des_lat, des_lon] = line.split(',')
time_tuple = datetime.strptime(time_str, '%H:%M:%S')
timestamp = (time_tuple - start_time_tuple).seconds + 1
if timestamp < SIM_START_TIME or timestamp > SIM_END_TIME:
continue
ori_lat = float(ori_lat)
ori_lon = float(ori_lon)
des_lat = float(des_lat)
des_lon = float(des_lon)
origin = Location(ori_lat, ori_lon)
destination = Location(des_lat, des_lon)
query = Query(identifier, timestamp, origin, destination)
query_set[identifier] = query
query_queue.put(query, timestamp)
identifier += 1
cur_file.close()
print("Done. Elapsed time is %f seconds" % (time.clock() - start_time))
return [query_set, query_queue]
def run(self):
print("The simulation system is running...")
start_time = time.clock()
waiting_queries = PriorityQueue()
for timestamp in range(SIM_START_TIME, SIM_END_TIME + 1):
print("Time: %d" % timestamp)
# Catch the queries to be processed in this timestamp. The queries consists of two parts:
# 1. queries that happened in this timestamp
# 2. queries that stranded in previous timestamps
while not self.query_queue.empty():
new_query = self.query_queue.get()
if new_query.timestamp == timestamp:
waiting_queries.put(new_query, new_query.timestamp)
else:
self.query_queue.put(new_query, new_query.timestamp)
break
while not self.dispatcher.failed_queries.empty():
old_query = self.dispatcher.failed_queries.get()
waiting_queries.put(old_query, old_query.timestamp)
# Process the queries.
while not waiting_queries.empty():
query = waiting_queries.get()
if query.status == CANCELLED:
self.dispatcher.add_cancelled_query(query)
else:
self.dispatcher.dispatch_taxi(timestamp, query, self.db,
self.taxi_set,
self.road_network)
# Update the status of all the queries
for query in self.query_set.values():
if query.timestamp <= timestamp and query.status == WAITING:
query.update_status(timestamp)
# All the taxis drive according to their schedule.
for taxi in self.taxi_set.values():
taxi.drive(timestamp, self.road_network, self.dispatcher,
self.query_set, self.db)
print("The simulation is end. Elapsed time is %f." %
(time.clock() - start_time))
def search_path_greedy_best_first(self):
frontier = PriorityQueue()
frontier.put(self.start_node, 0)
came_from = dict()
came_from[self.start_node] = None
self.real_end_node = None
s_t = time.clock()
while not frontier.empty():
if time.clock() - s_t > 60:
print("search path time out.")
return []
current = frontier.get() # type: Node
if current.xid == self.target_xid and current.yid == self.target_yid:
self.real_end_node = current
break
# inspect five (include itself) neighbors
neighbors = self._get_neighbors(current)
for nb in neighbors:
if nb not in came_from:
priority = self.heuristic(nb, self.end_node)
frontier.put(nb, priority)
came_from[nb] = current
if self.real_end_node is None:
return []
path = [self.real_end_node]
now = self.real_end_node
while came_from[now] is not None:
now = came_from[now]
path.append(now)
path.reverse()
return path
total_num_df_online, total_num_alg_online = 0.0, 0.0
total_cost_df_offline, total_cost_alg_offline, total_cost_opt = 0.0, 0.0, 0.0
total_num_df_offline, total_num_alg_offline, total_num_opt = 0.0, 0.0, 0.0
for round_id in range(0, rounds):
# Generate the input
[job_set, pm_set, ele_price] = load_data(num_jobs,
num_slots) # real-trace input
# Put all the jobs into a priority queue with start time of the job as the priority
pq = PriorityQueue()
for i in job_set:
job = job_set[i]
pq.put(job, job.start_time)
# Init the online algorithms
num_pms = len(job_set)
online_alg = OnlineSolver(num_pms, num_slots, ele_price)
online_df = OnlineDemandFirst(num_pms, num_slots, ele_price)
opt_lb = ILPSolver(job_set, pm_set, ele_price)
# Init the offline algorithms and run
solver = OfflineSolver()
solver.solve_offline_demand_first(copy.deepcopy(job_set), pm_set,
ele_price)
cost_df_offline = solver.evaluate(pm_set, ele_price)
num_df_offline = solver.evaluate_pm_number()
solver.reset(pm_set)
def run(self):
start_time = time.clock()
query_num = len(self.query_set)
print "query to be processed NUM:", query_num
processed_order = 0
query_sum_dist = 0
waiting_queries = PriorityQueue()
for timestamp in range(SIM_START_TIME, SIM_END_TIME + 1):
print("Time: %d" % timestamp)
sim_start_time = time.clock()
# Catch the queries to be processed in this timestamp. The queries consists of two parts:
# 1. queries that happened in this timestamp
# 2. queries that stranded in previous timestamps
while not self.query_queue.empty():
new_query = self.query_queue.get()
if new_query.timestamp == timestamp:
waiting_queries.put(new_query, new_query.timestamp)
else:
self.query_queue.put(new_query, new_query.timestamp)
break
while not self.dispatcher.failed_queries.empty():
old_query = self.dispatcher.failed_queries.get()
waiting_queries.put(old_query, old_query.timestamp)
# Process the queries.
while not waiting_queries.empty():
query = waiting_queries.get()
if query.status == CANCELLED:
self.dispatcher.add_cancelled_query(query)
else:
if DEBUG_MODEL:
print "......To process query:", query.id
print "origin: %s ---> dest:%s" % (query.o_geohash,
query.d_geohash)
print "[%f, %f]----->[%f,%f]" % (
query.pickup_window.early,
query.pickup_window.late,
query.delivery_window.early,
query.delivery_window.late)
print "[%f, %f]----->[%f,%f]" % (
query.origin.lon, query.origin.lat,
query.destination.lon, query.destination.lat)
print "dist:", get_distance(query.origin,
query.destination)
flag_suc = self.dispatcher.dispatch_taxi(
timestamp, query, self.db, self.taxi_set,
self.road_network, self.query_set)
if flag_suc:
processed_order += 1
query_sum_dist += get_distance(query.origin,
query.destination)
print "order Num:", processed_order
print "order Dist:", query_sum_dist
if processed_order > 0 and processed_order % 100 == 0:
self.print_load(processed_order)
# Update the status of all the queries
for query in self.query_set.values():
if query.timestamp <= timestamp and query.status == WAITING:
query.update_status(timestamp)
# All the taxis drive according to their schedule.
for taxi in self.taxi_set.values():
taxi.drive(timestamp, self.road_network, self.dispatcher,
self.query_set, self.db)
print "Done in %f seconds" % (time.clock() - sim_start_time)
[max, min, count] = self.print_utility()
print("after:"), max - min, (" count:"), count
print("satisfy ratio:"), self.print_satisfy(query_num)
for load in self.maxLoad:
print load, " "
for load in self.sumLoad:
print load, " "
print("The simulation is end. Elapsed time is %f." %
(time.clock() - start_time))
winsound.Beep(600, 1000)
