def action(vehicle: util.Vehicle): riders = ii.riders rider = riders[vehicle.picked_up[0]] from_node = rider.from_node to_node = rider.to_node (shortest_path, shortest_time) = ii.floyd_path(from_node, to_node) time_slack = rider.deadline - rider.appear_slot - shortest_time if time_slack > 10: neighbor = st.gen_neighbor(shortest_path, time_slack) if len(neighbor) >= 2: best_expected = 0 best_pair = [-1, -1] for i in range(len(neighbor)): for j in range(len(neighbor)): if i == j: continue temp_expected = st.cal_expected_revenue( vehicle, neighbor[i], neighbor[j]) a_d = vehicle.slot + ii.floyd_path(vehicle.location, neighbor[i])[1] + \ ii.floyd_path(neighbor[i], neighbor[j])[1] + ii.floyd_path(neighbor[j], to_node)[1] if temp_expected > best_expected and a_d <= rider.deadline: best_expected = temp_expected best_pair[0], best_pair[1] = neighbor[i], neighbor[j] if best_pair != [-1, -1]: vehicle.pre_pickup = best_pair else: return
def check_feasible_3(v, s: int, drop:int ,ddl:int, slot:int) -> (list,bool): ddl_list = [] des = [] multiple_feasible = [] if v.load >= v.cap: return {}, False else: for rider in v.onboard: ddl_list.append(ii.riders[rider].deadline) des.append(ii.riders[rider].to_node) ddl_list.append(ddl) des.append(drop) for i in range(len(des)): for j in range(len(des)): if j == i: continue t_i = slot + ii.floyd_path(s, des[i])[1] / util.average_speed t_j = t_i + ii.floyd_path(des[i], des[j])[1] / util.average_speed for k in range(len(des)): if k == i or k == j: continue t_k = t_j + ii.floyd_path(des[j], des[k])[1] / util.average_speed if t_i <= ddl_list[i] and t_j <= ddl_list[j] and t_k <= ddl_list[k]: final_des = [des[i], des[j], des[k]] multiple_feasible.append((final_des, t_k)) if len(multiple_feasible) > 0: sorted(multiple_feasible, key=lambda x: x[1]) return multiple_feasible[0][0], True else: return [], False
def re_replan_route(self, des_list: int): self.route = ii.floyd_path(self.location, des_list[0])[0] for i in range(len(des_list) - 1): route = ii.floyd_path(des_list[i], des_list[i + 1])[0] if len(route) > 1: route.pop(0) self.route += route return
def cal_final_revenue(v) -> int: final_revenue = 0 for r in v.picked_up: ea = ii.riders[r].appear_slot + ii.floyd_path( ii.riders[r].from_node, ii.riders[r].to_node)[1] / util.average_speed a = v.drop_off_slot[r] print('delay:') print(a - ea) revenue = rate * ii.floyd_path( ii.riders[r].from_node, ii.riders[r].to_node)[1] - beta * (a - ea) final_revenue += revenue return final_revenue
def feasible1_check(pre1:int,drop1:int,pre2:int,d:int, ddl: int, time_1:int) -> dict: feasible_dict = {} min_i = time_1 + ii.floyd_path(pre1, drop1)[1] / util.average_speed time_i = time_1 + ii.floyd_path(pre1, drop1)[1] / util.average_speed time_d = time_i + (ii.floyd_path(drop1, pre2)[1] + ii.floyd_path(pre2,d)[1]) /util.average_speed feasible_dict[1] = (False if time_d > ddl else True) time_i = time_1 + (ii.floyd_path(pre1, pre2)[1] + ii.floyd_path(pre2, drop1)[1]) / util.average_speed time_d = time_i + ii.floyd_path(drop1, d)[1] / util.average_speed feasible_dict[2] = (False if time_d > ddl or time_i > (min_i + 20) else True) time_d = time_1 + (ii.floyd_path(pre1, pre2)[1] + ii.floyd_path(pre2, d)[1]) / util.average_speed time_i = time_d + ii.floyd_path(d, drop1)[1] / util.average_speed feasible_dict[3] = (False if time_d > ddl or time_i > (min_i + 20) else True) return feasible_dict
def stage_one(v: util.Vehicle): stage_2.stage_two(v) s = ii.riders[v.picked_up[0]].from_node d = ii.riders[v.picked_up[0]].to_node slot_t = ii.riders[v.picked_up[0]].deadline slot_0 = v.slot slot_list = [slot for slot in range(slot_0, slot_t + 1)] global hat_P, w_i, f hat_P = chp.cal_hat_P(slot_list) w_i = cr.cal_expected_revenue(v, hat_P, slot_list) for i in gm.nodes: for t in slot_list: f[(i, t)] = -1 for t in slot_list: if t >= slot_t: f[(d, t)] = cr.rate * ii.floyd_path(s, d)[1] - cr.beta * (t - slot_0) nodes = gm.nodes.copy() nodes.remove(d) slot_list = list(reversed(slot_list)) for t in slot_list: for i in nodes: for j in gm.out[i]: if t + gm.delta[(i, j)] <= slot_t: temp = hat_P[(i, t)] * w_i[(i, t)] + (1 - hat_P[ (i, t)]) * (f[(j, t + gm.delta[(i, j)])]) f[(i, t)] = max(f[(i, t)], temp) v.route = [s] t = slot_0 Backtrack(v, s, t) v.route = route.copy()
def gen_neighbor(shortest_path: list, time_slack: int = 10) -> list: neighbor = [] for i in range(len(shortest_path) - 1): for j in gen_map.nodes: if j not in neighbor and i and ii.floyd_path(i,j)[1] <= time_slack / 2: neighbor.append(j) dict1 = {} s = shortest_path[0] d = shortest_path[-1] max_dis = ii.floyd_path(s,d)[1] for i in neighbor: dict1[i] = ii.floyd_path(s, i)[1] dict1 = {k:v for k,v in dict1.items() if v < max_dis} sort_dict = dict(sorted(dict1.items(), key=lambda d: d[1], reverse=False)) neighbor = list(sort_dict.keys()) return neighbor
def update_pick(self,node1:int, des_order:dict): self.route = [] if len(self.picked_up) == 3: des_list = list(des_order.items()) self.route = ii.floyd_path(node1, des_list[0][1])[0] for i in range(len(des_list) - 1): list_temp = ii.floyd_path(des_list[i][1], des_list[i + 1][1])[0] if len(list_temp) > 1: list_temp.pop(0) self.route += list_temp return else: des_list = list(des_order.items()) shortest_path = ii.floyd_path(node1, des_list[0][1])[0] slack = ii.riders[des_list[0][0]].deadline - (self.slot + ii.floyd_path(node1, des_list[0][1])[1] / average_speed) neighbor = strategy.gen_neighbor(shortest_path, slack) best, best_node, temp = 0, 0 ,0 if len(neighbor) == 0: self.route = shortest_path list_temp = ii.floyd_path(des_list[0][1], des_list[1][1])[0] if len(list_temp) > 1: list_temp.pop(0) self.route += list_temp else: for node in neighbor: time = self.slot + ii.floyd_path(node1, node)[1] / average_speed temp = strategy.cal_best_one(self, node, int(time)) if temp > best: best_node = node if best_node == 0: self.route = shortest_path list_temp = ii.floyd_path(des_list[0][1], des_list[1][1])[0] if len(list_temp) > 1: list_temp.pop(0) self.route += list_temp else: self.route = ii.floyd_path(node1, best_node)[0] list_temp = ii.floyd_path(best_node, des_list[0][1])[0] if len(list_temp) > 1: list_temp.pop(0) self.route += list_temp list_temp = ii.floyd_path(des_list[0][1], des_list[1][1])[0] if len(list_temp) > 1: list_temp.pop(0) self.route += list_temp return
def replan_route(self, type: int): rider = self.picked_up[-1] d = ii.riders[self.picked_up[0]].to_node i = ii.riders[rider].from_node j = ii.riders[rider].to_node self.route = [] if type == 1: self.route = ii.floyd_path(i, j)[0] temp = ii.floyd_path(j, d)[0] if len(temp) > 1: temp.pop(0) self.route += temp else: self.route = ii.floyd_path(i, d)[0] temp = ii.floyd_path(d, j)[0] if len(temp) > 1: temp.pop(0) self.route += temp
def cal_last_one_revenue(v, drop_list, time, node) -> float: a_i_list = [] ea_i_list = [] dis_i = [] a_i = time revenue = 0 order_dict = {} for i in range(len(drop_list)): for rider in v.onboard: if ii.riders[rider].to_node == drop_list[i]: order_dict[i] = rider break if i not in order_dict.keys(): order_dict[i] = -1 order_dict = dict( sorted(order_dict.items(), key=lambda e: e[0], reverse=False)) for i in range(len(order_dict)): if order_dict[i] == -1: a_i_list.append(a_i + ii.floyd_path(node, drop_list[i])[1] / util.average_speed) ea_i_list.append(time + ii.floyd_path(node, drop_list[i])[1] / util.average_speed) dis_i.append(ii.floyd_path(node, drop_list[i])[1]) if order_dict[i] == v.onboard[0]: a_i_list.append(a_i + ii.floyd_path(node, drop_list[i])[1] / util.average_speed) ea_i_list.append( ii.riders[v.onboard[0]].appear_slot + ii.floyd_path(ii.riders[v.onboard[0]].from_node, ii.riders[ v.onboard[0]].to_node)[1] / util.average_speed) dis_i.append( ii.floyd_path(ii.riders[v.onboard[0]].from_node, ii.riders[v.onboard[0]].to_node)[1]) if order_dict == v.onboard[1]: a_i_list.append(a_i + ii.floyd_path(node, drop_list[i])[1] / util.average_speed) ea_i_list.append( ii.riders[v.onboard[1]].appear_slot + ii.floyd_path(ii.riders[v.onboard[1]].from_node, ii.riders[ v.onboard[1]].to_node)[1] / util.average_speed) dis_i.append( ii.floyd_path(ii.riders[v.onboard[1]].from_node, ii.riders[v.onboard[1]].to_node)[1]) node = drop_list[i] for i in range(len(a_i_list)): r = rate * dis_i[i] - beta * (a_i_list[i] - ea_i_list[i]) revenue += r return revenue
def cal_best_one(v, node: int, time:int) -> int: factor = 0 for drop in gen_map.nodes: ddl = time + ii.floyd_path(node, drop)[1] / util.average_speed + 40 (drop_list, flag) = fc.check_feasible_3(v, node, drop, ddl, time) if flag: w = cr.cal_last_one_revenue(v, drop_list, time, node) factor += cp.P_ij[node][drop][time] * w factor *= cp.P_i[node][time] return factor
def feasible2_check(type1: int,pre2, drop2, drop1, ddl_1, d, ddl, time_2 ) -> dict: ddl_2 = time_2 + ii.floyd_path(pre2, drop2)[1] / util.average_speed + 20 feasible_dict = {} if type1 == 3: d,drop1 = drop1,d ddl, ddl_1 = ddl_1, ddl time_j = time_2 + ii.floyd_path(pre2, drop2)[1] / util.average_speed time_i = time_j + ii.floyd_path(drop2, drop1)[1] / util.average_speed time_d = time_i + ii.floyd_path(drop1, d)[1] / util.average_speed feasible_dict[3] = (False if time_i > ddl_1 or time_d > ddl else True) time_i = time_2 + ii.floyd_path(pre2, drop1)[1] / util.average_speed time_j = time_i + ii.floyd_path(drop1, drop2)[1] / util.average_speed time_d = time_j + ii.floyd_path(drop2, d)[1] / util.average_speed feasible_dict[4] = (False if time_i > ddl_1 or time_j > ddl_2 or time_d > ddl else True) time_i = time_2 + ii.floyd_path(pre2, drop1)[1] / util.average_speed time_d = time_i + ii.floyd_path(drop1, d)[1] / util.average_speed time_j = time_d + ii.floyd_path(d, drop2)[1] / util.average_speed feasible_dict[5] = (False if time_i > ddl_1 or time_j > ddl_2 or time_d > ddl else True) return feasible_dict
def feasible_pick(v: util.Vehicle, rider: int) -> (list, bool): ddl_list = [] des = [] slot = v.slot s = ii.riders[rider].from_node multiple_feasible = [] if v.load >= v.cap: return [], False else: for rider in v.onboard: ddl_list.append(ii.riders[rider].deadline) des.append(ii.riders[rider].to_node) for i in range(len(des)): for j in range(len(des)): if j == i: continue t_i = slot + ii.floyd_path(s, des[i])[1] / util.average_speed t_j = t_i + ii.floyd_path(des[i], des[j])[1] / util.average_speed if len(des) == 3: for k in range(len(des)): if k == i or k == j: continue # final_des = OrderedDict() t_k = t_j + ii.floyd_path( des[j], des[k])[1] / util.average_speed dis = ii.floyd_path(des[j], des[k])[1] + ii.floyd_path(des[i], des[j])[1] + \ ii.floyd_path(s, des[i])[1] if t_i <= ddl_list[i] and t_j <= ddl_list[ j] and t_k <= ddl_list[k]: final_des = [des[i], des[j], des[k]] # final_des[v.onboard[i]] = des[i] # final_des[v.onboard[j]] = des[j] # final_des[v.onboard[k]] = des[k] multiple_feasible.append((final_des, dis)) else: # final_des = OrderedDict() dis = ii.floyd_path(des[i], des[j])[1] + ii.floyd_path( s, des[i])[1] if t_i <= ddl_list[i] and t_j <= ddl_list[j]: final_des = [des[i], des[j]] # final_des[v.onboard[i]] = des[i] # final_des[v.onboard[j]] = des[j] multiple_feasible.append((final_des, dis)) if len(multiple_feasible) > 0: multiple_feasible = sorted(multiple_feasible, key=lambda x: x[1], reverse=False) return multiple_feasible[0][0], True else: return [], False return [], False
def cal_pre2_revenue(v, type2, pre1, pre2, drop2, time2) -> float: d = ii.riders[v.picked_up[0]].to_node if type2 == 1: a_2 = time2 + ii.floyd_path(pre2, drop2)[1] / util.average_speed a_d = a_2 + ii.floyd_path(drop2, d)[1] / util.average_speed else: a_d = time2 + ii.floyd_path(pre2, d)[1] / util.average_speed a_2 = a_d + ii.floyd_path(d, drop2)[1] / util.average_speed ea_2 = time2 + ii.floyd_path(pre2, drop2)[1] / util.average_speed ea_d = v.slot + ii.floyd_path(v.location, d)[1] / util.average_speed r_2 = rate * ii.floyd_path(pre2, drop2)[1] - beta * (a_2 - ea_2) r_d = rate * ii.floyd_path(v.location, d)[1] - beta * (a_d - ea_d) return r_2 + r_d
def feasible1_set(d:int ,ddl: int, pre1: int, time_1: int, pre2: int) -> dict: order_dict = {} return_dict = {} for drop1 in gen_map.nodes: dis1 = ii.floyd_path(pre1, drop1)[1] + ii.floyd_path(drop1, pre2)[1] + ii.floyd_path(pre2, d)[1] dis2 = ii.floyd_path(pre1, pre2)[1] + ii.floyd_path(pre2, drop1)[1] + ii.floyd_path(drop1, d)[1] dis3 = ii.floyd_path(pre1, pre2)[1] + ii.floyd_path(pre2, d)[1] + ii.floyd_path(d, drop1)[1] order_dict[1], order_dict[2], order_dict[3] = dis1, dis2, dis3 feasible_dict = feasible1_check(pre1,drop1,pre2,d, ddl, time_1) if True not in feasible_dict.values(): continue elif False not in feasible_dict.values(): type1 = sorted(order_dict.items(), key = lambda d:d[1],reverse=False)[0][0] else: true_key = [k for k,v in feasible_dict.items() if v == True] true_dict = {k:v for k,v in order_dict.items() if k in true_key} type1 = sorted(true_dict.items(), key=lambda d: d[1], reverse=False)[0][0] return_dict[drop1] = type1 return return_dict
def update_first(self): self.route = [self.location] from_node = ii.riders[self.picked_up[0]].from_node self.route.append(from_node) if len(self.pre_pickup) > 0: from_node = ii.riders[self.picked_up[-1]].from_node to_node = self.pre_pickup[0] self.route += ii.floyd_path(from_node, to_node)[0] from_node = to_node if len(self.pre_pickup) > 1: for i in range(1, len(self.pre_pickup)): from_node = self.pre_pickup[i-1] to_node = self.pre_pickup[i] self.route += ii.floyd_path(from_node, to_node)[0] from_node = to_node to_node = ii.riders[self.picked_up[0]].to_node self.route += ii.floyd_path(from_node, to_node)[0] temp_route = self.route.copy() n = 0 nums = len(self.route) - 1 for i in range(nums): if temp_route[i] == temp_route[i+1]: self.route.pop(i - n) n += 1
def gen_ori_riders() -> list: df = pd.DataFrame(columns=('tpep_pickup_datetime', 'tpep_dropoff_datetime', 'PULocationID', 'DOLocationID', 'day')) for k in range(50000): t_p = randint(0, slot_nums - 1) pickup = choice(nodes) drop_off = choice(nodes) d = randint(1, days) min_travel_time = ii.floyd_path(pickup, drop_off)[1] / util.average_speed t_d = t_p + int(min_travel_time) df.loc[k] = [t_p, t_d, pickup, drop_off, d] df.to_csv(r'data\self_gen_riders.csv', index=False, header=True, float_format='%d')
def check(v: util.Vehicle, pre, drop, slot) -> (int, bool): d = ii.riders[v.picked_up[0]].to_node ddl_d = ii.riders[v.picked_up[0]].deadline ddl_drop = slot + ii.floyd_path(pre, drop)[1] / util.average_speed + 40 path_1 = ii.floyd_path(pre, drop)[1] + ii.floyd_path(drop, d)[1] a_d_1 = slot + path_1 / util.average_speed a_drop_1 = slot + ii.floyd_path(pre, drop)[1] / util.average_speed path_2 = ii.floyd_path(pre, d)[1] + ii.floyd_path(d, drop)[1] a_drop_2 = slot + path_2 / util.average_speed a_d_2 = slot + ii.floyd_path(pre, d)[1] / util.average_speed if check_feasible(a_d_1, ddl_d, a_drop_1, ddl_drop): if check_feasible(a_d_2, ddl_d, a_drop_2, ddl_drop): if a_d_1 + a_drop_1 < a_d_2 + a_drop_2: return 1, True else: return 2, True else: return 1, True else: if check_feasible(a_d_2, ddl_d, a_drop_2, ddl_drop): return 2, True else: return 0, False
def routing_stage(s, node1: int, node2: int) -> list: if ii.floyd_path(s, node1)[1] + ii.floyd_path(node1, node2)[1] > ii.floyd_path(s, node2)[1] + \ ii.floyd_path(node2, node1)[1]: return [node2, node1] else: return [node1, node2]
def cal_expected_revenue(vehicle, node1: int, node2: int) -> int: first_rider = ii.riders[vehicle.picked_up[0]] time = first_rider.appear_slot s = first_rider.from_node d = first_rider.to_node ddl = first_rider.deadline pre_pickup = routing_stage(s,node1, node2) pre1, pre2 = pre_pickup[0], pre_pickup[1] time_1 = ii.floyd_path(s, pre1)[1] / util.average_speed + time expected_revenue = cp.P_i[pre1][int(time_1)] set1_dict = fc.feasible1_set(d, ddl, pre1, time_1, pre2) temp1 = 0 P, P1, P2, P3 = 0, 0, 0, 0 for drop1,type1 in set1_dict.items(): time_2 = cal_time_2(type1, pre1, drop1, pre2, time_1) ddl_1 = time_1 + ii.floyd_path(pre1, drop1)[1] / util.average_speed + 20 set2_dict = fc.feasible2_set(type1,d,ddl, drop1, ddl_1, pre2, time_2) temp2 = 0 infeasible_drop2 = set(gen_map.nodes) ^ set(set2_dict.keys()) term1 = 1 - cp.P_i[pre2][int(time_2)] w = cr.cal_pre1_revenue(vehicle, type1, pre1, drop1,time_1, pre2, d) for drop2 in infeasible_drop2: P1 += cp.P_ij[pre2][drop2][int(time_2)] term = w * P1 * cp.P_i[pre2][int(time_2)] + term1 * w P1 = P1 * cp.P_i[pre2][int(time_2)] for drop2,type2 in set2_dict.items(): w = cr.cal_two_revenue(vehicle, type1,type2, pre1,drop1,time_1, pre2,drop2, time_2, d) temp2 += w * cp.P_ij[pre2][drop2][int(time_2)] P2 += cp.P_ij[pre2][drop2][int(time_2)] temp2 = temp2 * cp.P_i[pre2][int(time_2)] temp1 += cp.P_ij[pre1][drop1][int(time_1)] * temp2 temp1 += cp.P_ij[pre1][drop1][int(time_1)] * term P2 = P2 * cp.P_i[pre2][int(time_2)] P += (P1 + P2 + term1) * cp.P_ij[pre1][drop1][int(time_1)] expected_revenue *= temp1 P *= cp.P_i[pre1][int(time_1)] factor2 = 1 - cp.P_i[pre1][int(time_1)] temp4 = 0 rest = set(gen_map.nodes) ^ set(set1_dict.keys()) for drop1 in rest: temp4 += cp.P_ij[pre1][drop1][int(time_1)] factor2 = factor2 + cp.P_i[pre1][int(time_1)] * temp4 P4 = factor2 # factor2 += cp.P_i[pre1][int(time_1)] * cp.P_ij[pre2][drop1][int(time_1)] time_2 = time_1 + ii.floyd_path(pre1, pre2)[1] / util.average_speed set2_dict = fc.feasible2_set(1, d, ddl, 0, 0, pre2, time_2) factor2 *= cp.P_i[pre2][int(time_2)] temp = 0 P5 = 0 for drop2,type2 in set2_dict.items(): P5 += cp.P_ij[pre2][drop2][int(time_2)] w = cr.cal_pre2_revenue(vehicle,type2, pre1, pre2, drop2, time_2) temp += w * cp.P_ij[pre2][drop2][int(time_2)] P5 *= cp.P_i[pre2][int(time_2)] P = P + P4 + P5 factor2 *= temp expected_revenue += factor2 no_ride_sharing_revenue = P * cr.cal_no_revenue(vehicle,pre1, pre2, d) expected_revenue += no_ride_sharing_revenue return expected_revenue
def cal_time_2(type1:int, pre1:int,drop1:int,pre2:int,time_1:int) -> int: if type1 == 1: time_2 = time_1 + (ii.floyd_path(pre1, drop1)[1] + ii.floyd_path(drop1, pre2)[1]) / util.average_speed else: time_2 = time_1 + (ii.floyd_path(pre1, pre2)[1]) / util.average_speed return time_2
def feasible2_set(type1:int,d:int,ddl:int, drop1: int,ddl_1:int, pre2: int, time_2: int) -> dict: order_dict = {} return_dict = {} if type1 == 1: for drop2 in gen_map.nodes: true_dict = {1:True, 2:True} dis_dict = {} dis1 = ii.floyd_path(pre2, drop2)[1] + ii.floyd_path(drop2, d)[1] dis_dict[1] = dis1 if time_2 + dis1 / util.average_speed > ddl: true_dict[1] = False dis2 = ii.floyd_path(pre2, d)[1] + ii.floyd_path(d, drop2)[1] dis_dict[2] = dis2 if time_2 + ii.floyd_path(pre2, d)[1] /util.average_speed > ddl or time_2 + dis2 /util.average_speed > \ time_2 + ii.floyd_path(pre2, drop2)[1] /util.average_speed + 40: true_dict[2] = False if True not in true_dict.values(): continue else: true_key = [k for k, v in true_dict.items() if v == True] true_dict = {k: v for k, v in dis_dict.items() if k in true_key} type2 = sorted(true_dict.items(), key=lambda d: d[1], reverse=False)[0][0] return_dict[drop2] = type2 return return_dict elif type1 == 3: d,drop1 = drop1,d ddl,ddl_1 = ddl_1,ddl for drop2 in gen_map.nodes: dis1 = ii.floyd_path(pre2, drop2)[1] + ii.floyd_path(drop2, drop1)[1] + ii.floyd_path(drop1, d)[1] dis2 = ii.floyd_path(pre2, drop1)[1] + ii.floyd_path(drop1, drop2)[1] + ii.floyd_path(drop2, d)[1] dis3 = ii.floyd_path(pre2, drop1)[1] + ii.floyd_path(drop1, d)[1] + ii.floyd_path(d, drop2)[1] order_dict[3], order_dict[4], order_dict[5] = dis1, dis2, dis3 feasible_dict = feasible2_check(type1, pre2, drop2, drop1, ddl_1, d, ddl, time_2) if True not in feasible_dict.values(): continue elif False not in feasible_dict.values(): type2 = sorted(order_dict.items(), key = lambda d:d[1],reverse=False)[0][0] else: true_key = [k for k, v in feasible_dict.items() if v == True] true_dict = {k:v for k, v in order_dict.items() if k in true_key} type2 = sorted(true_dict.items(), key=lambda d: d[1], reverse=False)[0][0] return_dict[drop2] = type2 return return_dict
def cal_pickup_revenue(v, slot_list) -> dict: s = ii.riders[v.picked_up[0]].from_node d = ii.riders[v.picked_up[0]].to_node t_0 = ii.riders[v.picked_up[0]].appear_slot ea_d = t_0 + ii.floyd_path(s, d)[1] / util.average_speed w_ij = {} for i in gen_map.nodes: for j in gen_map.nodes: for slot in slot_list: (type, flag) = s2.feasible_dict[(i, j, slot)] if flag: if type == 1: path_1 = ii.floyd_path(i, j)[1] + ii.floyd_path(j, d)[1] a_d_1 = slot + path_1 / util.average_speed w_ij[(i, j, slot)] = rate * ii.floyd_path( i, j)[1] + rate * ii.floyd_path(s, d)[1] w_ij[(i, j, slot)] -= beta * (a_d_1 - ea_d) else: path_2 = ii.floyd_path(i, d)[1] + ii.floyd_path(d, j)[1] a_d_2 = slot + ii.floyd_path(i, d)[1] / util.average_speed a_drop_2 = slot + path_2 / util.average_speed ea_drop_2 = slot + ii.floyd_path( i, j)[1] / util.average_speed w_ij[(i, j, slot)] = rate * ii.floyd_path( s, d)[1] - beta * (a_d_2 - ea_d) w_ij[(i, j, slot)] += rate * ii.floyd_path( i, j)[1] / util.average_speed - beta * (a_drop_2 - ea_drop_2) return w_ij
def cal_pre1_revenue(v, type1, pre1, drop1, time_1, pre2, d) -> float: if type1 == 1: a_1 = time_1 + ii.floyd_path(pre1, drop1)[1] / util.average_speed a_d = a_1 + (ii.floyd_path(drop1, pre2)[1] + ii.floyd_path(pre1, drop1)[1]) / util.average_speed elif type1 == 2: a_1 = time_1 + (ii.floyd_path(pre1, pre2)[1] + ii.floyd_path(pre2, drop1)[1]) / util.average_speed a_d = a_1 + ii.floyd_path(drop1, d)[1] / util.average_speed else: a_d = time_1 + (ii.floyd_path(pre1, pre2)[1] + ii.floyd_path(pre2, d)[1]) / util.average_speed a_1 = a_d + ii.floyd_path(d, drop1)[1] / util.average_speed ea_1 = time_1 + ii.floyd_path(pre1, drop1)[1] / util.average_speed ea_d = v.slot + ii.floyd_path(v.location, d)[1] / util.average_speed er_1 = rate * ii.floyd_path(pre1, drop1)[1] - beta * (a_1 - ea_1) er_d = rate * ii.floyd_path(v.location, d)[1] - beta * (a_d - ea_d) return er_1 + er_d
def cal_two_revenue(v, type1, type2, pre1, drop1, time1, pre2, drop2, time2, d: int) -> float: if type2 == 1: a_1 = time1 + ii.floyd_path(pre1, drop1)[1] / util.average_speed a_2 = time2 + ii.floyd_path(pre2, drop2)[1] / util.average_speed a_d = a_2 + ii.floyd_path(drop2, d)[1] / util.average_speed elif type2 == 2: a_1 = time1 + ii.floyd_path(pre1, drop1)[1] / util.average_speed a_d = time2 + ii.floyd_path(pre2, d)[1] / util.average_speed a_2 = a_d + ii.floyd_path(d, drop2)[1] / util.average_speed if type1 == 2: if type2 == 3: a_2 = time2 + ii.floyd_path(pre2, drop2)[1] / util.average_speed a_1 = a_2 + ii.floyd_path(drop2, drop1)[1] / util.average_speed a_d = a_1 + ii.floyd_path(drop1, d)[1] / util.average_speed elif type2 == 4: a_1 = time2 + ii.floyd_path(pre2, drop1)[1] / util.average_speed a_2 = a_1 + ii.floyd_path(drop1, drop2)[1] / util.average_speed a_d = a_2 + ii.floyd_path(drop2, d)[1] / util.average_speed elif type2 == 5: a_1 = time2 + ii.floyd_path(pre2, drop1)[1] / util.average_speed a_d = a_1 + ii.floyd_path(drop1, d)[1] / util.average_speed a_2 = a_d + ii.floyd_path(d, drop2)[1] / util.average_speed elif type1 == 3: if type2 == 3: a_2 = time2 + ii.floyd_path(pre2, drop2)[1] / util.average_speed a_d = a_2 + ii.floyd_path(drop2, d)[1] / util.average_speed a_1 = a_d + ii.floyd_path(d, drop1)[1] / util.average_speed elif type2 == 4: a_d = time2 + ii.floyd_path(pre2, d)[1] / util.average_speed a_2 = a_d + ii.floyd_path(d, drop2)[1] / util.average_speed a_1 = a_2 + ii.floyd_path(drop2, drop1)[1] / util.average_speed elif type2 == 5: a_d = time2 + ii.floyd_path(pre2, d)[1] / util.average_speed a_1 = a_d + ii.floyd_path(drop1, d)[1] / util.average_speed a_2 = a_1 + ii.floyd_path(d, drop2)[1] / util.average_speed ea_1 = time1 + ii.floyd_path(pre1, drop1)[1] / util.average_speed er_1 = rate * ii.floyd_path(pre1, drop1)[1] - beta * (a_1 - ea_1) ea_2 = time2 + ii.floyd_path(pre2, drop2)[1] / util.average_speed er_2 = rate * ii.floyd_path(pre2, drop2)[1] - beta * (a_2 - ea_2) ea_d = v.slot + ii.floyd_path(v.location, d)[1] / util.average_speed er_d = rate * ii.floyd_path(v.location, d)[1] - beta * (a_d - ea_d) return er_1 + er_2 + er_d
def cal_no_revenue(v, pre1, pre2, d) -> float: ea_d = v.slot + ii.floyd_path(v.location, d)[1] / util.average_speed a_d = v.slot + (ii.floyd_path(v.location, pre1)[1] + ii.floyd_path(pre1, pre2)[1] + ii.floyd_path(pre2, d)[1]) \ / util.average_speed return rate * (ii.floyd_path(v.location, d)[1]) - beta * (a_d - ea_d)