def view_package_bundle(text, bundle, time): h, m, s = time now = datetime.datetime.now() # Truck IDs are indicated by the first parameter in the Truck object, and their leaving time # has been pre-calculated to fit the constraints of the project. check_time is derived from # user input to stop a Truck during the greedy algorithm comparisons. check_time = now.replace(hour=h, minute=m, second=s) ds.package_delivery(Truck(1, now.replace(hour=8, minute=0, second=0)), first_bundle, check_time) ds.package_delivery(Truck(2, now.replace(hour=9, minute=5, second=0)), second_bundle, check_time) ds.package_delivery(Truck(3, now.replace(hour=10, minute=0, second=0)), third_bundle, check_time) # Prints package information print("\n\t▪■▪", text, check_time.strftime("%H:%M:%S"), "▪■▪") print("{:<5}{:<41}{:<19}{:<8}{:<8}{:<11}{:<8}{:<19}{}".format( "ID", "Address", "City", "State", "Zip", "Deadline", "Kilos", "Status", "Note")) for id_ in bundle: package = ds.package_hash_table.search_package_by_id(id_) print(package) # Resets package status to default package.status = Package.AT_FACILITY print()
def test_get_next_product_id(self): truck = Truck([5, 7, 0, 3], [3, 2, 4, 1]) expected = [3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0] for expect in expected: product_id = truck.get_next_product_id() self.assertEqual(product_id, expect) truck.pop_product()
def load_truck_with_packages(self, truck: Truck, packages: List[Package], time: datetime) -> Truck: if truck.can_load(len(packages)): for package in packages: self.update_package_status(package, PackageStatus.ON_TRUCK, time) truck.load_package(package) return truck
def return_to_hub(truck: Truck): #Returns truck to HUB. Trucks status is updated. Current destination is set to HUB's location ID. Distance to next #delivery is set to weight between current location and HUB. del_str = "Returning to HUB " print(truckUpdate + del_str) truck.current_destination = HUB update_delivery_status(truck) if(len(truck.package_list) > 0): the_hash.update_pkg(truck.package_list[0]) truck.distance_to_next_delivery = the_graph.return_weight_with_id(truck.package_list.pop(0).location_id, 0)
def sort_packages(the_truck: Truck): #Sort function begins by sorting all packages with early delivery #to the front of the package_list using a bubble sort. The next step #is to group any packages with the same destination. The final step is #to bubble sort all packages, starting with the first EOD delivery, based #on nearest neighbor. def sort_for_early_delivery(package_list): #Bubblesort the package_list to sort by deadline. If iterate through list and compare #based on deadline. If deadline is less move towards the front of the list. index_of_last_nonEOD = 0 for i in range(len(package_list)): if(package_list[i].deadline != "EOD"): index_of_last_nonEOD = i for j in range(len(package_list)-i - 1): if(package_list[j].getDeadline() > package_list[j+1].getDeadline()): later_pkg = package_list[j] package_list[j] = package_list[j+1] package_list[j+1] = later_pkg return index_of_last_nonEOD def sort_for_duplicate_locations(package_list): #Iterate through package_list and group all packages #with the same location_id for i in range(len(package_list)): for j in range(i+2, len(package_list)): if package_list[i].location_id == package_list[j].location_id: temp = package_list[j] package_list.remove(temp) package_list.insert(i, temp) return 0 #Use bubble sort to arrange packages by nearest neighbor. #Packages are already sorted by deadline. Start with final non-EOD #package and then find nearest neighbor by comparing the returned value #from the return_weight_with_id function. start = sort_for_early_delivery(the_truck.package_list) sort_for_duplicate_locations(the_truck.package_list) for i in range(start,len(the_truck.package_list)): for j in range(i, len(the_truck.package_list) - i - 1): if the_graph.return_weight_with_id(i, j) > the_graph.return_weight_with_id(i, j+1): temp = the_truck.package_list[j] the_truck.package_list[j] = the_truck.package_list[j + 1] the_truck.package_list[j + 1] = temp return 0
def __init__(self): self._trucks = [] truck = Truck(1) self._trucks.append(truck) # holding this truck at the hub until delayed packages arrive truck = Truck(2) truck.clock = datetime.now().replace(hour=9, minute=5, second=0, microsecond=0) self._trucks.append(truck)
def getBestPlan(trunk: Truck, orders: List[Order]): actions = [] for order in orders: action = Action(order) order.setAction(action) actions.append(action) plan_1 = Plan(len(actions), actions) plan_2 = Plan(len(actions), actions) plan_3 = Plan(len(actions), actions) best_plan = Plan.getBestOfPlans(plan_1, plan_2, plan_3) trunk.setPlan(best_plan) return best_plan
def initialize(self): self.status = 'INIT' ## all cities self.cities = City.load() ## opend cities self.accessible_cities = self.cities for city in self.cities: city.add_cargos(Cargo.generate(city, self.cities, 5)) ## owned trucks self.trucks = Truck.load() self.cur_city = self.cities[0] self.cur_truck = None self._map = Map(self.cities) fm_map = MapForm(self) fm_trucks = TruckList(self, []) fm_menu = Menu(self) fm_city = CityForm(self) fm_cargo = CargoList(self, []) fm_wild = WildForm(self) self.forms.append(fm_map) self.forms.append(fm_trucks) self.forms.append(fm_menu) self.forms.append(fm_city) self.forms.append(fm_cargo) self.forms.append(fm_wild) self.cur_form = 3 self.focus = self.forms[self.cur_form].focus() self.refresh_truck()
def __init__(self, timeLimit, ID, code, startLocation, destination, latitude, longitude): self.truck = Truck(ID, code, startLocation, destination, latitude, longitude) self.timeLimit = timeLimit self.setRoute() self.GUI = GUI()
def animate(problem, filename, num_trucks): with open(path + filename + ".txt") as f: customers = import_customers(problem + ".txt", False) Distances.calculate_matrix(customers) lines = f.readlines() ids = [] for line in lines[5:]: ids.append(line.split()[3:]) routes = [] for line in ids: route = [] for cust_number in line: route.append((customers[int(cust_number) - 1])) routes.append(route) truck_lists = [] for i in range(len(routes)): if i % num_trucks == 0: truck_lists.append([]) truck_lists[-1].append( Truck(i % num_trucks, 0, 0, len(routes), Path(routes[i]))) for trucks in truck_lists: State(trucks).plot() time.sleep(.3)
def multiple_pkgs_same_address(truck: Truck): #Handles multiple deliveries to same address. While all_pkgs remains false, the first package of the list #will be delivered. If the package_list is empy, the truck will return to HUB. Otherwise the next package #will be checked. If next package is to same destination the loop will continue, if not the truck will continue #to the next destination. all_pkgs = False while(all_pkgs == False): del_str = "\tPackage #%s Delivered " % (truck.package_list[0].ID) print(del_str) update_delivery_status(truck) the_hash.update_pkg(truck.package_list[0]) current_delivery = truck.package_list.pop(0).location_id if(len(truck.package_list) == 0): all_pkgs = True return_to_hub(truck) else: next_delivery = truck.package_list[0].location_id truck.distance_to_next_delivery = the_graph.return_weight_with_id(current_delivery, next_delivery) if(truck.distance_to_next_delivery > 0 and all_pkgs == False): truck.distance_to_next_delivery += miles_over_destination all_pkgs = True del_str = "Next Stop: %-39s %-18s |Package Number: %-2s |Distance: %.1f " % (truck.package_list[0].address, truck.package_list[0].city, truck.package_list[0].ID, truck.distance_to_next_delivery) print(truckUpdate + del_str) return 0
def __init__(self, number_of_storage: int, truck: Truck, storage: List[Storage]): self._truck = truck self._storage = storage self.N = number_of_storage self._plans = [truck.bestAction(storage[0])] for i in range(len(storage) - 1): self._plans.append(storage[i].bestAction(storage[1 + 1]))
def add_object(self): vehicleType = random.randint(0,2) if vehicleType == self.CAR: Object = Car(self.display,int(self.width/10),self.height,0,0,self.Hspeed,self.direction) elif vehicleType == self.TRUCK: Object = Truck(self.display,int(self.width/5),self.height,0,0,self.Hspeed,self.direction) else: Object = Bike(self.display,int(self.width/10),self.height,0,0,self.Hspeed,self.direction) return Object
def initial_state(problem, filename): global customers if filename == "nearest_neighbors": print "Generating nearest neighbors solution..." depot_c = Customer(0, 0, 0, 0, 0, 0, 0) c = [depot_c] for cust in customers: c.append(cust) paths = Dijsktra.get_nearest_neighbors_all_trucks(c, depot_c, num_trucks) trucks = [] for k in range(1, num_trucks + 1): t = Truck(k, 0, 0, truck_capacity, path = Path(paths[k-1][1:])) trucks.append(t) state = State( trucks, parent = None ) elif filename == "nn_random": print "Generating nearest neighbors random solution..." depot_c = Customer(0, 0, 0, 0, 0, 0, 0) c = [depot_c] for cust in customers: c.append(cust) paths = Dijsktra.get_nearest_neighbors_random(c, depot_c, num_trucks, 2) trucks = [] for k in range(1, num_trucks + 1): t = Truck(k, 0, 0, truck_capacity, path = Path(paths[k-1][1:])) trucks.append(t) state = State( trucks, parent = None ) state.plot() else: state = import_solution(problem, filename) if do_plot: state.plot() return state
def view_truck_routes(): now = datetime.datetime.now() print("\n\t▪■▪ TRUCK ONE ▪■▪\nClock Time Miles Location ID Path") truck1 = ds.truck_routes( Truck(1, now.replace(hour=8, minute=0, second=0)), first_bundle) print("\n\t▪■▪ TRUCK TWO ▪■▪\nClock Time Miles Location ID Path") truck2 = ds.truck_routes( Truck(2, now.replace(hour=9, minute=5, second=0)), second_bundle) print("\n\t▪■▪ TRUCK THREE ▪■▪\nClock Time Miles Location ID Path") truck3 = ds.truck_routes( Truck(3, now.replace(hour=10, minute=0, second=0)), third_bundle) print("\n🚚 ID MILEAGE\n\t1\t\t", truck1, "\n\t2\t\t", truck2, "\n\t3\t\t", truck3, "\n ", truck1 + truck2 + truck3, end=" TOTAL\n\n")
def test_is_empty(self): truck = Truck([5, 7, 0, 3], [3, 2, 4, 1]) expected = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1] self.assertEqual(truck.is_empty(), False) for expect in expected: truck.pop_product() is_empty = truck.is_empty() self.assertEqual(is_empty, expect)
def start_delivery(self): self.arrange_trucks() # Call a function to optimized each truck for truck in self._trucksList: optimized_truck = Truck() optimized_truck.add_start_time(truck.truck_start_time()) optimized_truck.add_time_to_delivery_map(truck.truck_start_time()) ready_truck = self.optimize_delivery(HUB, truck, optimized_truck) self._optimizedTruckList.append(ready_truck) self._optimizedTruckDict[truck.truck()] = ready_truck # call function to put times for each package delivered for truck in self._optimizedTruckList: self.set_delivery_time(truck)
def _prepare_truck_lists(solution, problem_instance, truck_num_var, dock_num_var, priority_var, num_prod_var): truck_dock_association = solution[0:problem_instance[truck_num_var]] truck_dock_association = [[index, int(x * problem_instance[dock_num_var])] for index, x in enumerate(truck_dock_association)] priorities = solution[problem_instance[truck_num_var]:] trucks_list = [] trucks_for_inbound_docks = [] for dock_id in range(0, problem_instance[dock_num_var]): trucks_for_inbound_docks.append([]) trucks_list.append([]) for association in truck_dock_association: if association[1] == dock_id: trucks_for_inbound_docks[dock_id].append([association[0], priorities[association[0]]]) trucks_for_inbound_docks[dock_id].sort(key=lambda x: x[1]) for truck in trucks_for_inbound_docks[dock_id]: trucks_list[dock_id].append( Truck(problem_instance[num_prod_var][truck[0]], problem_instance[priority_var][truck[0]])) return trucks_list
def import_solution(problem, filename): with open(path + filename + ".txt") as f: customers = import_customers(problem + ".txt", False) Distances.calculate_matrix(customers) lines = f.readlines() ids = [] for line in lines[5:]: ids.append(line.split()[3:]) routes = [] for line in ids: route = [] for cust_number in line: route.append((customers[int(cust_number) - 1])) routes.append(route) trucks = [] for i in range(len(routes)): trucks.append(Truck(i, 0, 0, len(routes), Path(routes[i]))) return State(trucks)
def __init__(self, package_controller: PackageController, location_controller: LocationController, city_map: Graph, num_of_trucks: int = 3, number_of_drivers: int = 2) -> None: super().__init__() self.hub_location = location_controller.locations[0] self.city_map = city_map self.total_distance = 0 now = datetime.now() self.startOfDay = datetime(now.year, now.month, now.day, 8) self.endOfDay = datetime(now.year, now.month, now.day, 17) self.current_time = self.startOfDay self.package_controller = package_controller self.num_of_trucks = num_of_trucks self.num_of_drivers = number_of_drivers self.trucks: List[Truck] = [] drivers = self.num_of_drivers for index in range(num_of_trucks): has_driver = False #used positional agruments for better readability on the truck id argument if drivers > 0: has_driver = True drivers -= 1 truck = Truck(id=index + 1, hub=self.hub_location, has_driver=has_driver, city_map=self.city_map) self.trucks.append(truck)
def __init__(self, distances, locations, packages): self.packages = packages self.locations = locations # Set the hub location from the locations table hub = locations["4001 South 700 East"] # Make the three trucks self.t1 = Truck(1, distances, hub) self.t2 = Truck(2, distances, hub) self.t3 = Truck(3, distances, hub) # Special package rules - sorted by hand based on time or on restrictions # about what needs to be delivered together for_t1 = [13, 14, 15, 16, 19, 20, 30, 31, 34, 37, 29] for_t2 = [1, 3, 6, 18, 25, 28, 32, 36, 38] for_t3 = [9] # Load the reserved packages into their respective trucks load_truck_from_list(self.t1, for_t1, self.packages) load_truck_from_list(self.t2, for_t2, self.packages) load_truck_from_list(self.t3, for_t3, self.packages)
def create() -> Truck: return Truck("Howo")
"4 : Get status of all packages" - Get and displays status of all packages after delivery route completion "5 : End delivery route" Helper functions from the Helper class provide the logic for each menu_selection Truck loads (lists) manually created to efficiently load truck while taking into account special instructions All truck loads are stored in a 2D list for each retrieval within start_delivery_route() Helper.clock datetime initialized to beginning of day 08:00:00 Delivery of all packages orchestrated - Truck.start_delivery_route() """ menu_selection = Helper.display_menu(route_started) # delivery route starts if user selects 1 and the route has not started yet if menu_selection == "1" and not route_started: route_started = True print("\n[Delivery Route Started]") truck1 = Truck(1, "Driver 1") truck2 = Truck(2, "Driver 2") # Assign packages to truck for each visit to hub truck1_first_load = [4, 13, 14, 15, 16, 17, 19, 20, 21, 34, 39, 40] truck2_first_load = [ 1, 2, 3, 5, 7, 8, 18, 22, 27, 29, 30, 33, 35, 36, 37, 38 ] truck1_second_load = [6, 10, 11, 12, 25, 26, 28, 31, 32] truck2_second_load = [9, 23, 24] # Consolidate lists loading_sequence = [[truck1_first_load, truck1_second_load], [truck2_first_load, truck2_second_load]] # Number of loading seqs for truck 1
def get_children(self, big=True, medium=True, small=True, extra_big_move_children=False, near_valid=False): children = [] # list of states children_paths = [] paths = self.paths n_customers = len(Distances.matrix[0]) - 1 trucks = self.trucks if big: #good #children_paths += State.shuffle( paths, 5 ) #might be good or not, we've never used it #children_paths += State.alternating_shuffle_within_path( paths ) children_paths += State.large_reconstruction( paths, 100 if extra_big_move_children else 50) if medium: if random.random() > 0.8: children_paths += State.random_nearest_neighbors( paths, 5, 10 ) #don't make n_touched bigger than 20 or else it won't work children_paths += State.use_clusters(paths, 10) children_paths += State.move_central_customers_to_path_starts_and_ends( paths, n_customers // 5) if small: # good # @TODO -- check that they are right # children_paths += State.wait_time_swap(paths) # children_paths += State.cargo_swap(paths, self.trucks[0].cargo) children_paths += State.time_swap(paths) children_paths += State.reverse(paths) children_paths += State.line_segment_insertion( paths, int(n_customers / 5), 15.0) children_paths += State.fix_single_unreasonable(paths) children_paths += State.fix_group_unreasonable(paths) children_paths += State.switch_between_paths(paths, 20) children_paths += State.missed_customer_time_swap(paths, 20) if near_valid or random.random() > 0.9: children_paths += State.swap_all_neighbor_pairs_on_some_path( paths) if random.random() > 0.8: children_paths += State.path_swap(paths, 20) children_paths += State.random_insert(paths, 20) # child_paths should be a list containing three paths per entry (as a list) for child_paths in children_paths: if child_paths: trucks = [] i = 1 for child in child_paths: trucks.append(Truck(i, 0, 0, self.trucks[0].cargo, child)) i += 1 if sum([len(child) for child in child_paths]) == n_customers: children.append(State(trucks, self)) return children
# Josh Gaweda Student ID #: 001150997 from datetime import datetime, timedelta from HashTable import HashTable from Package import Package from Truck import Truck import re import os clear = lambda: os.system('clear') & os.system('cls') # Creates the global variables for this project (Hash Table, Time, Trucks) receiveing = HashTable() global_time = datetime(2021, 1, 10, 8, 00) truck1 = Truck(receiveing.init1(), datetime(2021, 1, 10, 9, 5), 1, receiveing) truck2 = Truck(receiveing.init2(), datetime(2021, 1, 10, 8, 00), 2, receiveing) truck3 = Truck(receiveing.init3(), datetime(2021, 1, 10, 23, 59), 3, receiveing) def start_deliveries(delivery_time=datetime(2021, 1, 10, 23, 59)): # Space-time complexity = O(N) # Runs all deliveries until global time matches the delivery time. # This function will start each truck at the appropriate time, including truck 3 which will leave when another comes back. # Stops running deliveries once every package is delivered and all trucks returned to hub. global global_time while global_time < delivery_time: # Starts truck 3 if truck3.status == 'AT HUB, START OF DAY' and truck2.status == 'Deliveries complete' or truck1.status == 'Deliveries complete': truck3.time = global_time
def run(self): self.trucks.append(Truck(self.capacity)) final_cost = 0 visited_cost = 0 current_truck = 0 n_nodes = self.dimension - 1 while n_nodes > 0: chosen_index = 0 chosen_node = None min_cost = inf # check if truck path is empty if len(self.trucks[current_truck].path) == 0: self.trucks[current_truck].add_to_path(self.nodes[0]) self.nodes[0].visited = True if current_truck == 0: random_node = None while True: random_node = choice(self.nodes) if self.trucks[current_truck].available_load( ) >= random_node.demand: break random_node = choice(self.nodes) truck = self.trucks[current_truck] prev_location = truck.path[0] truck.add_to_path(random_node) truck.add_load(random_node.demand) truck.current_location = int(random_node.id) self.nodes[random_node.id].visited = True final_cost += self.cost_matrix[prev_location.id][ self.trucks[current_truck].current_location] n_nodes -= 1 # run the greedy algorithm for i in range(self.dimension): if not self.nodes[i].visited: if self.trucks[current_truck].available_load( ) >= self.nodes[i].demand: visited_cost = self.cost_matrix[ self.trucks[current_truck].current_location][i] if visited_cost < min_cost: min_cost = visited_cost chosen_index = i chosen_node = self.nodes[i] # if we can choose a node if chosen_node != None: truck = self.trucks[current_truck] truck.add_to_path(chosen_node) truck.add_load(chosen_node.demand) truck.current_location = int(chosen_node.id) self.nodes[chosen_index].visited = True final_cost += min_cost n_nodes -= 1 else: # Changing truck if int(self.trucks[current_truck].current_location) != 0: final_cost += self.cost_matrix[ self.trucks[current_truck].current_location][0] self.trucks[current_truck].add_to_path(self.nodes[0]) self.trucks.append(Truck(self.capacity)) current_truck += 1 # taker last truck to the depot final_cost += self.cost_matrix[ self.trucks[current_truck].current_location][0] self.trucks[current_truck].add_to_path(self.nodes[0]) routes = [] i = 0 for truck in self.trucks: # print("Truck:", i) # print(truck.get_path_ids()) routes.append(truck.get_path_ids()) i += 1 return final_cost, routes
class TruckManager: truck_1 = Truck(truck_id='truck_1') truck_2 = Truck(truck_id='truck_2') truck_3 = Truck(truck_id='truck_3') ####### # O(1) - constant # creates new truck objects (used for completing deliveries multiple times over) @classmethod def reset_trucks(cls): cls.truck_1 = Truck(truck_id='truck_1') cls.truck_2 = Truck(truck_id='truck_2') cls.truck_3 = Truck(truck_id='truck_3') ####### # O(1) - constant # to_string formatter for the TruckManager object @classmethod def __str__(cls): return '''TruckManager: ( truck_1: {}, truck_2: {}, truck_3: {} ) '''.format(cls.truck_1.packages, cls.truck_2.packages, cls.truck_3.packages) ####### # O(N^2) - quadratic (calls 'send_out_truck' which is a quadratic function) # sends out trucks based on driver availability @classmethod def run_fleet(cls, distance_table): cls.send_out_truck(cls.truck_1, distance_table, Clock('8:00', 'AM')) cls.send_out_truck(cls.truck_2, distance_table, Clock('11:30', 'AM')) cls.send_out_truck(cls.truck_3, distance_table, Clock('9:10', 'AM'), ignore_deadline=True) ####### # O(N^2) - quadratic time. # Delivers all packages that were loaded onto a specific truck @classmethod def send_out_truck(cls, truck, distance_table, start_clock, ignore_deadline=False): truck.start_clock(start_clock) # Loops until all packages in truck are delivered # 1. First checks if more than one package go to the same address # 2. Second checks if any deadlines are approaching that need to be prioritized # 3. Lastly, uses a greedy algorithm to find nearest location to deliver next package while not truck.is_route_finished() and not truck.clock_stopped(): package_with_deadline = truck.approaching_deadline() if not ignore_deadline else None package_for_same_address = truck.package_for_current_address() if package_for_same_address is not None: next_delivery = package_for_same_address elif package_with_deadline is not None: next_delivery = package_with_deadline else: next_delivery = cls.get_closest_package(truck, distance_table) truck.deliver_package(next_delivery, distance_table) # After all packages are delivered drive back to HUB truck.drive_back_to_hub(distance_table) ####### # O(N) - linear # greedy algorithm (find closest destination from current location) @classmethod def get_closest_package(cls, truck, distance_table): closest_package = truck.get_first_undelivered_package() closest_distance = distance_table.get_distance(truck.location, closest_package.address) for package in truck.packages: if package.status == PackageStatuses.DELIVERED: continue other_distance = distance_table.get_distance(truck.location, package.address) if other_distance < closest_distance: closest_package = package closest_distance = other_distance return closest_package ####### # O(N) - linear # loads each package onto a given truck @classmethod def load_truck(cls, truck, package_list, package_table): for package_id in package_list: package = package_table.get(str(package_id)) truck.load_package(package) ####### # O(1) - constant # sets stop time on trucks. used for reporting status at a specific time of the day @classmethod def set_stop_time(cls, stop_time): time = stop_time[0: stop_time.index(' ')] period = stop_time[stop_time.index(' ') + 1:] cls.truck_1.stop_clock = Clock(time, period) cls.truck_2.stop_clock = Clock(time, period) cls.truck_3.stop_clock = Clock(time, period) ####### # O(1) - constant # simply adds all miles traveled by all trucks @classmethod def get_miles_traveled_by_all_trucks(cls): return cls.truck_1.miles_traveled \ + cls.truck_2.miles_traveled \ + cls.truck_3.miles_traveled ####### # O(N) - linear # report for the package information by delivery truck @classmethod def print_report(cls): PACKAGE_TABLE_HEADER = '|\tID\t|\tDELIVERY ADDRESS\t\t|\tCITY\t\t\t|\tSTATE\t|\tZIP\t\t|\tDEADLINE\t|\tWEIGHT\t' \ '|\tSTATUS\t\t|\tDELIVERY TIME\t|\tINSTRUCTIONS' hr = '--------------------------------------------------------------------------------------------------------' \ '--------------------------------------------------------' print('////////////////////////////////////////////////////////') print('PACKAGE REPORT (BY TRUCK)\n') print('Truck 1: location {}, time arrived: {}, miles traveled {}' .format(cls.truck_1.location, cls.truck_1.clock.time_string(), cls.truck_1.miles_traveled)) print(hr + '\n' + PACKAGE_TABLE_HEADER + '\n' + hr) for package in cls.truck_1.packages: print(cell_row_of(package)) print('\n\nTruck 2: location {}, time arrived: {}, miles traveled {}' .format(cls.truck_2.location, cls.truck_2.clock.time_string(), cls.truck_2.miles_traveled)) print(hr + '\n' + PACKAGE_TABLE_HEADER + '\n' + hr) for package in cls.truck_2.packages: print(cell_row_of(package)) print('\n\nTruck 3: location {}, time arrived: {}, miles traveled {}' .format(cls.truck_3.location, cls.truck_3.clock.time_string(), cls.truck_3.miles_traveled)) print(hr + '\n' + PACKAGE_TABLE_HEADER + '\n' + hr) for package in cls.truck_3.packages: print(cell_row_of(package)) print('\n\nTotal miles traveled: {}'.format(cls.get_miles_traveled_by_all_trucks())) print('////////////////////////////////////////////////////////')
def reset_trucks(cls): cls.truck_1 = Truck(truck_id='truck_1') cls.truck_2 = Truck(truck_id='truck_2') cls.truck_3 = Truck(truck_id='truck_3')
#Jeffery Burroughs #876696 from Graph import Graph from Graph import Vertex from Pack import Package from Hash import pkg_hash import datetime from Truck import Truck import operator location_list = [] the_graph = Graph() time = [8,0] total_mileage = 0 trucks = [Truck(1), Truck(2)] HUB = 0 def sort_packages(the_truck: Truck): #Sort function begins by sorting all packages with early delivery #to the front of the package_list using a bubble sort. The next step #is to group any packages with the same destination. The final step is #to bubble sort all packages, starting with the first EOD delivery, based #on nearest neighbor. def sort_for_early_delivery(package_list): #Bubblesort the package_list to sort by deadline. If iterate through list and compare #based on deadline. If deadline is less move towards the front of the list.
# ---------Values that make the most difference in this program------------ # Max values to lookahead (computational complexity is very sensitive to increases - max recommended is 9, which takes # about 150 seconds to run on my machine. MAX_LOOKAHEAD = 9 # --------------------Don't change these values------------------- # Absolute package limit for each truck ABSOLUTE_PACKAGE_LIMIT = 16 # If less than 16, designates truck #2 as a shorter loop truck so it returns to the hub more often to get priority # packages SHORTER_PACKAGE_LIMIT = 16 # ------------------------------------------------------------------ # -------Initializations------- # trucks Truck(1) Truck(2) all_trucks = Truck.get_all_trucks() # -------Imports------- # ---Locations--- graph_input = pd.read_excel("WGUPS Distance Table.xlsx", header=0, index_col=0, engine="openpyxl") locations = graph_input.columns.tolist() # This is needed for iterating through the new locations later try: start_location_num = Location.max_location_number() except ValueError: start_location_num = 0 # Get the graph and distances between points # Unfortunately I wrote the PathGraph and Dijkstra's with lists before I decided to do input via pandas