routing_with_closed_chain.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Walkthrough of Flexible Vehicle Routing "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook includes code used in the Python simulation files. Users can generate example transportation networks to visualize different routing strategies. Notebook sections are listed below:\n",
    "\n",
    "**A. Setup** - imports packages and sets *user-defined* global variables  \n",
    "**B. Classes and routing functions** - defines the Instance class and helper functions with (i) VRP/TSP solvers, (ii) routing algorithms, and (iii) cost measures  \n",
    "**C. Plotting functions** - helper functions to plot realized delivery routes through customer locations  \n",
    "**D. Example instance** - sets *user-defined* network parameters and walks through the routing algorithms for a random customer and demand instance.\n",
    "\n",
    "Note: Code for the TSP and VRP solvers is from [Google OR-Tools](https://developers.google.com/optimization/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A. Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.8.8 (default, Apr 13 2021, 15:08:03) [MSC v.1916 64 bit (AMD64)]\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import math\n",
    "import random\n",
    "import time\n",
    "import matplotlib.pyplot as plt\n",
    "from ortools.constraint_solver import routing_enums_pb2\n",
    "from ortools.constraint_solver import pywrapcp\n",
    "from copy import deepcopy\n",
    "print(sys.version)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set global variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "field_width = 100 # Customer location has x-coordinate in (0, field_width)\n",
    "field_height = 100 # Customer location has y-coordinate in (0, field_height)\n",
    "#depot_x = 50 # Depot x-coordinate\n",
    "#depot_y = 50 # Depot y-coordinate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## B. Classes and routing functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Instance class for random demands and locations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Instance():\n",
    "    \"\"\"A realized set of node locations and demands and the resulting routing characteristics.\"\"\"\n",
    "\n",
    "    def __init__(self, xlocs, ylocs, demands, solve_TSP=True):\n",
    "\n",
    "        self.size = len(demands) - 1\n",
    "        self.demands = demands\n",
    "        self.xlocs = xlocs\n",
    "        self.ylocs = ylocs\n",
    "        self.distances = self.calc_distance_matrix()\n",
    "        self.optimal_routes = 'None'\n",
    "        self.tour = 'None'\n",
    "        if solve_TSP:\n",
    "            # self.tour = self.solve_TSP()\n",
    "            # self.tour = self.TSP_heuristic()\n",
    "            self.tour = self.solve_TSP()\n",
    "\n",
    "    def calc_distance_matrix(self):\n",
    "        \"\"\"Returns a matrix with pairwise node distances\"\"\"\n",
    "        distances = np.zeros((self.size + 1, self.size + 1), dtype=float)\n",
    "        for i in range(self.size + 1):\n",
    "            for j in range(self.size + 1):\n",
    "                new_dist = math.sqrt((self.xlocs[i] - self.xlocs[j]) ** 2 + (self.ylocs[i] - self.ylocs[j]) ** 2)\n",
    "                distances[i, j] = new_dist\n",
    "        return distances\n",
    "\n",
    "    def update_demands(self, demands):\n",
    "        self.demands = demands\n",
    "\n",
    "    def update_tour(self, tour):\n",
    "        self.tour = tour\n",
    "\n",
    "    def get_lowerbound(self, capacity):\n",
    "        \"\"\"Returns a theoretical lowerbound on the optimal routing cost\"\"\"\n",
    "        return (2 / capacity) * sum([self.demands[i] * self.distances[0, i]\n",
    "                                     for i in range(len(self.demands))])\n",
    "\n",
    "    def get_fleet_size(self, route_size):\n",
    "        \"\"\"Returns the number of vehicles needed to visit all nodes given a fixed route size\"\"\"\n",
    "        assert self.size % route_size == 0, \"Number of customers must be evenly divisible by the route size.\"\n",
    "        return int(self.size / route_size)\n",
    "\n",
    "    def save_optimal_routes(self, route_list):\n",
    "        self.optimal_routes = route_list\n",
    "\n",
    "    def solve_TSP(self):\n",
    "\n",
    "        def create_data_model():\n",
    "            data = {}\n",
    "            data['distance_matrix'] = self.distances\n",
    "            data['num_vehicles'] = 1\n",
    "            data['depot'] = 0\n",
    "            return data\n",
    "\n",
    "        def get_tour(manager, routing, solution):\n",
    "            index = routing.Start(0)\n",
    "            plan_output = ''\n",
    "            while not routing.IsEnd(index):\n",
    "                plan_output += '{},'.format(manager.IndexToNode(index))\n",
    "                previous_index = index\n",
    "                index = solution.Value(routing.NextVar(index))\n",
    "            plan_output += '{}'.format(manager.IndexToNode(index))\n",
    "            as_list = plan_output.split(',')\n",
    "            return [int(i) for i in as_list][:-1]  # excludes return to depot in tour\n",
    "\n",
    "        # --- RUN PROGRAM ---\n",
    "\n",
    "        # Instantiate the data problem.\n",
    "        data = create_data_model()\n",
    "\n",
    "        # Create the routing index manager.\n",
    "        manager = pywrapcp.RoutingIndexManager(len(data['distance_matrix']),\n",
    "                                               data['num_vehicles'], data['depot'])\n",
    "\n",
    "        # Create Routing Model.\n",
    "        routing = pywrapcp.RoutingModel(manager)\n",
    "\n",
    "        def distance_callback(from_index, to_index):\n",
    "            \"\"\"Returns the distance between the two nodes.\"\"\"\n",
    "            # Convert from routing variable Index to distance matrix NodeIndex.\n",
    "            from_node = manager.IndexToNode(from_index)\n",
    "            to_node = manager.IndexToNode(to_index)\n",
    "            return data['distance_matrix'][from_node][to_node]\n",
    "\n",
    "        transit_callback_index = routing.RegisterTransitCallback(distance_callback)\n",
    "\n",
    "        # Define cost of each arc.\n",
    "        routing.SetArcCostEvaluatorOfAllVehicles(transit_callback_index)\n",
    "\n",
    "        # Setting first solution heuristic.\n",
    "        search_parameters = pywrapcp.DefaultRoutingSearchParameters()\n",
    "        search_parameters.first_solution_strategy = (\n",
    "            routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC)\n",
    "\n",
    "        # Solve the problem.\n",
    "        solution = routing.SolveWithParameters(search_parameters)\n",
    "        return get_tour(manager, routing, solution)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### VRP solver\n",
    "Using Google OR-Tools."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def optimize(inst, capacity):\n",
    "    \"\"\"Note: This function is largely from the Google OR-Tools tutorial.\"\"\"\n",
    "\n",
    "    def create_data_model(inst, capacity):\n",
    "        data = {}\n",
    "        data['distance_matrix'] = inst.distances\n",
    "        data['demands'] = inst.demands\n",
    "        data['vehicle_capacities'] = [capacity]*inst.size\n",
    "        data['num_vehicles'] = sum(inst.demands)\n",
    "        data['depot'] = 0\n",
    "        return data\n",
    "\n",
    "    def get_routes(solution, routing, manager):\n",
    "        \"\"\"Get vehicle routes from a solution and store them in an array.\"\"\"\n",
    "        # Get vehicle routes and store them in a two dimensional array whose\n",
    "        # i,j entry is the jth location visited by vehicle i along its route.\n",
    "        routes = []\n",
    "        for route_nbr in range(routing.vehicles()):\n",
    "            index = routing.Start(route_nbr)\n",
    "            route = [manager.IndexToNode(index)]\n",
    "            while not routing.IsEnd(index):\n",
    "                index = solution.Value(routing.NextVar(index))\n",
    "                route.append(manager.IndexToNode(index))\n",
    "            routes.append(route)\n",
    "        return routes\n",
    "\n",
    "    def distance_callback(from_index, to_index):\n",
    "        \"\"\"Returns the distance between the two nodes.\"\"\"\n",
    "        # Convert from routing variable Index to distance matrix NodeIndex.\n",
    "        from_node = manager.IndexToNode(from_index)\n",
    "        to_node = manager.IndexToNode(to_index)\n",
    "        return data['distance_matrix'][from_node][to_node]\n",
    "    \n",
    "    def demand_callback(from_index):\n",
    "        \"\"\"Returns the demand of the node.\"\"\"\n",
    "        # Convert from routing variable Index to demands NodeIndex.\n",
    "        from_node = manager.IndexToNode(from_index)\n",
    "        return data['demands'][from_node]\n",
    "    \n",
    "    \n",
    "    # --- RUN PROGRAM ---\n",
    "\n",
    "    # Zero cost if no demands\n",
    "    if all(dem == 0 for dem in inst.demands):\n",
    "        return [[]]\n",
    "\n",
    "    # Set up data model\n",
    "    data = create_data_model(inst, capacity)\n",
    "    \n",
    "    # Create the routing index manager\n",
    "    manager = pywrapcp.RoutingIndexManager(len(data['distance_matrix']), data['num_vehicles'], data['depot'])\n",
    "    \n",
    "    # Create routing model\n",
    "    routing = pywrapcp.RoutingModel(manager)\n",
    "\n",
    "    # Create and register a transit callback\n",
    "    transit_callback_index = routing.RegisterTransitCallback(distance_callback)\n",
    "\n",
    "    # Define cost of each arc\n",
    "    routing.SetArcCostEvaluatorOfAllVehicles(transit_callback_index)\n",
    "\n",
    "    # Add capacity constraint\n",
    "    demand_callback_index = routing.RegisterUnaryTransitCallback(demand_callback)\n",
    "    routing.AddDimensionWithVehicleCapacity(\n",
    "        demand_callback_index,\n",
    "        0,  # null capacity slack\n",
    "        data['vehicle_capacities'],  # vehicle maximum capacities\n",
    "        True,  # start cumul to zero\n",
    "        'Capacity')\n",
    "\n",
    "    # Setting first solution heuristic\n",
    "    search_parameters = pywrapcp.DefaultRoutingSearchParameters()\n",
    "    search_parameters.first_solution_strategy = (\n",
    "        routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC)\n",
    "\n",
    "    # Solve the problem\n",
    "    solution = routing.SolveWithParameters(search_parameters)\n",
    "    all_routes = get_routes(solution, routing, manager)\n",
    "    nonempty_routes = [route for route in all_routes if not all(i == 0 for i in route)]\n",
    "    \n",
    "    # Remove the depot from the optimal routes\n",
    "    parsed_routes = [route[1:-1] for route in nonempty_routes]\n",
    "    \n",
    "    return parsed_routes\n",
    "    \n",
    "def solve_SDVRP(inst, capacity):\n",
    "    \"\"\"Creates equivalent demand/location instance with unit demand and solves the VRP with splittable demands\"\"\"\n",
    "    # Create equivalent instance with unit demand customers\n",
    "    depot_x = inst.xlocs[0]\n",
    "    depot_y = inst.ylocs[0]\n",
    "    \n",
    "    split_xlocs = [[depot_x]] + [[inst.xlocs[i]]*inst.demands[i] for i in range(1,len(inst.demands))]\n",
    "    split_xlocs = [v for sublist in split_xlocs for v in sublist]\n",
    "\n",
    "    split_ylocs = [[depot_y]] + [[inst.ylocs[i]]*inst.demands[i] for i in range(1,len(inst.demands))]\n",
    "    split_ylocs = [v for sublist in split_ylocs for v in sublist]\n",
    "\n",
    "    split_demands = [[0]] + [[1]*inst.demands[i] for i in range(1,len(inst.demands))]\n",
    "    split_demands = [v for sublist in split_demands for v in sublist]\n",
    "    \n",
    "    split_inst = Instance(split_xlocs, split_ylocs, split_demands, solve_TSP=False)\n",
    "\n",
    "    # Solve VRP with unit demand customers\n",
    "    vrp = optimize(split_inst, capacity)\n",
    "\n",
    "    # Convert back to non-unit demand problem\n",
    "    # to get SDVRP solution for original instance\n",
    "    ids = [[i]*inst.demands[i] for i in range(1,len(inst.demands))]\n",
    "    ids = [v for sublist in ids for v in sublist]\n",
    "    if ids == []:\n",
    "        return [[]] # No routes\n",
    "    else:\n",
    "        sdvrp = [[ids[c-1] for c in route] for route in vrp]\n",
    "   \n",
    "    return sdvrp\n",
    "\n",
    "def solve_VRP(inst, capacity):\n",
    "    depot_x = inst.xlocs[0]\n",
    "    depot_y = inst.ylocs[0]\n",
    "    # Create equivalent instance EXCLUDING customers with zero demand\n",
    "    xlocs = [depot_x] + [inst.xlocs[i] for i in range(1,len(inst.demands)) if inst.demands[i] != 0]\n",
    "    ylocs = [depot_y] + [inst.ylocs[i] for i in range(1,len(inst.demands)) if inst.demands[i] != 0]\n",
    "    dems = [0] + [inst.demands[i]  for i in range(1,len(inst.demands)) if inst.demands[i] != 0]\n",
    "    \n",
    "    new_inst = Instance(xlocs, ylocs, dems, solve_TSP=False)\n",
    "\n",
    "    # Solve VRP\n",
    "    vrp = optimize(new_inst, capacity)\n",
    "    return vrp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Routing algorithms and helper methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a priori (designed in advance) routes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_primary_routes(inst, route_size):\n",
    "    \"\"\"Splits customer sequence into segments of 'route_size' number of customers.\n",
    "    Requires that number of customers is evenly divisible by route_size.\"\"\"\n",
    "    \n",
    "    assert inst.size%route_size == 0, \"The number of customers must be evenly divisible by route_size.\"\n",
    "    tour =  inst.tour[1:] # Exclude depot\n",
    "    routes = []\n",
    "    for i in range(0,len(tour),route_size):\n",
    "        new_route = tour[i:min(i+route_size,len(tour))]\n",
    "        routes.append(new_route)\n",
    "    return routes\n",
    "\n",
    "def get_extended_routes(inst, route_size, overlap_size):\n",
    "    \"\"\"Splits customer sequnce into segments of 'route_size + overlap_size' number of customers, where adjacent\n",
    "    segments SHARE overlap_size number of customers. Requires that the number of customers is evenly divisible by route_size.\"\"\"\n",
    "    \n",
    "    assert inst.size%route_size == 0, \"The number of customers must be evenly divisible by primary route size.\"\n",
    "    tour = inst.tour[1:]\n",
    "    routes = []\n",
    "    for i in range(0,len(tour),route_size):\n",
    "        new_route = tour[i:min(i+route_size+overlap_size,len(tour))] # note: for the last route, subsetting ends with final customer\n",
    "        routes.append(new_route)\n",
    "    return routes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Get realized trips between depot visits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_full_trips(inst, route_list, capacity, demand_filled = None):\n",
    "    \"\"\"Splits a sequence of customers into individual trips. Returns a list of lists.\"\"\"\n",
    "    \n",
    "    assert type(route_list[0]) == list, \"route_list must be a list of lists (routes).\"\n",
    "\n",
    "    # Dictionary for tracking remaining demand filled at all customers\n",
    "    remaining_demand = dict([(inst.tour[i],inst.demands[inst.tour[i]]) for i in range(1,len(inst.tour))])\n",
    "\n",
    "    segments = []\n",
    "    for m in range(len(route_list)):\n",
    "        i = 0\n",
    "        seg_dict = {} # demand filled on current trip\n",
    "        vehicle_dict = dict([(inst.tour[i],0) for i in range(1,len(inst.tour))]) # total demand filled by vehicle on this route\n",
    "        while i < len(route_list[m]):\n",
    "            cust = route_list[m][i]\n",
    "            for d in range(inst.demands[cust]):\n",
    "                #print(dict([(c,vehicle_dict[c]) for c in vehicle_dict if vehicle_dict[c]!=0]))\n",
    "                #print(dict([(c,seg_dict[c]) for c in seg_dict if seg_dict[c]!=0]))\n",
    "                \n",
    "                if demand_filled != None and sum(vehicle_dict.values()) == demand_filled[m]:\n",
    "                    # Route's vehicle achieved its predetermined workload (if applicable)\n",
    "                    # Force to end this route and move to next\n",
    "                    i = len(route_list[m])\n",
    "                    break\n",
    "                    \n",
    "                elif sum(remaining_demand[c] for c in route_list[m]) == 0:\n",
    "                    # Route is completed\n",
    "                    # Force to end this route and move to next\n",
    "                    i = len(route_list[m])\n",
    "                    break\n",
    "                \n",
    "                elif sum(seg_dict.values()) == capacity:\n",
    "                    # Vehicle is at capacity\n",
    "                    # End current trip, and begin a new trip within this route\n",
    "                    segments.append(list(seg_dict))\n",
    "                    seg_dict = {cust: 1}\n",
    "                    vehicle_dict[cust] += 1\n",
    "                    remaining_demand[cust] -= 1\n",
    "                    \n",
    "                elif remaining_demand[cust] > 0:\n",
    "                    if cust not in seg_dict:\n",
    "                        # Begin service\n",
    "                        seg_dict[cust] = 1 \n",
    "                    else:\n",
    "                        # Continue service\n",
    "                        seg_dict[cust] += 1\n",
    "                    vehicle_dict[cust] += 1\n",
    "                    remaining_demand[cust] -= 1\n",
    "                \n",
    "            i += 1 # Moves to next customer\n",
    "        \n",
    "        # Append route's last segment\n",
    "        segments.append(list(seg_dict))\n",
    "\n",
    "    return segments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Algorithm for overlapped routing recourse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def implement_k_overlapped_alg(inst, primary_routes, extended_routes, capacity, route_size, overlap_size):\n",
    "    \"\"\"Implement's general k-overlapped routing algorithm. Returns list of realized vehicle routes. \"\"\"\n",
    "    assert type(primary_routes[0]) == list, \"primary_routes must be a list of lists (routes)\"\n",
    "    assert type(extended_routes[0]) == list, \"extended_routes must be a list of lists (routes)\"\n",
    "    \n",
    "    if overlap_size == 0: # reduced to dedicated routing\n",
    "        return create_full_trips(inst,primary_routes,capacity)\n",
    "\n",
    "    # Get overlapped segments (note that last route does not have any shared customers at the route's end)\n",
    "    overlapped_segments = []\n",
    "    for j in range(len(primary_routes) - 1):\n",
    "        new_segment = [c for c in extended_routes[j] if c not in primary_routes[j]]\n",
    "        overlapped_segments.append(new_segment)\n",
    "\n",
    "    # Initialize arrays\n",
    "    primary_demands = np.asarray([sum(inst.demands[cust] for cust in route) for route in\n",
    "                                  primary_routes])  # a priori primary route demand for each vehicle\n",
    "    extended_demands = np.asarray([sum(inst.demands[cust] for cust in route) for route in\n",
    "                                   extended_routes])  # a priori extended route demand for each vehicle\n",
    "    overlap_demands = extended_demands - primary_demands  # demands of customers in k-overlapped regions for each vehicle\n",
    "\n",
    "    first = np.asarray([route[0] for route in primary_routes])  # first customer in route for each vehicle\n",
    "    last = np.asarray([route[-1] for route in overlapped_segments] + [inst.tour[-1]])\n",
    "\n",
    "    excess = np.zeros(len(primary_routes))  # surplus capacity for each vehicle (updated below)\n",
    "    workload = np.zeros(len(primary_routes))  # demand in the primary route that must be filled by each vehicle (updated below)\n",
    "    demand_filled = [0 for j in range(len(primary_routes))] # demand ultimately filled by each vehicle (updated below)\n",
    "    realized_routes = []\n",
    "\n",
    "    # Loop through vehicles\n",
    "    for j in range(len(primary_routes)):\n",
    "        if j == 0:\n",
    "            workload[j] = primary_demands[j]\n",
    "        else:\n",
    "            workload[j] = max(0, primary_demands[j] - excess[j-1])\n",
    "\n",
    "        if workload[j] == 0:\n",
    "            excess[j] = excess[j-1] - primary_demands[j]\n",
    "            demand_filled[j] = 0\n",
    "        else:\n",
    "            excess[j] = min(capacity * np.ceil(float(workload[j]) / capacity) - workload[j], overlap_demands[j])\n",
    "            demand_filled[j] = workload[j] + excess[j]\n",
    "        \n",
    "        remaining_surplus = 0\n",
    "        if j == 0:\n",
    "            first[j] = primary_routes[0][0]\n",
    "        else:\n",
    "            remaining_surplus = excess[j-1]\n",
    "        i = 0\n",
    "        while remaining_surplus > 0:\n",
    "            remaining_surplus -= inst.demands[primary_routes[j][i]]\n",
    "            if remaining_surplus < 0:\n",
    "                first[j] = primary_routes[j][i]\n",
    "            elif remaining_surplus == 0 and i < len(primary_routes[j]) - 1:\n",
    "                first[j] = primary_routes[j][i+1]\n",
    "            elif i == len(primary_routes[j]) - 1:\n",
    "                first[j] = 0\n",
    "                last[j] = 0\n",
    "                break\n",
    "            i += 1    \n",
    "        \n",
    "        if j < len(primary_routes) - 1:\n",
    "            remaining_surplus = excess[j]\n",
    "            i = 0\n",
    "            while remaining_surplus > 0:\n",
    "                # fill demand of next shared customer\n",
    "                # override default first and last customer if appropriate\n",
    "                remaining_surplus -= inst.demands[overlapped_segments[j][i]]\n",
    "                 \n",
    "                if remaining_surplus <= 0:\n",
    "                    # set last customer\n",
    "                    last[j] = overlapped_segments[j][i]\n",
    "                elif remaining_surplus > 0 and i == len(overlapped_segments[j]) - 1:\n",
    "                    last[j] = overlapped_segments[j][i]\n",
    "                    break\n",
    "                i += 1\n",
    "    \n",
    "    # Determine realized routes based on updated first and last customers\n",
    "    realized_routes = []\n",
    "    for j in range(len(primary_routes)):\n",
    "\n",
    "        # Create vehicle route\n",
    "        if first[j] == 0:\n",
    "            route = []  # vehicle doesn't leave depot\n",
    "        else:\n",
    "            first_index = inst.tour.index(first[j])\n",
    "            last_index = inst.tour.index(last[j])\n",
    "            route = inst.tour[first_index:last_index + 1]\n",
    "\n",
    "        # Append to realized routes\n",
    "        realized_routes.append(route)\n",
    "\n",
    "    # Create full trips (i.e., segments) from realized routes\n",
    "    segments = create_full_trips(inst, realized_routes, capacity, demand_filled)\n",
    "\n",
    "    return segments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def implement_k_overlapped_alg_closed(demand_instance, primary_routes, extended_routes, capacity, route_size, overlap_size):\n",
    "    \"\"\"Closed chain implemetation for flexible routing\"\"\"\n",
    "\n",
    "    # Get customer instance\n",
    "    inst = demand_instance\n",
    "    tour = inst.tour\n",
    "    # Set current tour and cumulative cost over all demand instances as best so far\n",
    "    # Note: cumulative cost yields same tour ranking as average cost across demand instances\n",
    "    best_segments = implement_k_overlapped_alg(inst, primary_routes, extended_routes, capacity, route_size, overlap_size)\n",
    "    lowest_cumul_cost = sum(get_total_cost(inst, seg) for seg in best_segments)\n",
    "    #print('Initial Routes: {}, Cost: {}'.format(best_routes, lowest_cumul_cost.round(2)))\n",
    "\n",
    "    # Copy of tour (for rotating below)\n",
    "    \n",
    "    primary_routes_to_rotate = primary_routes\n",
    "    extended_routes_to_rotate = extended_routes\n",
    "\n",
    "    # Loop over all vehicles\n",
    "    for c in range(len(primary_routes)-1):\n",
    "\n",
    "        # Rotate primary and extended routes\n",
    "        tour = tour[0:1] + tour[route_size+1:] + tour[1:route_size+1]\n",
    "        inst.update_tour(tour)\n",
    "        primary_routes_to_rotate = get_primary_routes(inst, route_size)\n",
    "        extended_routes_to_rotate = get_extended_routes(inst, route_size, overlap_size)\n",
    "        tour_cost = 0\n",
    "        \n",
    "        # Get cumulative cost over all demand instances\n",
    "        segments = implement_k_overlapped_alg(inst, primary_routes_to_rotate, extended_routes_to_rotate, capacity, route_size,\n",
    "                                                overlap_size)\n",
    "        for seg in segments:\n",
    "            tour_cost += get_total_cost(inst, seg)\n",
    "        #print('Candidate Routes: {}, Cost: {}'.format(extended_routes_to_rotate, tour_cost.round(2)))\n",
    "        if tour_cost < lowest_cumul_cost:\n",
    "            # Set as new best routes and cost\n",
    "            best_segments = segments\n",
    "            lowest_cumul_cost = tour_cost\n",
    "            #print('--> NEW BEST ROUTES: {}, COST: {}'.format(extended_routes_to_rotate, lowest_cumul_cost.round(2)))\n",
    "    \n",
    "    return best_segments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def set_best_chain(demand_instance, primary_routes, extended_routes, capacity, route_size, overlap_size):\n",
    "    \"\"\"Closed chain implemetation for flexible routing\"\"\"\n",
    "\n",
    "    # Get customer instance\n",
    "    inst = demand_instance\n",
    "    tour = inst.tour\n",
    "    # Set current tour and cumulative cost over all demand instances as best so far\n",
    "    # Note: cumulative cost yields same tour ranking as average cost across demand instances\n",
    "    best_routes = extended_routes\n",
    "    segments = implement_k_overlapped_alg(inst, primary_routes, extended_routes, capacity, route_size, overlap_size)\n",
    "    lowest_cumul_cost = sum(get_total_cost(inst, seg) for seg in segments)\n",
    "    print('Initial Routes: {}, Cost: {}'.format(best_routes, lowest_cumul_cost.round(2)))\n",
    "\n",
    "    # Copy of tour (for rotating below)\n",
    "    \n",
    "    primary_routes_to_rotate = primary_routes\n",
    "    extended_routes_to_rotate = extended_routes\n",
    "\n",
    "    # Loop over all customers\n",
    "    for c in range(len(primary_routes)-1):\n",
    "\n",
    "        # Rotate primary and extended routes\n",
    "        tour = tour[0:1] + tour[route_size+1:] + tour[1:route_size+1]\n",
    "        inst.update_tour(tour)\n",
    "        primary_routes_to_rotate = get_primary_routes(inst, route_size)\n",
    "        extended_routes_to_rotate = get_extended_routes(inst, route_size, overlap_size)\n",
    "        tour_cost = 0\n",
    "        \n",
    "        # Get cumulative cost over all demand instances\n",
    "        segments = implement_k_overlapped_alg(inst, primary_routes_to_rotate, extended_routes_to_rotate, capacity, route_size,\n",
    "                                                overlap_size)\n",
    "        for seg in segments:\n",
    "            tour_cost += get_total_cost(inst, seg)\n",
    "        #print('Candidate Routes: {}, Cost: {}'.format(extended_routes_to_rotate, tour_cost.round(2)))\n",
    "        if tour_cost < lowest_cumul_cost:\n",
    "            # Set as new best routes and cost\n",
    "            best_routes = extended_routes_to_rotate\n",
    "            lowest_cumul_cost = tour_cost\n",
    "            #print('--> NEW BEST ROUTES: {}, COST: {}'.format(extended_routes_to_rotate, lowest_cumul_cost.round(2)))\n",
    "    return segments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cost measures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_trip_count(route_list):\n",
    "    \"\"\"Returns number of trips in route list\"\"\"\n",
    "    assert type(route_list[0]) == list, \"route_list must be a list of lists (routes).\"\n",
    "    count = 0\n",
    "    for route in route_list:\n",
    "        if route != []:\n",
    "            count += 1\n",
    "    return count\n",
    "    \n",
    "def get_circular_cost(inst,segment):\n",
    "    \"\"\"Returns the total distance of moving from node to node within the given segment\"\"\"\n",
    "    if len(segment) == 0:\n",
    "        return 0.0\n",
    "    else:\n",
    "        return sum([inst.distances[segment[i],segment[i+1]] for i in range(len(segment)-1)])\n",
    "\n",
    "def get_radial_cost(inst,segment):\n",
    "    \"\"\"Returns the total distance of trips to/from the depot at segment endpoints.\"\"\"\n",
    "    if len(segment) == 0:\n",
    "        return 0.0\n",
    "    else:\n",
    "        return inst.distances[0,segment[0]] + inst.distances[0,segment[-1]]\n",
    "\n",
    "def get_total_cost(inst,segment):\n",
    "    \"\"\"Returns sum of circular and radial costs for the given segment\"\"\"\n",
    "    return get_circular_cost(inst,segment)+get_radial_cost(inst,segment)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## C. Plotting Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_instance(inst, showTour=False, showLabels=False):\n",
    "    \"\"\"\n",
    "    Plots the instance's tour through all customers.\n",
    "    \"\"\"\n",
    "\n",
    "    # Set field dimensions\n",
    "    plt.ylim(ymin=0,ymax=100)\n",
    "    plt.xlim(xmin=0,xmax=100)\n",
    "    depot_x = inst.xlocs[0]\n",
    "    depot_y = inst.ylocs[0]\n",
    "    \n",
    "    # Plot customer and depot locations\n",
    "    plt.plot(inst.xlocs[1:], inst.ylocs[1:], 'ko', markersize=4)\n",
    "    plt.plot(depot_x, depot_y, 'k*', markersize=9)\n",
    "   \n",
    "    if showTour:\n",
    "        # Plot the TSP path through the customers\n",
    "        tour_x = [inst.xlocs[c] for c in inst.tour] + [depot_x]\n",
    "        tour_y = [inst.ylocs[c] for c in inst.tour] + [depot_y]\n",
    "        plt.plot(tour_x, tour_y, color='gray', linestyle='-')\n",
    "\n",
    "    if showLabels:\n",
    "        # Add customer labels\n",
    "        for i in range(len(inst.tour)):\n",
    "            plt.annotate(i, # Label text\n",
    "                         (inst.xlocs[i], inst.ylocs[i]), # Point to label\n",
    "                         textcoords=\"offset points\",\n",
    "                         xytext=(0,5), # Distance from text to points (x,y)\n",
    "                         ha='center')\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_routes(inst, routes, route_color, showTour=False):\n",
    "    \n",
    "    assert type(routes) == list\n",
    "    if all(route == [] for route in routes):\n",
    "        return\n",
    "    \n",
    "    depot_x = inst.xlocs[0]\n",
    "    depot_y = inst.ylocs[0]\n",
    "    routes = [routes[a] for a in range(len(routes)) if routes[a] != []]\n",
    "    num_plots = len(routes)\n",
    "    tour_x = [inst.xlocs[c] for c in inst.tour] + [depot_x]\n",
    "    tour_y = [inst.ylocs[c] for c in inst.tour] + [depot_y]\n",
    "    \n",
    "    fig, axs = plt.subplots(1, num_plots, figsize=(3*num_plots,3))\n",
    "    \n",
    "    for a in range(num_plots):\n",
    "        if num_plots > 1:\n",
    "            ax = axs.flat[a]\n",
    "        else:\n",
    "            ax = axs\n",
    "        ax.set_ylim(ymin=0,ymax=100)\n",
    "        ax.set_xlim(xmin=0,xmax=100)\n",
    "        ax.plot(inst.xlocs[1:], inst.ylocs[1:], 'ko', markersize=4)\n",
    "        ax.plot(depot_x, depot_y, 'k*', markersize=9)\n",
    "        if showTour:\n",
    "            ax.plot(tour_x, tour_y, color='gray', linestyle='-')\n",
    "        route_x = [depot_x] + [inst.xlocs[c] for c in routes[a]] + [depot_x]\n",
    "        route_y = [depot_y] + [inst.ylocs[c] for c in routes[a]] + [depot_y]\n",
    "        ax.plot(route_x, route_y, color=route_color, linestyle='-')\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## D. Example Instance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1) Set network parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- PARAMETERS ---\n",
      "Num. of customers: 15, Demand range: [0,8], Veh. capacity: 20, Primary route size: 5, Overlap size: 5\n"
     ]
    }
   ],
   "source": [
    "num_cust = 15 # number of customers\n",
    "dmin = 0 # a customer's minimum random demand (for Uniform distribution)\n",
    "dmax = 8 # a customer's maximum random demand (for Uniform Distribution)\n",
    "capacity = 20 # vehicle capacity\n",
    "route_size = 5 # number of customers on a truck's primary route (note: must divide evenly into num_cust!)\n",
    "overlap_size = 5 # number of shared customers between two neighboring routes \n",
    "\n",
    "print('--- PARAMETERS ---')\n",
    "print('Num. of customers: {}, Demand range: [{},{}], Veh. capacity: {}, Primary route size: {}, Overlap size: {}'. \\\n",
    "      format(num_cust, dmin, dmax, capacity, route_size, overlap_size))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2) Generate random instance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "cust_x = field_width*np.random.random(num_cust + 1) # x coordintes of all customers and deopt\n",
    "cust_y = field_height*np.random.random(num_cust + 1) # y coordinates of all customers and depot\n",
    "cust_dems = list(np.random.randint(dmin,dmax,num_cust)) # Uniformly distributed customer demands\n",
    "xlocs = cust_x # depot and customer x-coords\n",
    "ylocs = cust_y # depot and customer y-coords\n",
    "#xlocs = list(np.append([depot_x], cust_x)) # depot and customer x-coords\n",
    "#ylocs = list(np.append([depot_y], cust_y)) # depot and customer y-coords\n",
    "demands = list(np.append([0], cust_dems)) # depot and customer demands\n",
    "inst = Instance(xlocs, ylocs, demands)\n",
    "plot_instance(inst, showLabels=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3) Print instance summary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- INSTANCE SUMMARY ---\n",
      "Number of customers: \t 15\n",
      "Vehicle capacity: \t 20\n",
      "Primary route size: \t 5\n",
      "Overlap size: \t\t 5\n",
      "Big TSP tour: \t\t [15, 3, 14, 5, 9, 10, 4, 7, 11, 13, 2, 8, 12, 1, 6]\n",
      "Tour demands: \t\t [7, 3, 0, 5, 3, 4, 7, 1, 2, 2, 7, 6, 4, 4, 0]\n",
      "\n",
      "TSP Tour:\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print('--- INSTANCE SUMMARY ---')\n",
    "print('Number of customers: \\t', inst.size)\n",
    "print('Vehicle capacity: \\t', capacity)\n",
    "print('Primary route size: \\t', route_size)\n",
    "print('Overlap size: \\t\\t', overlap_size)\n",
    "print('Big TSP tour: \\t\\t', inst.tour[1:])\n",
    "print('Tour demands: \\t\\t', [inst.demands[c] for c in inst.tour[1:]])\n",
    "#print('Lowerbound Cost: \\t', int(inst.get_lowerbound(capacity)))\n",
    "print()\n",
    "print('TSP Tour:')\n",
    "#plot_instance(inst, showTour=True, showLabels=True)\n",
    "plot_instance(inst, showTour=True, showLabels=True)\n",
    "inst_copy = deepcopy(inst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4) Solve routing problem\n",
    "#### a) Dedicated routing strategy\n",
    "*The algorithm is described below:*\n",
    "- Identify a single tour through all *N* customers.\n",
    "- Split this sequence of *N* customers into into *M* \"primary\" route segments with equal number of customers (\"route_size\" or N' customers). This assumes *N* is divisible by *M*.\n",
    "- Assign a single vehicle (with capacity *Q*) to each route.\n",
    "- Get information on customers' updated (realized) demands\n",
    "- Upon learning demands, vehicle *m* executes its primary route *m* in the following manner.\n",
    "    - The vehicle departs from depot at full capacity.\n",
    "    - It sequentially visits the customers in its primary route, skipping customers that have 0 demand.\n",
    "    - Upon exhausting its capacity, the vehicle detours to the depot to refill to full capacity and resumes its route wherever it left off.\n",
    "    - Upon filling all customer demands in the primary route, the vehicle has completed its route and returns to the depot.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- DEDICATED ROUTING ---\n",
      "\n",
      "Tour (Row 1), Demand (Row 2):\n",
      "[[15  3 14  5  9 10  4  7 11 13  2  8 12  1  6]\n",
      " [ 7  3  0  5  3  4  7  1  2  2  7  6  4  4  0]]\n",
      "\n",
      "A priori routes:\n",
      "[15, 3, 14, 5, 9]\n",
      "[10, 4, 7, 11, 13]\n",
      "[2, 8, 12, 1, 6]\n",
      "\n",
      "Realized trips:\n",
      "[15, 3, 5, 9]\n",
      "[10, 4, 7, 11, 13]\n",
      "[2, 8, 12, 1]\n",
      "[1]\n",
      "\n",
      "Trip count:\t 4\n",
      "Radial cost:\t 362.8\n",
      "Circular cost:\t 213.7\n",
      "Total cost:\t 576.6\n"
     ]
    }
   ],
   "source": [
    "inst = deepcopy(inst_copy)\n",
    "print('--- DEDICATED ROUTING ---')\n",
    "primary_routes = get_primary_routes(inst, route_size)\n",
    "segments = create_full_trips(inst,primary_routes,capacity)\n",
    "combined = np.array([inst.tour[1:], [inst.demands[c] for c in inst.tour[1:]]])\n",
    "print('\\nTour (Row 1), Demand (Row 2):')\n",
    "print(combined)\n",
    "print('\\nA priori routes:', *primary_routes, sep=\"\\n\")\n",
    "print('\\nRealized trips:', *segments, sep=\"\\n\")\n",
    "print('\\nTrip count:\\t', get_trip_count(segments))\n",
    "print('Radial cost:\\t', np.round(sum([get_radial_cost(inst,seg) for seg in segments]), 1))\n",
    "print('Circular cost:\\t', np.round(sum([get_circular_cost(inst,seg) for seg in segments]), 1))\n",
    "print('Total cost:\\t', np.round(sum([get_total_cost(inst,seg) for seg in segments]), 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A priori routes (orange) vs. realized  trips (blue)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x216 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x216 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print('A priori routes (orange) vs. realized  trips (blue)')\n",
    "plot_routes(inst, primary_routes, 'orange', showTour=True)\n",
    "plot_routes(inst, segments, 'blue', showTour=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### b) Overlapped routing strategy\n",
    "\n",
    "*The algorithm is described below:*\n",
    "- Create primary routes as described above in dedicated routing.\n",
    "- Additionally, create extended routes by assigning each vehicle to all of the customers in its primary route plus some of the customers in a neighboring vehicle's primary route.\n",
    "    - Extended routes formed under \"full adjacent overlapping\" means vehicle $m$ is assigned to customers in primary route $m$ plus all customers in primary route $m+1$, for vehicles $m=1,2,...,M-1$.\n",
    "    - Alternatively, extended routes formed under \"partial adjacent overlapping\" means vehicle $m$ is assigned to customers in primary route $m$ plus $k$ additional customers in primary route $m+1$, for vehicles $m=1,2,...,M-1$.\n",
    "    - In both cases, vehicle $m=M$ is assigned to only its primary route.\n",
    "- Upon learning customer demands, vehicle *m* executes its extended route in the following manner.\n",
    "    - The vehicle departs from depot at full capacity.\n",
    "    - It sequentially visits the customers in its primary route, skipping customers that have 0 demand or demand that has already been filled. The vehicle reloads at the depot as needed.\n",
    "    - Upon filling demand of the final customer in the primary route, the vehicle either (a) permanently returns to the depot if no capacity remains or (b) proceeds with the customers in the extended route and fills those customer demands until the leftover vehicle capacity is exhausted, at which point the vehicle permanently returns to the depot.\n",
    "    - Vehicle *m+1* then starts primary route *m+1* wherever  vehicle *m* left off.\n",
    "    - However, in the case that vehicle *m-1* satisfied the demand of ALL customers in the extended route (meaning it covered all demand in vehicle *m*'s primary route), then vehicle *m* is never deployed. Instead vehicle *m+1* just starts its route at the beginning of primary route *m+1*.\n",
    "\n",
    "Note that a central planner assesses the realized customer demands and coordinate each vehicle's starting and ending customers (realized routes) within the extended route prior to the vehicle's departing the depot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- OVERLAPPED ROUTING ---\n",
      "\n",
      "Tour (Row 1), Demand (Row 2):\n",
      "[[15  3 14  5  9 10  4  7 11 13  2  8 12  1  6]\n",
      " [ 7  3  0  5  3  4  7  1  2  2  7  6  4  4  0]]\n",
      "\n",
      "A priori routes:\n",
      "[15, 3, 14, 5, 9, 10, 4, 7, 11, 13]\n",
      "[10, 4, 7, 11, 13, 2, 8, 12, 1, 6]\n",
      "[2, 8, 12, 1, 6]\n",
      "\n",
      "Realized trips:\n",
      "[15, 3, 5, 9, 10]\n",
      "[10, 4, 7, 11, 13, 2]\n",
      "[2, 8, 12, 1]\n",
      "\n",
      "Trip count:\t 3\n",
      "Radial cost:\t 265.0\n",
      "Circular cost:\t 259.5\n",
      "Total cost:\t 524.5\n"
     ]
    }
   ],
   "source": [
    "inst = deepcopy(inst_copy)\n",
    "print('--- OVERLAPPED ROUTING ---')\n",
    "primary_routes = get_primary_routes(inst, route_size)\n",
    "extended_routes = get_extended_routes(inst, route_size, overlap_size)\n",
    "#set_best_tours([inst], primary_routes, extended_routes, capacity, route_size, overlap_size)\n",
    "segments = implement_k_overlapped_alg(inst,primary_routes,extended_routes,capacity,route_size,overlap_size)\n",
    "combined = np.array([inst.tour[1:], [inst.demands[c] for c in inst.tour[1:]]])\n",
    "print('\\nTour (Row 1), Demand (Row 2):')\n",
    "print(combined)\n",
    "print('\\nA priori routes:', *extended_routes, sep=\"\\n\")\n",
    "print('\\nRealized trips:', *segments, sep=\"\\n\")\n",
    "print('\\nTrip count:\\t', get_trip_count(segments))\n",
    "print('Radial cost:\\t', np.round(sum([get_radial_cost(inst,seg) for seg in segments]), 1))\n",
    "print('Circular cost:\\t', np.round(sum([get_circular_cost(inst,seg) for seg in segments]), 1))\n",
    "print('Total cost:\\t', np.round(sum([get_total_cost(inst,seg) for seg in segments]), 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A priori routes (orange) vs. realized  trips (blue)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x216 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x216 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print('A priori routes (orange) vs. realized  trips (blue)')\n",
    "plot_routes(inst, extended_routes, 'orange', showTour=True)\n",
    "plot_routes(inst, segments, 'blue', showTour=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- OVERLAPPED ROUTING CLOSED ---\n",
      "\n",
      "Tour (Row 1), Demand (Row 2):\n",
      "[[ 2  8 12  1  6 15  3 14  5  9 10  4  7 11 13]\n",
      " [ 7  6  4  4  0  7  3  0  5  3  4  7  1  2  2]]\n",
      "\n",
      "A priori routes:\n",
      "[15, 3, 14, 5, 9, 10, 4, 7, 11, 13]\n",
      "[10, 4, 7, 11, 13, 2, 8, 12, 1, 6]\n",
      "[2, 8, 12, 1, 6]\n",
      "\n",
      "Realized trips:\n",
      "[10, 4, 7, 11, 13, 2]\n",
      "[2, 8, 12, 1, 15]\n",
      "[15, 3, 5, 9]\n",
      "\n",
      "Trip count:\t 3\n",
      "Radial cost:\t 242.6\n",
      "Circular cost:\t 271.7\n",
      "Total cost:\t 514.3\n"
     ]
    }
   ],
   "source": [
    "inst = deepcopy(inst_copy)\n",
    "print('--- OVERLAPPED ROUTING CLOSED ---')\n",
    "primary_routes = get_primary_routes(inst, route_size)\n",
    "extended_routes = get_extended_routes(inst, route_size, overlap_size)\n",
    "#set_best_tours([inst], primary_routes, extended_routes, capacity, route_size, overlap_size)\n",
    "segments = implement_k_overlapped_alg_closed(inst,primary_routes,extended_routes,capacity,route_size,overlap_size)\n",
    "combined = np.array([inst.tour[1:], [inst.demands[c] for c in inst.tour[1:]]])\n",
    "print('\\nTour (Row 1), Demand (Row 2):')\n",
    "print(combined)\n",
    "print('\\nA priori routes:', *extended_routes, sep=\"\\n\")\n",
    "print('\\nRealized trips:', *segments, sep=\"\\n\")\n",
    "print('\\nTrip count:\\t', get_trip_count(segments))\n",
    "print('Radial cost:\\t', np.round(sum([get_radial_cost(inst,seg) for seg in segments]), 1))\n",
    "print('Circular cost:\\t', np.round(sum([get_circular_cost(inst,seg) for seg in segments]), 1))\n",
    "print('Total cost:\\t', np.round(sum([get_total_cost(inst,seg) for seg in segments]), 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A priori routes (orange) vs. realized  trips (blue)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x216 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAigAAADGCAYAAAD43HteAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABdOklEQVR4nO2deXhU5dn/P88s2bcJWcgQsoIJBGVHERUFFdEGca9Wa7Wtv9rNtnax9X2rtlqttmpX3/q2Vmvd9bWaYlFEQSEsSRCBAGHJRjay78kkM3N+f5xMSCDLJJmZM8vzua5cSSYzc+5MvvPke+5zP/ctFEVBIpFIJBKJxJvQaR2ARCKRSCQSyelIgyKRSCQSicTrkAZFIpFIJBKJ1yENikQikUgkEq9DGhSJRCKRSCRehzQoEolEIpFIvI5xDYoQ4jkhRL0Q4sCQ22KFEJuEEEcHPpuG/OynQohjQogSIcQadwUukUwEqWOJryM1LAk0nMmgPA9ccdpt9wGbFUWZDWwe+B4hxFzgi0DOwGP+LITQuyxaiWTyPI/UscS3eR6pYUkAMa5BURTlE6D5tJuvBl4Y+PoFYP2Q219VFMWiKEoZcAxY5ppQJZLJI3Us8XWkhiWBxmRrUBIVRakFGPicMHD7DODEkPtVDdwmkXgjUscSX0dqWOK3GFz8fGKE20bspS+EuAu4CyA8PHxxdna2i0ORBCpFRUWNiqLET+EppI4lmiI1LPEHpqrjyRqUk0KIJEVRaoUQSUD9wO1VwMwh90sGakZ6AkVRngWeBViyZIlSWFg4yVAkkuEIISqcvKvUscQrkRqW+AMT0PGITPYSz7vA7QNf3w68M+T2LwohgoUQ6cBsYPdUApRI3IjUscTXkRqW+C3jZlCEEK8AFwNxQogq4AHgMeB1IcRXgUrgBgBFUYqFEK8DBwEr8C1FUWxuil0icRqpY4mvIzUsCTTGNSiKotw8yo9Wj3L/R4BHphKUROJqpI4lvo7UsCTQkJ1kJRKJRCKReB3SoEgkEolEIvE6pEGRSCQSiUTidUiDIpFIJBKJxOuQBkUikUgkEonXIQ2KBygtLSUnJwe93kBOTg6lpaVahySRTBiHjg0GqWOJbyI17FtIg+Jm+vrsXHvtizQ3v0FQUButrcvIzc3VOiyJZEJUV1fzy1/+kvXr17N8+XIOHz4sdSzxKVpbW/nZz37GVVddxbXXXsuxY8ekhr0cV8/ikQxQVtbFo4828MYbsbS2PkBkZAuhoR3U1v4Vg+FhrcOTSMbFarVy4MABCgoKqKmpISkpiZMnT3LppZdiMpn4z3/+o3WIEsmYKIpCaWkpBQUFHDlyhKysLCoqKpg7dy7R0dG89tprWocoGQNpUFzMv/9dz29+08u2bWZstjTmzq0lJeW3HDjwGAZDFNOnb6ay8gFuvbWcf/wjFZ1upJleEol2tLa2UlhYyJ49e+jp6SEuLo61a9fy9a9/nQMHDnDxxRdz0UUXYTabsVgsBAcHax2yRDIMi8XC3r17KSgooKmpibCwMFasWMF9993Hnj17OOuss7juuuv4f//v/9HY2EhcXJzWIUtGQBoUF9DZaeXJJ6t57rkwKioSCAqysHZtFT/5SRQXXJBEaent5Oa+SUlJCSbTl8nKepOXXppFZWUl//mPmfBw+WeQaIuiKJSVlbF7926OHDkCQFZWFkuXLiU9PR0hBG+//Ta5ubls3bqV0NBQli1bxt///nduueUWoqKiNP4NJBKor6+noKCAffv20dfXx4wZM1i/fv1g3clrr71Gbm4uJSUlbN26lauuuornnnuOm266idTUVK3Dl5yGUJQRJ3B7FF+doLlvXxuPPtrMu+8m0t0dRmJiM7fd1s6Pf5xEfPzoZ5V2u8Ldd5fz7LPpZGXV8dFH0ZjNoR6M3L8RQhQpirLE08f1RR2PdKa5aNEilixZQnR09JiPPXbsGG+88QYhISHccsstJCYmeihq/0dq2HnsdjslJSXs3r2b8vJy9Ho98+bNY+nSpcyYMWPMx7a0tPDSSy/R2trK+vXrmTdvnoeiDgymqmNZJDtB7HaFF1+sZenSKhYsiOS111LJyWnmH/+ooabGxBNPpI1pTgB0OsFf/pLOo49WcuxYHIsW9bB3b5uHfgPvRFbXe5aGhgY2bNjAk08+ycaNGwkJCWH9+vV8//vfZ/Xq1eOaE4BZs2Zxxx13oCgKzz33HMePH/dA5N6L1LBn6erq4pNPPuF3v/sdr7/+Oi0tLaxevZrvf//7rF+/flxzAmAymfjqV7/KjBkzeOutt9i2bRvecNKuFd6mYZlBcZKGBguPPVbLSy9FcfJkLOHh3axbV8/PfhbLvHmTT2+//nodX/lKNHq9nVde6eILX0hwYdS+Q05ODkFBQdTW1tLQ0EB2djbFxcWTei559jkyUznTHIv29nZefvll6uvryc3NZeHChS6M2nfIycmhuXkeOt006ur+IjXsBhRFobq6moKCAoqLi7HZbGRkZLB06VLOOussdLrJnXNbrVbeeecdDhw4wKJFi7jqqqsm/Vy+TE5ODnV1dWRmZlJUVDQlDcPUdSyLH8Zh27ZmHnusnU2bkujrSyM9vZ6HH67knnvMRESkTfn5b7xxOjNntpCbq+Paa0089VQV3/pW8tQD9zHi4uJYtWoVx44d45///CclJSVah+Q3dHV1UVRURFFREe3t7URHR7N69WoWLVpEWFjYlJ8/KiqKO+64gzfeeIN3332XlpYWLrnkEoQIrALwlpZFNDT8Hb3eBvxdatiF9Pf3U1xczO7du6mtrSUoKIjFixezdOlSlxS4GgwGrr32WmJiYti2bRvt7e1cf/31AVcAXlNTw1e+8hViYmKoqanRXMPSoAyhtLR0oIDqODk5P6W392scOTIDgyGKCy+s4d57Q7jqKtdnOJYvN7F7dxeXXtrCt789g+PHy3nyyTSXH8dbKSwsZNWqVfT29pKamorRaGT27Nlah+WTnNJwCcuXL+frX/86lZWVg2eaa9eundKZ5mgEBwdz8803s2HDBj799FNaW1tZt24dBkNgLDEbNtTT1PRXDIZ+LJZQpk9fR2zsAa3D8kmGanjhwoX85Cc/obS0dHBH2ZVXXsk555zjcvMghGD16tXExMSwYcOGgCsA7+7u5o477iAkJARFUZg1a5ZTl3rdSeDlsMYgNzeXjo5cQkNr2bfvAerqwvjGN8o4fryPjz5KcYs5cZCREc5nn5lYurSap55KIzv7PxgMwV5xHdCdFBcXs2HDBmbMmEFhYSFGo5EVK1aQl5endWg+SW5uLq2trdx5551ceumlHDlyhMWLF/Otb32L2267jezsbLelrvV6Pbm5uaxatYr9+/dzzz33EBER4fca3r69mRtvjCAiooesrK8ghA2T6Uap4UmSm5tLRUUF119/PVdddRX79+8nLS2NL3/5y3zzm99k6dKlbs1sLF68mFtuuYWmpiYeeeQRzGaz32vYYrHw0ksvYTKZyM/Pp7a2lnnz5mmuYVmDMoSIiDQsliPExNQSFPRrTp78G1arxaMx9PfbOfvs9ykpWUtKym+oqvrJlK8DeivHjh3jlVdeITk5mVtvvRVFUXj88cc599xzueyyyyb9vIF8/d5gMHDnnXcSHR3Nli1bKC4upru72+NxrF27liVLlnDkyBHefPNNv9XwgQPtXHihwGrV8fHH/SxZEsPs2Sex2QSlpZM/oQl0Da9atYrly5ezbds2PvvsM5qbmz0ex4oVKzjvvPPQ6XQ89dRTZGVl+aWGrVYrr7zyCmVlZdx0001kZWWxefNm8vPz+fGPfzwlMyh38biQ1NRfY7UGYbPdSl3dX8jKmuXxGIxGHceO5RIe3oaiLBwsbPQ3qqqqeP3114mPj+fmm2/GaDQSFBTEzJkzA343yFS44IILmDFjBlu2bGHPnj2kp6drEsemTZs4dOgQSUlJfqvh8vIuVq+20dtr5F//6mHJkhgALrigm7KyeKqre7QN0EeZN28eS5Ys4eDBg2zZsoWkpCRN4ti1axeffPIJERERhIeH+6WG7XY7b7/9NqWlpVx99dVkZWUBkJmZid1up7y8XNP4pEEZoK2tn4qKXFJS9tHevoPs7GzN0ltZWVmEhzfQ329Gp9MNisZfqK+v56WXXiIiIoJbb72VkJCQwZ9lZmZy8uRJOjs7NYzQd7n11lvp7e1l//79mmu4ra2N6Oho9Hq932m4ocHCypXdtLRE8M9/trF69alCzauvDgMEr73WqF2APswvf/lLgoOD2bFD+3W4rU1t/xAbG+t3GlYUhQ0bNnDw4EEuv/xy5s+fP/iz5ORkjEaj5ieL0qAM8KtfVdPVFcZvfpOA1WqluLiYjIwMTWLJy8sjIqKBrq7EKb1BvWlPuyOWuLg4nnzySYQQ3HbbbURERAy7X2Zm5uD9JRPj5MmTVFdXs3btWnp7ezXXcEhICDqdjoULF/qFhk/Fs5hzzimlqiqWhx8u4brrhjeou/LKeEJCetm40a5RlL6L1WrlyJEjpKenU1VVpbmGTSYTAHPmzPEzDedw+eWXs2fPHubNm8fy5cuH3cdgMJCWlqa5QZE1KKgTh83mDqKjLRw9Gu8V83Fuu62Ml15KpbtbISRE79RjLBY4eBD27YPPP4dnn92JXj+LL3zhDczmUnQ6HUlJSeh0uil9CCEm/JhHHnmE2tpali9fTlhYGFu3bmXHjh1n/A6KovCb3/yGWbNmcc0110zqtQvU6/f/+te/OHjwIN///vcJDdW+M3FpaSkvvvgit99+O2lpaZN6jpycHDo6/khDwzJ0Ojs6nR2jUaDTKeh0dvR6BZ1OQa9Xvx79A/R6BYNB/dpgUNDpGPK940MZ8rXjQwx+/f77G2hqWkFNzQJmzvwpkZHvjliXcO65VRw9GkVjY+Sk1pNA1fBnn33Gu+++y6233jp4sqIlVquVRx55hJUrV3LxxRdP6jlycnIICwtj1apVKIqCTqcjMTFxyuvwZNfihx9+mP7+fs477zwKCwspLS0dUcO7du1i48aNfPe73x00ahNF9kFxAX/4QzVNTTN54IEqrzAnABkZOhRFx6FDbSxcOHyrl6JAXZ1qQhxmZN8+OHwYrFb1PqGh0NcXh80WR0WFnfb2w+j1epYvX47dbj/jQ1GUwa9tNhv9/f0j3s+Zj5FYvHgxoFaLv/jii9TW1o54PyEEGRkZlJaWoihKwPXSmCxtbW3s37+fpUuXeoU5AYiJiQHUduKTNSglJSUEBS0lPLyF8PB9gIFZs7Kx2cBqFdhsYLOJga8Fdrv6vc0m6OvTDX5ts+mw2x330Q1+tttP/179UJTRksvfAhRSU5+gouIx9PqRTx5WrbKxe3cUBQUtnHvu5Bb3QENRFPLz85k+fbpmWZPTMRgMREZG0traOunnKCkp4brrrgPg4MGDY67Dp6/FU1mHR0s+ONbi/fv3s2HDhlF39Q3NZjse42kC3qDY7Qq//30ICQktfOMbZq3DGSQurgOAK6/8PmFhbdx99zPU1iYMmpGGhlP3nTkT5s+HdevUz+ecA7Nnw+LFz/L5549z9OhHNDa+R3Z2NuvXr3d77EPfYI6PFStWcPz4cXp7e7FarWRnZ4/6+IyMDA4cOEB9fb2c7+IkO3fuRFEUzjvvPK1DGaS5uRm73c4Pf/hD6urqyMvLm/A/nqys+Rw8GEFCwqucOPH/yM7OZvNm9++ksNkU+vvt9PUN/1i37lqOHz9ERcWJMevDbrwxhscegzffbJMGxUmOHDlCY2Mj1157rdecmJSWllJaWsqBAwe4//77J6nhLKKioqitreU///kP2dnZXH311W6K+BSKooy4Fl944YUcO3aM9vb2MTU8bdo0oqKiNDUoAV+D8sordVRWxnPXXW0Yjd7zcvz1r/8FQF3dc5SWvsWPfpTAn/8MbW2Qmwu/+x1s2QJNTVBZCXl58MgjcOONkJ0Nej2sWvVlACyW4x4tNhNCoNfrMRqNBAcHExoayptvvklycjI2m23cWBzOXevrn75CT0/P4LVkR9bCG7j66qsHO9cePnyY3NzcCT/Ho4++CICiVHpUw3q9ICRET1SUkbi4YMzmUNLSwvnXv54hLS0SvV4/ZjwLF0YTF9fKRx8F/Dmg02zfvp3o6GhycnK0DmWQ3NxcampqiImJmbSG8/LyiI2NpaOjw+PrsE6nw2AwEBQUREhICGFhYbzxxhskJyePq+Gh2ezRMuPuZkrvHiHE94GvAQqwH7gDCANeA9KAcuBGRVFaphSlG/n1rxUiIzv5yU+8q718cfEGzj//E6qrq6ioeAedrpiOjgNMpDFnS0s4ALW1RYSGOlfH4i4yMjKc7iEQFRVFfHw8paWlnH/++W6Nyx80XFhYSF9fHytWrNA6lGGUlJSwdOlSTCbTpLcad3fHAvDww9/gttt+4eoQJ8xEdLxsWRsffjidnh6b299/vq7jyspKTpw4wRVXXOFVM3BKSkpISEjgnHPOQQgxKQ2npaURHh7Od7/7XS655BI3RDkxJqLhzMxM9u7dS01NDcnJnv8fOWklCCFmAN8FliiKMg/QA18E7gM2K4oyG9g88L1XsnlzI/v3m7nllkYiIrzrTCcr6yyWLHmLpUvfRqd7k+xsZULmBKC6WkdERJfm5mQyZGRkUFFRQX9/v9uO4Q8atlqt7Nq1i1mzZnnd5bCsrCxaWlowmUyT3i5fWtoHwOzZ3lFXMxHWrtXT1xdMXl7D+HeeAv6g4/z8fEJDQ71u0KRDw0KISW817ujoQFEUn2yZ77icpVU2e6pW1QCECiEMqG69BrgaeGHg5y8A66d4DLfxi190ExRk4cEHp2sdyhnk5eXR19eHyWSadFrw5EkjsbGe7yLqCjIzM7FarVRWVrr7UD6t4c8//5yuri63Z5omQ15eHkajkcjISHJycial4cpKNbV81lnhrg7P7dxwQxw6nZ133+31xOF8VseNjY2D2bagoCCtwxlGXl7eoLE4++yzJ6Xh9vZ2AJ80KGFhYZjNZs22Rk/aoCiKUg38BqgEaoE2RVE+ABIVRakduE8tMGK/ZyHEXUKIQiFEYUODe88wRmLfvja2bUsmN7eW6dNDxn+Ah8nIyOCqq65i1qxZk+4F0NgYTEKCZ1v1u4rU1FT0er1b3xhT1TBoq2O73c6OHTswm82T3iXjTjIyMnjwwQcB+PDDDyel4epqCAnpJTbWu/5xOUNiYggZGQ3k5099YvRY+PpanJ+fj8FgYNmyZR4/9nhkZGSwYcMGAB599NFJadiXDQqor8GJEyewWDz/v2Qql3hMqA49HTAD4UKIW519vKIozyqKskRRlCXx8fGTDWPS/PznLYDCL385zePHdhaTyURPTw+9vZM7A2tuDmf6dKuLo/IMQUFBpKSkuDW1OFUNg7Y6LikpoampifPPP99rdj2cjqN/QkvL5Eof6uoMxMZ2uTIkj3LBBT1ub3vvy2txR0cH+/btY8GCBYSHe2eWLCIiAoPBMGkN+7pByczMRFEUysrKPH7sqVziuRQoUxSlQVGUfuD/gPOBk0KIJICBz/VTD9O1nDjRzXvvmVm5spo5cyK1DmdUprK4Nzf30dsbQnKy9o34JktGRoa72977rIYVRWH79u2YTCbmzJmjdTijMlWDUl8fTHy8Ry6RuIWrrw7FA23vfVbHu3btwm63n9HJ1JsQQmAymaZkUIxG47CRHr7EzJkzMRqNmlzmmYpBqQTOE0KECfX0bTVwCHgXuH3gPrcD70wtRNfz0EP19PcH8cAD3unYHcTGqjsYJvPGKClRzzpTUnyvQNaBB9re+6yGKysrqa6uZvny5V616+F0QkNDCQ4OnvQ02ubmMBITfTMLCB5re++TOrZYLBQWFjJ37tzBtc5biY2NnZJBiYqK8tos53jo9XrN2t5PpQZlF/AmsAd1W5sOeBZ4DLhMCHEUuGzge6+hvb2fV1+NZ8GCalau9N7LOzC8E+dEOXZMPetMTze6MiSPMn36dMLCwtz2xvBVDYN63T4sLIwFCxZoHcqYOM4+J9OJs6vLSmdnODNm+G4WMChIxznnNFJYaMJud8/v4as6LioqwmKxeGWB9+nExMTQ0tIyanfWsXAYFF8mMzOT5ubmSZu0yTKlvbWKojwAPHDazRZUB++VPPpoDV1dqfz0px1ahzIuISEhhIaGTurss6xM3Z7ri9szHXii7b0vari+vp4jR45w8cUXYzR6vwE1mUzU10/86sLRo11ANDNn+uaZp4PVq63s3h3F7t0tnHeee7rK+pqObTYbO3fuJD09HbPZezp4j4bJZKK/v5+urq4zBpyOR3t7O+np6W6KzDNo1fbee3PDbqC/385f/xpNeno911/vXT0jRiM2NnZSZ5+O7ZlZWRN7M3kbmZmZdHZ2TuofnL+Sn5+P0Whk6dKlWofiFI4MykTPPo8eVQtLfTkLCHDDDaopeeutNo0j8R727dtHR0eHT2RPYPKX2+12Ox0dHURGem+tozM42t57+jJPQBmUP/yhmsbGGL73vT6vGQo4HpMtzqquhvDwLq9rQDdRtG4U5G20t7ezf/9+Fi5cSFiYe7evugqTyYTNZqOjY2JZy+PHHU3afLO40IFsez8cx1DAxMREr5hY7AyTLfbu6upCURSio6PHv7MXI4QgMzOTsrIyj7a9DxiDYrcr/O53IcTHt3D33d6fUnTgOPu02WwTelxdne82aRvK0Lb3klNDAb1518PpOM4+J3qp8lQW0LuL2Z1h2bI2DhyIp6dnYu9jf8QxFNCbt8efjqMecKIa9vUtxkPJyMigt7eXmpoajx0zYAzKq6+qQwG//vV2rxoKOB4mkwlFUQaF7iwNDcHEx/tmk7bT8UTbe1+gt7eXoqIirxsKOB6TPfusrobg4F7i4oLdEZZH8VTbe18gPz/f64YCjofBYCAqKmrCl9vb2tTLev5iUMCz2Wzf+U89RX79a4WIiC5++tMZWocyIRyL+0Sde0tLONOn+8fZmgfb3ns1jqGAvnLd3kF0dDRCiAkblNpaAyaT72cBweNt772WEydOUFlZyXnnnYde71stEEwmU0BnULRoex8QBuXjj5vYt8/MzTc3+FxNxmTOPtva+unuDvXp7ZlDcbS9D+Q6FMdQwMzMTKZP977ZUWOh0+kGt2lOhIaGIJ9u0jYUR9v77dt9o27IXeTn5xMSEsKiRYu0DmXCTKYesL29Hb1eT2io7+6mHIqn294HhEF56KEugoL6ePBB39i5M5TIyEj0ev2E3hglJWrn1dRU//jzOtreB3Idyr59++js7PS57ImDySzuzc1hJCT4z2W9Cy7oobzcvW3vvZnGxkYOHz7slUMBncFkMtHZ2TmhS80dHR0+3aTtdDzd9t4//oONwb59bXz6aTJXXVWD2ex7LnYyZ5/+0KTtdDzQ9t5rcex6SEpK8tl+ChM1KD09Ntrbw316VMPprF8fhgfa3nstjqGA5557rtahTIrJZLPb29t9fgfPUBxt7z2VzfZ7g/LAA+pQwF/8wrtbKY/FRBf30lLV4c+a5dvbM4figbb3XosvDAUcD5PJRHd3t9Op4aNHOwHh803ahrJ2bZwn2t57Jb4wFHA8JmtQ/KH+xIGj7b2n1mG/NijV1T28956ZCy+sZt483xWJw6A42+jKX5q0DcXdbe+9FcdQwJiYGObOnat1OJNmoou7vzRpG4on2t57K74wFHA8JtqszbH70tebtJ2OJ9ve+7VBefDBOvr6gnjwQd907A5MJhMWi4WeHueuXVdXC8LCeoiOdu3iXlpaSk5ODgaDgZycHI9mMxxt748fPz6peRi+yokTJ6iqqvL6oYDjMVGDUlamNmnLzHTtFmMtNQxq2/uWlih272716HG1xDEUcM6cOV4/FHAsQkNDCQoKclrDXV1d2O12l2dQtNawJ7PZvrvijYM6FDCB+fOrufhi7x4KOB4Tde51dXpiY7tcHkdubi4NDQ2YTCYOHz5Mbm6uy48xFpmZmXR1dQVU2/vt27cTGhrKwoULtQ5lSkx0u3xFhXuatOXm5nLixAkSExM5cuSIxzV8443q6/DGG4HT9t6XhgKOhRBiQlON3bXFODc3l2PHjmE2mzl+/LjHNezJtve+ted2Ajz2WDWdnWncd5/3DwUcj6FnnzNmjN/HpaEhmLg4128DKykp4Yc//CGhoaF0dnZSUVFBQUEBaWlpxMXFub0+YmijoMRE39uRNVEaGho4cuQIK1eu9ImhgGPhGHzp7OJeVQVBQRYSElybQSkpKeH6669nzpw59PX1UVlZybZt20hNTcVsNru9N8eCBWrb+y1b/HbpHYZjKGBaWppTa5e3YzKZaGhwrtmew6C4uki2pKSEpUuXcsUVV2C326mpqeHDDz8kLS2NmTNnEhzs3saGjrb3hw4dwm63uzWz65fvEnUoYAxpafXceKPv/yObaJvl5uZwcnJc3+Bqzpw5hIaGcvToUXp6epg1axbvvfceAOHh4aSmppKWluY2wzK07b2vn405g2PXw7Jly7QOxSVMpNi7tlaPydSFTufaxTYrK4vIyEgaGhooKysjKyuLzZs3A2A0GklJSRnUsbsMy7JlbXz44XR6emyEhvpWs7KJsn//fjo6Oli3bp3WobiEmJgYjhw54tR0dXdlUBwattls5Ofnk52dzY4dO9i+fTtCCMxm86CGU1JS3GJYMjMz+eyzz6ipqSE5Odnlz+/ALw3Kn/5UTUPDTH72sxM+MxRwLIKCgoiIiHBqce/stNLVFeaWJm2vvfYab7zxBsePH6e9vZ3HH38ck8lEeXk5FRUVlJeXc/DgQUDtOpiWljb4RomPj3eJYcnMzKSwsJD+/n6fzyqMRXt7O/v27WPJkiU+MxRwPGJjY6murnbqvvX17skC5uXl8cc//pGamhrKy8v5wx/+QGJi4qB+Kyoq+OijjwDVsMycOXNQwzNmzHCJYVm7Vs977wWTl1fHjTf6VtO9ieDYHp+QkOAzQwHHIzY2dnDw5XjGw9GkzdXv37y8PB544AF6e3upra3l2WefJTk5maqqqkEN79y5k/z8fIQQJCUlDTMsISFT393paHdw/PhxaVAmgjoUMJj4+Fa+9S3fTyk6cAwNHA+1SVsMKSmuT7slJSUB8Mwzz7BgwYLB22NjY1m0aBGKotDa2kp5efngx1DDkpqaOvhGSUhImJRhycjIYOfOnVRWVvrNojcSu3bt8rmhgOMRExPDwYMHnUoLNzeHkp7u+l0CGRkZzJw5k5UrV/Lqq68O3j537tzBXVLd3d2DhqW8vJyPP/4YUOexzJw5c9B4z5gxA4Nh4kvoDTfEcc89atv7G290ze/ljRw9epSGhgauueYan90efzpDL7c7Y1AiIyNd/rtnZGRwzTXXUFVVRXFx8bDbHZfB+/v7OXHixKCOd+/ezY4dOxBCMH369MFM92QNi6Pt/fHjx1m5cqXLfrfT8TuD8vrrdZSXJ/HTn5ZjNMZoHY7LcGQqxkPdnhnjlu2Zjh4Wo6UMhRCYTCZMJhMLFy4cZlgcb5RDhw4BakX80EtCzhqWoW3v/dWg9Pb2UlhYSE5Ojk8NBRyP2NhY7HY7bW1tgwv9SPT12WlvD8dsdk9DM4vFMmbaOywsjDlz5jBnzhxguGGpqKg4w7AMzbA4Y1jUtvcn/b7tfX5+PlFRUT41FHA8hhqU1NTUMe/rzh4o42nYaDSeYViGZlgchgU4I8PibFv+jIwMtm/fTm9vr0uyMiPhdwbl17+2ExHRxX33+U/2BNQ3xr59+7BarWMugmVlapO22bNdL5jxDMrpnG5YgDMMy+HDh4FThsXxRklMTBzRsARC2/uioiKfHAo4HkMX97EMyvHjXShKpFuatCmKMu7ifjojGZbKyspBHW/ZsgVQDUtycvKghpOTk0d9r15wQQ/PP5/KiRPdzJzpf0alqqqKiooK1qxZ43NDAcfCMfjSmXrA9vZ2txUGT1TDRqOR9PT0wUsz/f39VFdXD2q4oKCAnTt3AmrPKYeGU1NTRzUsmZmZbNu2jfLycrKzs6f+S42AXxmULVua2Lt3Bl/7WhlRUb7ZEnw0HAt6a2srcXFxo96vslKdYHzWWa7v/TJRgzISMTExLFiwYPASUWtr67CzU4dhCQkJOcOwOC4LZGRksHnzZjo7O4mI8J9mdKAOBdy5cycZGRmDl9T8BWd7oZSUdAORbskC9vWp/VWmouGwsDCys7MHF+Wenp5Bw1JeXs7WrVvZunUrer2e5OTkwYU+OTl5sG5q/fownn9e8MYbTfzgB/5nUHx5KOBY6PV6oqOjx73c7mjS5jC1rsZisUwpO2M0Ggez16CuOw5TWV5eTlFREbt27QIgMTFx2CUhR03N0Lb30qA4gToUMJIHH/S/wrOhi/tYBqWqShAS0ktsrPYZFGeIiYkhJiaG+fPnA9DW1jYsw1JSUjJ4TIdZ6e5WdyhdeOGF9PX1kZeXN5jK9HX2799PZ2cn11xzjdahuBxnB1+Wlqomwh2jGtyh4dDQULKyssjKygKGG5aKigo++eQTFEVBr9czY8YM0tLSiI42Ehwcye9+d4i//e0Kv9JwU1MThw4d4sILL/TJoYDjYTKZxs2gdHd3Y7PZNLvEM1EMBsOgCVm5ciVWq3VYhuV0w+LIrNTU1FBXV8ePf/xjt2jYbwxKcXE7n3wyg3XrTjBjRprW4bgcZ88+6+oMA03afGNxP53o6Gjmz58/aFja29sHz0wrKio4cuTI4H1TU1PJy8sjNzd3WLGYr+LY9TB9+nSfHQo4Fs4OvqyocGQBXZ9Z8ISGTzcsvb29wwzLp59+iqIopKXFUVu7iKqqw36jYVCzJ3q93m+2x5+Oo1HlWLhri7EDi8XiVvNnMBgGM9igZlgcO98qKirYs2cPVquV+Ph4AGpqatyiYb8xKD//eTMQwS9/6butlMciIiICg8Ew7uLuru2Z4JnF/XSioqI455xzOOeccwD1jX/RRRcxc+ZMjh07ht1uH8yy+DolJSU0NjZy3XXX+c2uh9NxphdKVRUYjf0kJfmmyT6dkJAQzjrrLM466yxANSxnn72Siop7CAs77lca7uzs5PPPP2fBggV+d/nVwdDBl6PpyBMGxZMaNhgMpKSkkJKSAqgN+DIzM0lJSSE6OprOzk63aNgvDEpNTQ///ncSF15Yxbx5KVqH4xYcBafjLe7NzWFkZblv94MQQtP+I1FRUfT39/Pee+8Nbld1nKn6Ovn5+T4/FHA8TCYTVVVVY96ntlZPTEwnOt3ohbSTRQuDcjohISE0Nf2A/v4I2tq+4lca3rVrFzabza+2x5/O0Gz29OkjlxO406BYrVZsNpumGtbr9YSHh7N9+/bBddgddShTapYhhIgRQrwphDgshDgkhFguhIgVQmwSQhwd+Oz6VeY0Hnqojr6+YB54wLeHAo7HeHMgenpsdHaGk5zsnmF6Dteu9dl9Xl4e2dnZ6PV6srOzycvLm9LzeYOOKysrOXHihM8PBRwPk8lEb2/vmIMvGxqCiI/vdcvxvcGg7N4Nra03Ehv7Enr9Ib/R8NChgNOm+fb8s7FwZjZae3s7Op3OLVkkVxR6uwJXr8MjMdWV8HfARkVRsoH5wCHgPmCzoiizgc0D37uNzk4rL7+cwDnn1HDJJf77pgAGr9+PNs1XbdKGW7ZngufTiqORkZFBcXExVquV4uJiVxRmaa7j/Px8QkNDhzXA80ecqaVqbAwlIaHfLcfX2qDYbHD33ZCUJCgru92vNLxnzx56e3tZsWKFOw+jOc5o2F1N2kB7DTtwwzp8BpM2KEKIKOAi4G8AiqL0KYrSClwNvDBwtxeA9VMLcWwefbSazs5wfvIT/7xmPxSTyUR/fz9dXSNPKlabtOGW7ZngPQbFlXiDjhsaGigpKWHZsmV+uethKONNNe7vt9PeHoHZbHPL8bVe3P/yF9izB558ElyV/fcGDfvbUMCxCAkJISQkZFyD4s76E9DeoHiCqWRQMoAG4O9CiM+EEH8VQoQDiYqi1AIMfE5wQZwj0t9v53//N4rU1Aa++EX/21p8OuOlFt25PRP806DgBTp2DAVcunSpuw7hNYx39llW1o3driM52X1ZQEATI3jyJPzsZ3Dppbi6xb3mGj5w4ADt7e1+11xwNMa73C4NimuYikExAIuAZxRFWQh0MYEUohDiLiFEoRCi0Nnx1afzzDM1NDSY+O53e/1iKOB4jLe4V1baAcjKck8tjp8aFE113NHRwb59+1i4cCHh4f5dQwWqMQgPDx9Vw0eOqD1u0tLcU79vsVgwGo2adDf98Y+huxv++EdwceZfUw0risL27dtJSEhg1qxZE368LzLWhgVHkzZ3GxR3tZf3JqZiUKqAKkVRdg18/ybqm+SkECIJYOBz/UgPVhTlWUVRliiKssSxl3oi2O0KTz8dxLRpbXznO/6dUnTgmMsyWnq8qgqCg3uJj3ePifBTg6Kpjnfu3Ol3QwHHY6yzT0cW0B2jGkA7DX/yCfzjH/CjH4EbNuxoquFjx47R0NDA+eefr3kBvadwDG+12+1n/Kynpwer1SozKC5g0gZFUZQ64IQQwvF2Ww0cBN4Fbh+47XbgnSlFOApvvnmSsrIEvvrVFoxG/931MBSDwUBUVNSobZbr6vSYTN1uO74/GhQtddzb20tRURFz584dczaNvzHW2WdZmRVwT5M20EbD/f3wzW9Caircf7/rn1/rtXj79u1ERUUxb948dzy9V2IymbDb7YPbiYfiiR4oEBgGZap51O8ALwkhgoBS4A5U0/O6EOKrQCVwwxSPMSKPPmojPLyL++8PjOyJg7HaLNfXB7tteyb4p0EZQBMdFxUVYbFYAua6vYOYmBj279+PzWY741JLVRUYDFaSk52bqDpRtNDw738PxcXwzjsQ5r6xO5po2DG/5fLLL/eroYDjMfRy++kTx6VBcR1TMiiKouwFlozwo9VTed7x2LpVHQp4553+NxRwPEwmE8eOHRvxZ83NYWRmNrnluHa7nf7+fr98U2ihY6vVyq5du0hPT8dsNrvrMF5JbGwsiqLQ2tp6Rr+MU03aYtxybE8blKoqeOAB+MIXYN069x1Hq7XYX4cCjsfQ3Winj6XwhEERQow51d5f8MlrIw891IXR2MeDDyZqHYrHMZlMdHZ20t8/vE9Eb6+N9vZwZsw485qoKwgk1+4J9u/fT0dHh9/3jBiJsYq96+uNTJvmP1nAH/xA7X3y+9977JAewzEUcMmSJQG3LkRFRaHT6UbUcHt7O0IIt7X695aGmZ7A5wzKoUMdbN06g7Vra5g50//GlI/HaIv7sWNdgGDmTPf8SaVBcR2OoYCJiYl+M8F2IoxlUJqaQklM7HPbsT1pUD74AN54Q6078cPZj+zYsQO9Xs+5556rdSgexzH4cqR6QEeTNnd1hPbjS+1n4HMG5b//uwkQfjsUcDxGW9wdTdoyMtzXpA2kQXEFR44cobGxkRUrVgTEWdDpjDb40mZTaGtzX5M2cP8U2FPHgW9/G2bPVnfu+BudnZ3s3buX+fPn++1QwPEYrR7QnVuMQRoUr6Wurpe8vCQuuKCKc85xnwC8mdGatR0/rhqIzEz3bTEGaVBcQX5+PtHR0X49FHAsRht8WV7ejc2md1uTNkVRPLa4P/EEHD2q9jzxx7fM7t27sdlsAVfgPZTRdqNJg+I6fMqgPPigOhTw5z8PvEs7DkJDQwkKCjrjjVFR4f4mbSANylQ5ceIElZWVLF++PKB2PZzOSIu7u5u0Wa1WFEVxu4bLyuCRR+CGG+Dyy916KE3o6+ujoKDA74cCjsdIgy/d3aQNpEHxStShgHGcfXYNq1fHaR2OZox29llVBUFBfSQkyAyKN+MYCrhw4UKtQ9EUR3p86OBLf8kCfve7oNer83b8EcdQwEDOnsDIl9stFgv9/f3SoLgInzEov/51NR0dEQExFHA8RurEWVenJyamy20t/6VBmTqNjY0cPnyYpUuX+v1QwPFwDL7s7j7VWLCiwv1N2sC9Gn73Xfj3v+GhhyA52W2H0QybzcaOHTtITU0l2R9/wQkw0uV2d28xBmlQvA6bTeHZZ6NISWng5pv9fyjgeMTExNDS0jLs7NMTTdpAGpSp4BgKuGzZMq1D0ZyRphqfOAF6vZXUVN80KN3davYkJ0f97I8UFxcH1FDAsXA0aBtqUNra2gBpUFyFTxiUZ56ppr4+cIYCjkdsbCw2m42Ojo7B29Ttmf1jPGpqaDkF1h9wDAVcsGBBQAwFHI+Rzj5ranTExHSh1/tmFvCRR6CiAv78ZzC6ZzOdpjiGAsbHxzN79mytw9Gc4ODgMwZfujuD4s8NM0fC6w2K3a7w1FOBNRRwPE6/9tnXZ6e9Pdwj2zMDcVusK9i1axd2uz2ghgKOxUhnn/X1QUyb1jPKI6aOOw1KSYm6c+fLX4aLLnL503sFx48fp76+PqCGAo7H6fWAnmjSBoGTyfZ6g/L22/WUlqpDAYOCvD5cj3B6evz48S4URcfMme5bNAIprehqLBYLhYWFzJ07dzBzEOg4Bl8OXdwbG0NJSHBvkzZw/eKuKPCtb6lzdh5/3KVP7VU4hgKeffbZWofiNYxkUCIiIty2Q08aFC/jV7/qJzy8m5/9TGZPHERHRyOEGHxjOJq0paW5L6/c19dHSEiI257fnwnUoYDjMXRxt9sVWlvDSUpyz6gGcN/i/vrrsHmzeokn0U+nb1RXV1NeXs55550X0NvjT8dkMtHW1obNpmavOzo63F5/AtKgeAXbtjWzZ08yN95YT3S0H17UnSR6vZ7o6OjBxd3d2zNBZlAmi81mY+fOnQE5FHA8hhqUyspubDaDW3e+uGNxb2+H738fFi2Cb3zDZU/rdeTn5xMcHBxwQwHHw2QyoSjKYHGsJ3qggDQoXsGDD3ZgNPbx0EMJWofidQxd3CsqVPeene2+4ktpUCaHYyigzJ6ciclkoqOjg/7+/sEmbenp7pvQarFY0Ov1Lp0C++CDUFcHzzyj9j7xR5qbmzl06BBLly6Va8BpnF4P2NbWJg2KC/Fag3L4cAdbtiQH7FDA8RhqUE6cAKOxn6Qk912CkQZl4gwdCpiZmal1OF6HY3FvbW0dzAJmZLhvl5irNbx/vzql+K67wJ93ju/YsQOdTheQQwHHY2g9oMVioa+vTxoUF+K1BuXnP29CUQJ3KOB4mEwmuru7sVgs1NbqiYnpdOsWbE8NWfMnjh49SkNDg9z1MApDzz7Ly93bpA1ca1Dsdrj7bjCZ4Fe/cslTeiVdXV0BPxRwLCIjIwcHX3qqSRsEjkFxXz51CtTV9fLuu0mcf34V55yTonU4XsnQxb2hIYi4OPc1aQOZQZkM27dvJzo6mpycHK1D8UqGavjEiUR0Ohtpab5hUP7xD9i+Hf72N/DnjVm7du3CarXK7fGjIIQgJiaG1tZWaVDcgFdmUB56qBaLJZj//u9QrUPxWoYu7k1NoSQkuK9JmyenwPoLjqGActfD6ISFhREUFERzczM1NTqio7swGt23JLlKwy0t8OMfw/nnw1e+MvW4vBXHUMDs7Gzi4gJ3/tl4OOZKedKgBEo22+sMSleXlZdeimfevBouvzxe63C8Fkc/jfr6Jtrawpkxw31N2vr61N4U0qA4T35+PiEhIXLXwxg4Bl+2trZSX290a5M2cJ1Buf9+aGpSO8bqvG4FdR2OoYArVqzQOhSvxlEP6NjJExkZ6bZjBVrDTK97ezmGAv74x4HxB5gsISEhhISEcPBgI3a7nuRk99afgDQoziKHAjqP4+zT3U3awDUGpaAA/ud/4DvfgfnzXRSYF+LYHp+SkhLwQwHHw2Qy0dfXx8mTJ93apA0C71K7VxkUm03hL3+JYubMBr70JTkUcDxiY2MpLlbTimlp7t2eCdKgOMuOHTvQ6/Vy14MTqAalhZaWcJKS3JcFhKkXetts8M1vwvTp8ItfuDAwL6S4uJi2tjaZPXECRza7vLzcrZd3QM1mB9I67FVFsv/zP9XU1yfz+OMn5FBAJzCZTDQ0qIu6u5u0gTQoztDZ2cnnn38uhwI6iclkorMzCKvV6NYmbTD1s89nn4XCQnj5ZXDz/yFNcWyPl0MBncNRD9jb2+t2gyIzKBry9NNGYmPbuOce2dbeGUwmE+3t6hvC3dszQRoUZ9i1axc2m002ZnOS2NjYQQ2nprovNW61WrHZbJMe11BfDz/7GVxyCXzxiy4Ozss4fvw4J0+elNvjncQx+BLcW38C6locSCNHvMagvPVWHceOJXLnnXIooLM4DIpebyU62n27eKRBcQ5FUSgoKJBDASfAUJPtzks8U9XwT34CXV3wpz+Bv//Pzs/PJzIyUg4FdBKj0Th46dDdNWcygzJBhBB6IcRnQoh/D3wfK4TYJIQ4OvDZ5MzzPPqolbCwbn72MzmvxFkci3tUVDsbNvzbbcfxd4PiKg07GufJ7InzREdHDxqU2trdbjvOVDS8bRs8/zzcey/MmePiwFyIK3Tc399PWVmZ3B4/QaxWtdHg0aNH3XqcQGuY6YpUxT3AoSHf3wdsVhRlNrB54PsxOXiwlKKiZNLSNtDSUuWCkAKDoQblueeec9tx/N2g4AINg9ruur6+fvD1koyPXq+nrU01KO+++6zbjjNZDVutamFsSgr813+5IzKXMmUdnzhxgr6+PpkBnCA9PT3YbDo++OADtx4n0DIoUyqSFUIkA1cBjwA/GLj5auDiga9fALYAPxnreWy2aQAcPjybs89uZOnSjBHvpyjjx+Sp+2h5nEOHDtHe3jbw3XkA1NZuH7xevHr1aj788MPxD+4k/mxQXKVhUP/Zfvjhh2zZsoXi4mLXB+tHXHrppWzevHngO1Xk27fne52G//AHdebO22+DN9c8u0rHISEhFBQU8K9//UtqeByGanjOnF0cOrSMhIQL3abhQGyYOdVdPE8DPwaGVgYlKopSC6AoSq0QYtxRxAZDH/HxR6mubqW7e/QLvM40RXLm+rA33Wcyz5GVlUBRURV2u3rN3mSqo6VF7SERFhbGf7n4VM9isWA0GtH5Z1eqp3GBhh3U1NTQ0+PehmP+wP3338+OHTvo7u4mNLSbnp4w+vv/AnyFsLAQt2gYJmZQqqvh5z+HK6+Eq692aTju4GlcpOPa2lpKSkpcH6Gfcf/995Ofv4uenvs5dEidFtnQ8BYwh7CwXpdrOBAbZk7aoAghvgDUK4pSJIS4eBKPvwu4CyAiIoKvf/1lHnvsMTIyMtiyRTr3sZnGv/9t4YYbbqC3t5eBocaEhITw2muvcfHFF7v0aP7q2qeq4YHnGNRxUlISM2bMkNfuneCSSy7htdde44YbbqCnJxz4KfAr9Horr7wS7xYNw8QW93vvVS/x/OEP3l0Y68q1OCkpCbPZjN1ud22Qfsj8+ZeQnX2czz5LAJ4B3kVR3kaID/nb3056hYZ9namcEq8A1gkhyoFXgVVCiH8CJ4UQSQADn+tHerCiKM8qirJEUZQljpTYueeeS15e3hRCChxaW1sxGAzodDpCQ0PR6XQYDAZaW1tdfix/NShMUcMwXMcAZ599ttSwkwzX8NPAL7HZ7uD3v5/t1OXRiTDRxf3DD+G11+CnP4WMka84exMuW4v7+/vJzMyUGh6Hfftg6VLYv38awcHfRqf7NqGhWxHiehQlh/vvX8LAaB6XIQ3KBFAU5aeKoiQripIGfBH4SFGUW4F3gdsH7nY78M54zzVr1iwAfvWrX5HhA6uBN/C3v/2N7u5u5s+fzzvvvMP8+fPp7u52S7GsvxoUV2oY1O2G1157rdSwk5yu4QUL3gYeZ/PmLH7wA+dquJxlIou7xQLf+hZkZqpDAb0dV+o4JiaGlJQU0tPT3Ravr/P667B8OfT2wtlnf4f+/meGaLgGIW6irCyGK6+Ezk7XHVcaFNfwGHCZEOIocNnA92MHodMRHR1NbW2tG8LxT6Kjo3niiScoLCzksssuo6CggMcff9wtnQz91aCMwYQ1DKpBqampcWtg/sTpGi4sLOCJJ/RkZOTx9NNq9sJVJsVisSCEwGAY/6r2b38LR47AH/8IPt4Ta8I6NhqNWCwWmpub3R6cr2Gzqf1wbroJFi6EoiJISak5Yx1+4okLWLz4SXbsgHXroLvbNccPRIPiklb3iqJsQa0QR1GUJmD1RJ/DbDbLxX0C/Otf/xr2vV6v59577+Xee+91+bEsFovft213hYaNRiOdnZ10dHS4vaOkPzCShn/4w3u59151a++vf60ahAcfnPqxHCZ7vM6o5eXw8MNw3XVwxRVTP66nmaqOjUYjoBZ7T5s2zcXR+S7NzXDzzfDBB3D33fD00xAUNNY6DP/8J3z5y3DNNfDOO1M3u4FoULxmW0ZSUhLNzc309vZqHYrkNAIwgzIphi7ukskjhNqx9Y474KGH4NFHp/6czg5Zu+cedbfgU09N/Zi+iNFoxGAwSA0PYd8+WLIEtmyBv/4V/vxn1ZyMx623qvf/4AO44Qbom+KwbmlQNMRsVjvIyss83oc0KM5hNBoRQsjF3QXodPC//wu33KLOwJmqYXBGw3l58O678MADMHPm1I7ny0yfPl2uwwO89ppab2KxwNat8NWvTuzxd96pGpp//1vNwAw0nJ0U0qBoSFJSEiDPPr2NQGwONFmEEMTHx8vF3UXo9fDCC3D99fCDH6hZlckynoa7u+G734W5c+F735v8cfyBpKQkamtrUVy9lcqHsNnUAukvfvFUvcl5503uue6+WzXY//d/cNtt6nNPhkA0KC6pQXEFYWFhxMTESIPiZVitVhRFCag3xVQwm80cPXoURVHkJFgXYDDAyy+r6fFvfxuCg+FrX5v481gsFsLCRp/4/eijav3Jxx/DwJW6gMVsNlNQUEBTUxNxcXFah+NxmptVY7Jp0/B6k6nwve+pWZj77lM1/NxzzjUeHYqfN8wcEa/6Tc1mszz79DIC0bVPhaSkJLq6uujo6NA6FL/BaFS3dl5xBdx1F/zjHxN/jrEyKEeOwOOPqzUDLu6t5ZM4LrcH4smio95k69aJ1Zs4w09+otZUvfCCanwmmqAKxEy2VxmUpKQkWlpaZKtwL0IalIkRyIu7OwkOVlPkq1apxbOvvTaxx4+2uCuKmpkJCYEnnnBRsD5OXFxcQBbKDq03+eSTidebOMN//7e6ff7ZZ9WC7ImYFGlQNEYu7t6HNCgTIzExURbKuonQUHW75ooV8KUvqQP8nGW0xf3NN9VU/sMPw/TpLgzWh9HpdIN1KIGA1Xpmvcm557rnWELAI4+oNVV/+IN6XGdNijQoGuMolA2UN4YvIA3KxDAajSQkJEgNu4nwcNiwQW0zftNN6tfjYbfb6e/vP0PDHR3w/e+r/5TuvttNAfsoDoPi7zN5mppg7Vo1e3b33fDRR+43qkLAb36jdiv+zW/UgZTOIA2KxoSGhmIymeTZpxchDcrESUpKoqamJqB3QbiTyEj4z3/gnHPUhmoffDD2/UfT8EMPqROL//xntRhXcgqz2Ux/fz9NTU1ah+I2Pv9cNbqffOL6epPxEAJ+/3u14Pvhh9WP8ZAGxQuQHWW9C0fjvEB7Y0wFs9lMd3c3bW1tWofit8TEqMYkKwvWr1ebaI3GSAblwAF1d8bXvjb57aP+jL9fbn/1VbXepK8PPv3UPfUm46HTwV/+om49/u//Hr8GShoULyApKYm2tja6XTXAQDIlZAZl4vj74u4txMaqU4fT0+ELX4Dt20e+3+kaVhS1lX5MDDzm1JSlwGPatGl+OVvKUW9y882weDEUFsKyZdrFo9OpW45vukmN6/e/H/2+FouFIE+leLwErzMocnH3LhyLe6C9MaZCYmIiOp1O1qF4gPh41aSYzWotwe7dZ97ndIPy4ovqWfNjj4EcNzMy/lgoO7Te5JvfhM2bvaMw2mBQNXnNNerOnr/85cz7BGrDTK8zKLKjrHdhsVjQ6/VOTYGVqBgMBhISEqSGPURSklrcGBcHa9bAZ58N//lQg9LSAj/6kXpZ5847NQjWh/CnQtnPP1f7m3zyCfztb2pXYm865zIa1ctOV10F3/gGPP/88J8HasNMrzMoISEhxMbG+pVz92UC0bW7Alko61mSk1WTEhUFl10G+/ef+tlQg/Jf/wWNjfDMMxPv5BlomM1mrFYrDQ0NWocyJRz1Jv39aubMW41pUJC67f2yy9QYX3751M8C9VK7V75FZaGs9+DsFFjJcMxmM729vbS2tmodSsCQlqam7YOD4dJL4fBh9XbH4n7wYCjPPKNu71ywQLMwfQZfH+BqtarZsptvVrMnRUXa1ps4Q0gI/OtfcNFF8OUvw1tvqbdLg+JFmM1m2tvb6erq0jqUgEdmUCaHrKXShlmzVJMihNp19tgxVcN2u+CHPwwjIQF++Uuto/QNpk2bRlBQkE9q2FFv4ug38uGHkJiodVTOERamTj8+91y1eVxenjQoXoWsQ/EepEGZHAkJCeh0OqlhDcjOVv8h9fWpJqWiQrBnzyIKC3X89rcQHa11hL6BEGLwUqUvsXfvqXqT556DP/7Ru+pNnCEiAt57T20ieP318MEH6r/qkJAQjSPzLNKgSEaltLSUvXv38sEHH5CTk0NpaanWIfkMBoOBxMREn02P+zrz5qkt7NvabHz965l8+OEqwsJ2c955UsMTISkpiZMnT2Kz2bQOxSleeQXOP/9Uvckdd2gd0eSJjob334dZsyx89asmSkvTuOWWWwJqHfZKgxIcHExcXJxc3DUmNzd3cHvb4cOHyc3N1Tokn8JRSyULZbVh4UKYNu0WLJYI+vqC6em5k3XrpIYngq8Uylqt8MMfwi23+E69iTOYTGC1riIoqJJXX/0ihw9XBdQ67JUGBfDJ1KK/UVJSQmhoKL29vdjtdkpKSrQOyadISkrCYrHQ0tKidSgBS2XlW1x66c+56qo/oSjFUsMTxBdqqZqa4Ior4Le/VSdT+1K9iTMcP76LxMQ8+vqC6e62BZSGvdagmM1mOjo66Ozs1DqUgCUrK4uQkBB6enrQ6XRkZWVpHZJP4QuLu7+TlZXF9OlNxMXtlRqeBLGxsQQHB3ttNttRb7JtG/z97+qEYF+rNxmPrKwshFA7Cvb11QeUhr3aoIBc3LXkrbfeQgiBxWIhOzubvLw8rUPyKRISEtDr9VLDGpKXl0dMTIzU8CTx5kLZ0+tNvvIVrSNyD3l5eQQFJRIc3Et29uyA0rDXGpTpAz2IvfGNESgkDuRJ//jHP1JcXExGRobGEfkWer1eFspqTEZGBikpKdxwww1Sw5PEbDZ7VaHsSPUmS5dqHZX7yMjIIClpLmFhfQGnYa81KEFBQcTHx8vFXUMck4xDQ0M1jsR3MZvN1NbWykJZDent7Q247ZmuJCkpCZvNRn19vdah0Ng4vN5k82b/qjcZjfZ2PRERfVqH4XEmbVCEEDOFEB8LIQ4JIYqFEPcM3B4rhNgkhDg68Nk02WPIjrLa0tPTA/j33nt369hsNmOxWGhubnZt4BKnsNls9PX1SQ1PUcOgfTZ7pHoTo1HTkDxGR4eBiIh+rcPwOFPJoFiBexVFmQOcB3xLCDEXuA/YrCjKbGDzwPeTIikpic7OTjo6OqYQpmSyBEgGxa06lj19tMXRgVNqePIaNplMhISEaKrhl19W601sNv+uNxmNzk4jkZHecYnNk0zaoCiKUqsoyp6BrzuAQ8AM4GrghYG7vQCsn+wxvMW5ByoOg+LPZ5/u1nF8fDwGg0FqWCMCIQvobg07CmW1uNxutcK998KXvqTWmRQW+ne9yWh0dwcRFSUNyqQQQqQBC4FdQKKiKLWgvnGAhFEec5cQolAIUThaE6Dp06cjhJCLu0YEwuI+FHfoWK/XM336dFlLpREBkgUcxF1rsaNQ1mq1uifwEWhshDVr4Mkn4Tvf8b/+JhOhuzuYmJjAq2ObskERQkQAbwHfUxSl3dnHKYryrKIoSxRFWRIfHz/ifYxGoyyU1ZDe3l6EEAT5W2OBEXCnjh1nn7JQ1vMEksl2p4bNZjN2u91jhbKffabWm2zfrtab/P73gVNvcjqdnVasViOmSVdz+i5TMihCCCPqG+IlRVH+b+Dmk0KIpIGfJwFTUrRsF64dPT09hIaGIoTQOhS34m4dm81m+vr6aGpqmnqwkgkRKBkUd2vYk7VUL78MK1YEbr3J6Zw8qdZRSYMyAYT6X+tvwCFFUZ4c8qN3gdsHvr4deGfy4alvjK6uLlkoqwGBsD3TEzqWtVTaEQgZFE9oOCYmhtDQULdq2GqFH/zgVL2Jv/c3cZa6OtWgxMXpNY7E80wlg7ICuA1YJYTYO/BxJfAYcJkQ4ihw2cD3k0Yu7trR29vr92eeeEDHcXFxslBWIwIkg+J2DQshBnv6uANHvclTT52qN0kYsWIm8KivV7cXB6JBMUz2gYqibANGy/2vnuzznk5iYuJgoWx2drarnlbiBI5LPP6MJ3Ss0+k02wUR6PT09GAwGDAYJr3UeT2eWouTkpLIz8/HarW69PXcsweuvRbq6uD55+H228d9SEDR0KAWJsfH+6+GR8NrO8k6MBqNJCQkyMVdAwIkg+IRHAbFbrdrHUpAEQiXKT2Fo1D25MmTLnvOl146VW+ybZs0JyPR2KhuL05ICLwqYa83KMDgsCpZKOtZenp65OLuIsxmM/39/TQ2NmodSkAhTbbrcOXldke9ya23wrJlar3JkiVTflq/pKlJPamZPj1Y40g8j08YFLPZTHd3N21tbVqHEjAcP36crq4unn76aXJycigtLdU6JJ/GsbjLTKDnKC0tZcuWLRQVFUkNu4CoqCjCwsKmbFAaGuDyy2W9iTOUlpayceMuANauXR5wGvYZgwJycfckt912Gzqdju7ubg4fPkxubq7WIfk006ZNw2g0ykJZD3LddddhNBrp6emRGnYBriiU3bNHzZTk56v1JoHc32Qs7HYoKYGLLnqWkycXEBTUy+HDBwJOwz5RdZOYmIhOp6OmpoY5c+ZoHY5f09vby5YtW7j00kvp7e2ltLQUu91OSUmJ1qH5NI5CWWlQ3I/dbqeoqIjLL7+ckJAQPv30U6lhF5GUlMTx48fp7+/HOEFn8dJL8LWvQXy82oBt8WI3BeljKApUVkJBwamPoiJobwd4DKOxD7N5CxUVgadhnzAoBoOBhIQEubi7Ebvdzp49e/j444/p7u6mvLyct99+m87OTnQ6HVlZWVqH6PMkJSVRVFSE3W5Hp/OJ5KXPUVpayvvvv099fT2dnZ28+OKL1NbWSg27CLPZjKIo1NXVMXPmTKceY7XCj34ETz8NK1fC668H9iWdkyeHm5HCQvWyF6jZpJwcK8uWlREefpCYmKPs3Pl3SkoOBqSGfcKggPrGOHToEIqi+H1nU09TVlbGxo0bqa+vJzU1lTVr1tDT00NRURElJSVkZWWRl5endZg+j9lsZteuXTQ0NJAYqENF3ERzczMffPABJSUlxMTEcOONNxIUFMSWLVuor6+XGnYRQy+3O2NQGhrgxhthyxb47nfhN78JrEs6LS1qNmSoIamqUn+m08HcufCFL6gN6c45x0JLyyd89tlODAYDF110EQkJc1m//u/o9fqA1LBPGZQ9e/bQ2tqKKRB7/rqBlpYWPvjgAw4fPkx0dDQ33HADc+bMGTSAxcXFGkfoXwzdBSENimuwWCx88skn7Ny5E71ez6pVq1i+fPlgnw6pYdcSGRlJeHi4U9nsPXvgmmvUjMELL8CXv+yBADWkq0udITTUjBw7durns2bBhReqZmTpUli4EMLD1ez13r172bx5M93d3SxYsIDVq1cTEREBBLaGfcagDJ0FIQ3K1LBYLHz66afs3LkTnU7HJZdcwvLlyyd8TVkyMaZNm0ZQUBA1NTUsXLhQ63B8Gsei/tFHH9HV1cWCBQtYtWoVkZGRWofm1zgKZcczKP/8J3z96/5bb2KxwL596uUZhxk5eFAtbgVITlZNyJ13qp8XLx55lk5FRQUbN24cvGT2pS99afBERuJDBiUhIQG9Xk9tbS05OTlah+OTKIrC559/zubNm+ns7OScc85h9erVREVFaR1aQCCEkB1lXUBFRQXvv/8+tbW1JCcnc/PNNzNjxgytwwoYkpKSOHbsGH19fWdMOvfHehObTTUfjnqRggLVnPT1qT+Pi1NNyLXXqp+XLIHp08d+ztbWVjZt2sTBgweJioriuuuuIycnR5YvnIbPGBSDwUBiYqIslJ0kJ06cYOPGjdTU1DBjxgxuuukmkpOTtQ4r4DCbzezevRubzYZeH3izNaZCW1sbmzZtori4mKioKK699lrmzZsnF3UPM7RQNiUlZfD2ofUm99wDTzzhe/UmiqJelhlqRvbsge5u9edRUWo25HvfO3WpJiUFnJVgX18f27ZtIz8/HyEEF198Meeff77MXo+CzxgUUJ17cXGxLJSdAG1tbXz44YccOHCAyMhIrrnmGs4++2z5+mlEUlISNpuNhoYGpo93miUB1EV9+/bt5OfnA7By5UrOP//8M87eJZ5haC2Vw6AUFan1Jg0N8I9/wG23aRmhcyiKWrA6dDdNYSG0tqo/DwlR60S+9rVTZmT2bLW4deLHUti3bx+bN2+mo6ODs88+m9WrVxMdHe3S38nf8CmDYjabKSoqoqWlhdjYWK3D8Wr6+/vZvn0727dvB+DCCy/kggsukIu6xgxd3KVBGRtFUdi/fz8ffvghHR0dzJs3j0svvVQu6hoTGRlJRETE4KXKF1+Eu+5S6022bfPeepOGhjO39zrGChkMcPbZagbIYUZyctTbp0pVVRUbN26kuroas9nMDTfc4PQW7UDHpwyKY9DaxRdfjM1mIy8vj4yMDI2j8i4URaG4uJhNmzbR3t7O3Llzueyyy4iJidE6NAnqtee+vj4eeOABSktLpYZHobq6mo0bN1JVVUVSUhLXX3/9sMsJEu0oLS2lpKSEY8cq+NrXOmluvo2LL1brTeLjtY5Opa3tzO29lZXqz4SAOXNgzZpTZmT+fDVj4kra29vZvHkz+/btIyIigquvvpr58+fL7PUE8CmD8pWvfGXwEsXevXv58pe/zMaNGwkPD5d/dNSz8o0bN3LixAmmT5/OtddeS2pqqtZhSYawbt06li5dSnp6OhUVFdxxxx288847REZGypoUoKOjg82bN/P5558THh7OunXrWLBggXx/exG5ubnExqZQVfVnmpvTiYw8yCOPmAkODgc8X0vR3Q179w43I0eOnPp5Rgacd54692fpUli0CNy52au/v58dO3awbds27HY7F1xwARdccAHBwYE37G+qCG+YELxkyRKlsLBw3PsZDAZuvPHGM7rp6fV6oqKiiIqKIjo6etjXju9DQkL8dpHr7Oxk8+bN7N27l/DwcFatWsWCBQsCtlupEKJIURSPz0Z1RscGg4Fly5axZs2aYbcLIYiIiDhDv0N17M9G3Gq1smPHjsG29Oeddx4XXnhhwC7q3q7huLhLaWz8Nzbb8HPcsLBupk3rJj7eQlKSlZkz7aSm6snMDCIrK4yzzgonJGTyRryvD/bvH769t7hY3WkDkJR0Kivi2FEzbdqkDzchFEXh4MGDbNq0iba2NubMmcNll10W0G0xpqpjn8qgZGVl8dprrxESEkJMTAxz587lkUceoa2tjfb2dtra2qioqKC9vZ3TjZfRaBzVvERHR9PU1MS11147rHOqt6ferVYrO3fu5NNPP8VqtbJ8+XIuuugiQlydq5S4jKysLHbt2sWePXuIiYkhJyeHxx9/nPb29kEN19XVceTIEaxW67DH6nS6EU34UD3X1NSwbt06n9GxoigcOnSITZs20draSnZ2NpdddpmsMfNisrKyOHx4E0LEEBMzh5SUFdxwww+oqLBRVaWjrs5AXV0IBw+G09t7+lqkEBXVybRp3SQk9GE2W5k5E9LS9MyaFUxWVhhCnGT9+nUcPnyUtLQr+MY3/kpFRQIFBfD552oPEoDYWNWA5OaeMiRatRCpra1l48aNVFZWkpiYyPr160lLS9MmGD/CpzIopaWl5Obmjrv42u12Ojs7Bxf8oZ8dX3d2dp7xuJ6eHlpaWjhx4gRWq5V33nmH0NBQl/yOrkRRFA4fPsymTZtoaWkhKyuLyy67jGmeOlXwcrz57NNZDSuKQk9Pz6j6dXztqMtyYLVaaWlpoaamhvLycvR6PQUFBS79PV1FXV0dGzdupKKigoSEBK644grS09O1Dssr8AcNAzQ2Wigp6eLIkR5KS61UVtqprtZRVxdEQ0MILS3h9PcPL9zX6WyEh7fR0xOK1aquv+HhCosXi2HZkfR057f3uovOzk4++ugjPvvsM8LCwrjkkktYtGhRwGavT2eqOvYpg+JKbDbbsAX/29/+NpGRkcTFxTFz5szBfemJiYmkpaWRlpZGamqq5obl5MmTbNy4kfLycuLj41mzZg2ZmZmaxuRtePPi7krsdjtdXV3DTMwvfvELoqOjSUlJITw8HIDo6GjS09NJTU0lPT1d810wXV1dfPTRR+zZs4fQ0FAuueQSFi9eLBf1IQSOhhVqa3s5fLiLo0d7KSuz8vrrO7DZzMTECDIzmzGbq0lO7iIjI3VwLU5ISND0cqfNZmPXrl1s3boVq9XKsmXLWLlypcxen0ZAXeJxJXq9HpPJNHh9sKmpie3bt2O32zEYDCxfvpyHH36Y8vJyioqK2LVrFwDTp08nLS2N9PR0UlJSPCbI7u7uwUU9JCSEtWvXsmTJErmoBzA6nY7IyMhh7d0rKys5fPgwdrudxMREzj33XL70pS9RUlLC3r17ATCZTINmJS0tzWOdhG02G7t372br1q309/dz7rnnsnLlSs1Nv0Q7dDrBjBmhzJgRyurV6m3//vdVHD58mBMn7FRWRrN8+XLWrLmb8vJyDh8+DEBoaOigWUlLSyM+Pt4jhkVRFI4cOcIHH3xAc3Mzs2fP5vLLLycuLs7txw5EAtagnE5eXt5g2vKss87i+eefJyMjg4suugir1Up1dTXl5eWUl5dTUFDAzp07B1uXOxb7lJQUlxf12Ww2CgoK2Lp1KxaLhaVLl3LxxRfLRV0yIkN1PG3aNJ566ikyMjJQFIX6+vpBDR8+fHjQsMTGxg4zLK6eZ6MoCkePHuWDDz6gqamJWbNmsWbNGrmoS0ZkqIZnzJjBn/70p8FLSG1tbYMaLisr49ChQwCEhYUNMyxxcXEuNyz19fW8//77lJaWEhcXx5e+9CVmzZrl0mNIhhOwl3imgtVqpaqqirKyMioqKqiqqsJmsw0O0nK8SVJSUqbUGO3o0aO8//77NDU1kZmZyZo1a4j3lkYDXkygpMengqIonDx5krKyMsrLy6moqMAyUH04bdq0YYu9Y6rqZGhoaOD999/n+PHjTJs2jTVr1jB79mxX/Rp+i9Swc7S2tg6uw2VlZbS3twMQHh4+TMPTpk2btGHp7u5my5YtFBYWEhwczMUXX8ySJUtkWwAnkDUoXkB/fz8nTpwYdPbV1dXY7XZ0Ot0wwzJz5kynDEtjYyPvv/8+x44dIzY2dnBR99ctpq5GLu4Tx263U1dXN6jhiooK+gamocXFxQ1b7B21LWPR09PDli1bKCgoICgoiJUrV7Js2TK5qDuJ1PDEURSFlpaWQQ2Xl5fT0dEBQERExDANx8bGjrue2mw2CgsL2bJlCxaLhcWLF3PJJZcQFhbmiV/HL/BagyKEuAL4HaAH/qooymOj3deX3xQj0dfXd4ZhURQFnU7HjBkzhhmWoUOienp62Lp1KwUFBRiNRi666CLOPfdcuahPEFct7hPRMPiXju12O7W1tYMarqysHDQs8fHxwxb7oQu23W4fXNR7e3tZtGgRl1xyiVOmRnIKqeGpoygKzc3NwwyLY/dmZGTkMA2bTKZhhuX48eO8//77NDQ0kJ6ezpo1a0hMTNTqV/FZvNKgCCH0wBHgMqAKKABuVhTl4Ej396c3xUj09fVRWVk5+CapqalBURT0ej3Tpk3j448/prq6erCHyaJFi1i1apVc1CeJKxb3iWoY/FvHNpvtDMPS398PQEJCArGxsfzzn/8kJSWFhIQEEhMTueaaa+SiPkmkhl2Poig0NTUNMyxdXV0AREVFERcXx+uvv05UVBRnnXUWERERXHXVVWRlZcns9STxVoOyHHhQUZQ1A9//FEBRlEdHur8/vylGwmKxUFlZSVlZGRs2bCAmJgadTkdFRQUlJSWDA/4kk8NFi/uENAyBpWObzUZNTc3g9f8jR45gMBhoaWlh06ZNABQXF2scpe8iNex+FEWhsbFxUMOOHZIWi4VPP/2U1tZW9u/fr3WYPo23bjOeAZwY8n0VcK6bjuVzBAcHM3v2bGbPns2VV1452OX25MmT8nKO9yA1PAZ6vZ6ZM2cOTmUNDg4mNjaWxsZGrFar1LF3IDU8BkII4uPjiY+PZ9myZdx8882YTCa6urro6emRGvYC3GVQRsqHDUvVCCHuAu4a+NYihDjgplgmSxzQ6IHj5NhstpDe3l4AbDZbrxBitFNPT8U0Ebwxpqzx7zIu42oYvF7Hnvzb5NTV1Q02BRpDx96oF2+MSWr4FB5bixsbG53RsCdjmgjeGNOUdOwug1IFzBzyfTJQM/QOiqI8CzwLIIQo1KJifSxkTM7hrTG54GnG1TB4t469LR6QMTmL1PApZEzO4a0xTeXx7mpDWgDMFkKkCyGCgC8C77rpWBKJO5Aalvg6UsMSn8YtGRRFUaxCiG8D76Nub3tOURRZMSfxGaSGJb6O1LDE13Fbq3tFUd4D3nPy7s+6K44pIGNyDr+NaYIadtlxXYi3xQMyJmeRGj6FjMk5/C4mr+gkK5FIJBKJRDIUOQpXIpFIJBKJ16G5QRFCXCGEKBFCHBNC3KdRDDOFEB8LIQ4JIYqFEPcM3P6gEKJaCLF34ONKD8dVLoTYP3DswoHbYoUQm4QQRwc+mzwYT9aQ12KvEKJdCPE9T79OQojnhBD1Q7dDjvW6CCF+OqCvEiHEGjfEIzU8elxSwyPHITV8ZgxSw87FEzgaVhRFsw/Uwq3jQAYQBHwOzNUgjiRg0cDXkajtoecCDwI/1PD1KQfiTrvtceC+ga/vA36t4d+uDkj19OsEXAQsAg6M97oM/B0/B4KB9AG96V38OkgNjx6X1PDIx5YaPjMOqeHJ/e38VsNaZ1CWAccURSlVFKUPeBW42tNBKIpSqyjKnoGvO4BDqF0YvZGrgRcGvn4BWK9RHKuB44qiVHj6wIqifAI0n3bzaK/L1cCriqJYFEUpA46h6s5VSA1PHKlhqeEzkBqeFH6tYa0NykitmDUVpBAiDVgI7Bq46dtCiH0D6SyPpfEGUIAPhBBFQu32CJCoKEotqG9oIMHDMTn4IvDKkO+1fJ1g9NfF3RqTGh4bqWHnkRoeQGrYafxaw1obFKdaMXsKIUQE8BbwPUVR2oFngExgAVAL/NbDIa1QFGURsBb4lhDiIg8ff0SE2vRpHfDGwE1av05j4W6NSQ2PjdTw1JEalho+g0DQsNYGxalWzJ5ACGFEfVO8pCjK/wEoinJSURSboih24H9xbVp1XBRFqRn4XA+8PXD8k0KIpIGYk4B6T8Y0wFpgj6IoJwfi0/R1GmC018XdGpMaHgOp4QkhNSw1PBH8XsNaGxSvaMUshBDA34BDiqI8OeT2pCF3uwbw2BAtIUS4ECLS8TVw+cDx3wVuH7jb7cA7noppCDczJK2o5es0hNFel3eBLwohgoUQ6cBsYLcLjys1PHpMUsMTQ2pYangi+L+GPVXxO0Yl8JWo1drHgfs1iuEC1HTTPmDvwMeVwIvA/oHb3wWSPBhTBmrV8+dAseO1AaYBm4GjA59jPfxahQFNQPSQ2zz6OqG+KWuBflRn/tWxXhfg/gF9lQBr3RCP1PDIMUkNjx6D1PCZMUgNOx9XQGhYdpKVSCQSiUTidWh9iUcikUgkEonkDKRBkUgkEolE4nVIgyKRSCQSicTrkAZFIpFIJBKJ1yENikQikUgkEq9DGhSJRCKRSCRehzQoEolEIpFIvA5pUCQSiUQikXgd/x8U0rDR0IhaygAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 648x216 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print('A priori routes (orange) vs. realized  trips (blue)')\n",
    "plot_routes(inst, extended_routes, 'orange', showTour=True)\n",
    "plot_routes(inst, segments, 'blue', showTour=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### c) Fully flexible routing strategy\n",
    "\n",
    "*The algorithm is described below:*\n",
    "- As in the dedicated and overlapped routing strategies, create a large tour through all customers.\n",
    "- Select a starting customer and send out a vehicle at full capacity to sequentially fill as much customer demand as possible.\n",
    "- The vehicle returns to the depot upon exhuasting its capacity, and the next vehicle continues with the customer sequence where the previous vehicle left off.\n",
    "\n",
    "\n",
    "Note that as in the overlapped routing strategies, demands are learned in advance, which means each truck's starting and ending customers can be determined prior to the day's deliveries so that vehicles can execute their realized routes simultaneously.\n",
    "\n",
    "Also note that this strategy differs from full reoptimization since the sequence of customer visits within individul trips is fixed. In reoptimization, on the other hand, an individual vehicle trip can consists of any of the *N* customers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- FULLY FLEXIBLE ROUTING ---\n",
      "\n",
      "Tour (Row 1), Demand (Row 2):\n",
      "[[15  3 14  5  9 10  4  7 11 13  2  8 12  1  6]\n",
      " [ 7  3  0  5  3  4  7  1  2  2  7  6  4  4  0]]\n",
      "\n",
      "A priori routes:\n",
      "[15, 3, 14, 5, 9, 10, 4, 7, 11, 13, 2, 8, 12, 1, 6]\n",
      "[10, 4, 7, 11, 13, 2, 8, 12, 1, 6]\n",
      "[2, 8, 12, 1, 6]\n",
      "\n",
      "Realized trips:\n",
      "[15, 3, 5, 9, 10]\n",
      "[10, 4, 7, 11, 13, 2]\n",
      "[2, 8, 12, 1]\n",
      "\n",
      "Trip count:\t 3\n",
      "Radial cost:\t 265.0\n",
      "Circular cost:\t 259.5\n",
      "Total cost:\t 524.5\n",
      "\n",
      "Realized trips:\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x216 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "inst = deepcopy(inst_copy)\n",
    "print('--- FULLY FLEXIBLE ROUTING ---')\n",
    "#segments = create_full_trips(inst,[inst.tour[1:]],capacity)\n",
    "primary_routes = get_primary_routes(inst, route_size)\n",
    "extended_routes = get_extended_routes(inst, route_size, inst.size)\n",
    "segments = implement_k_overlapped_alg(inst,primary_routes,extended_routes,capacity,route_size,inst.size)\n",
    "combined = np.array([inst.tour[1:], [inst.demands[c] for c in inst.tour[1:]]])\n",
    "print('\\nTour (Row 1), Demand (Row 2):')\n",
    "print(combined)\n",
    "print('\\nA priori routes:', *extended_routes, sep=\"\\n\")\n",
    "print('\\nRealized trips:', *segments, sep=\"\\n\")\n",
    "print('\\nTrip count:\\t', get_trip_count(segments))\n",
    "print('Radial cost:\\t', np.round(sum([get_radial_cost(inst,seg) for seg in segments]), 1))\n",
    "print('Circular cost:\\t', np.round(sum([get_circular_cost(inst,seg) for seg in segments]), 1))\n",
    "print('Total cost:\\t', np.round(sum([get_total_cost(inst,seg) for seg in segments]), 1))\n",
    "print()\n",
    "print('Realized trips:')\n",
    "plot_routes(inst, segments, 'blue', showTour=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- FULLY FLEXIBLE ROUTING CLOSED ---\n",
      "\n",
      "Tour (Row 1), Demand (Row 2):\n",
      "[list([0, 2, 8, 12, 1, 6, 15, 3, 14, 5, 9, 10, 4, 7, 11, 13])\n",
      " list([7, 6, 4, 4, 0, 7, 3, 0, 5, 3, 4, 7, 1, 2, 2])]\n",
      "\n",
      "A priori routes:\n",
      "[15, 3, 14, 5, 9, 10, 4, 7, 11, 13, 2, 8, 12, 1, 6]\n",
      "[10, 4, 7, 11, 13, 2, 8, 12, 1, 6]\n",
      "[2, 8, 12, 1, 6]\n",
      "\n",
      "Realized trips:\n",
      "[10, 4, 7, 11, 13, 2]\n",
      "[2, 8, 12, 1, 15]\n",
      "[15, 3, 5, 9]\n",
      "\n",
      "Trip count:\t 3\n",
      "Radial cost:\t 242.6\n",
      "Circular cost:\t 271.7\n",
      "Total cost:\t 514.3\n",
      "\n",
      "Realized trips:\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-23-269d2df6d324>:6: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  combined = np.array([inst.tour, [inst.demands[c] for c in inst.tour[1:]]])\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x216 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "inst = deepcopy(inst_copy)\n",
    "print('--- FULLY FLEXIBLE ROUTING CLOSED ---')\n",
    "primary_routes = get_primary_routes(inst, route_size)\n",
    "extended_routes = get_extended_routes(inst, route_size, inst.size)\n",
    "segments = implement_k_overlapped_alg_closed(inst,primary_routes,extended_routes,capacity,route_size,inst.size)\n",
    "combined = np.array([inst.tour, [inst.demands[c] for c in inst.tour[1:]]])\n",
    "print('\\nTour (Row 1), Demand (Row 2):')\n",
    "print(combined)\n",
    "print('\\nA priori routes:', *extended_routes, sep=\"\\n\")\n",
    "print('\\nRealized trips:', *segments, sep=\"\\n\")\n",
    "print('\\nTrip count:\\t', get_trip_count(segments))\n",
    "print('Radial cost:\\t', np.round(sum([get_radial_cost(inst,seg) for seg in segments]), 1))\n",
    "print('Circular cost:\\t', np.round(sum([get_circular_cost(inst,seg) for seg in segments]), 1))\n",
    "print('Total cost:\\t', np.round(sum([get_total_cost(inst,seg) for seg in segments]), 1))\n",
    "print()\n",
    "print('Realized trips:')\n",
    "plot_routes(inst, segments, 'blue', showTour=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### d) Reoptimization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- REOPTIMIZATION (SDVRP) ---\n",
      "\n",
      "Tour (Row 1), Demand (Row 2):\n",
      "[[15  3 14  5  9 10  4  7 11 13  2  8 12  1  6]\n",
      " [ 7  3  0  5  3  4  7  1  2  2  7  6  4  4  0]]\n",
      "\n",
      "Trip count:\t 3\n",
      "Radial cost:\t 279.6\n",
      "Circular cost:\t 242.5\n",
      "Total cost:\t 522.1\n",
      "\n",
      "Realized trips:\n",
      "[15, 15, 15, 15, 15, 15, 15, 3, 3, 3, 5, 5, 5, 5, 5, 9, 9, 9]\n",
      "[4, 4, 4, 4, 4, 4, 4, 7, 11, 11, 13, 13, 2, 2, 2, 2, 2, 2, 2]\n",
      "[1, 1, 1, 1, 12, 12, 12, 12, 8, 8, 8, 8, 8, 8, 10, 10, 10, 10]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAigAAADGCAYAAAD43HteAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAvbElEQVR4nO3deXzU1fX/8dedREBwAcQFd1BISKwKglq3qiyuca0VF0rd96244Fb061oX1P6sWqxUtG64VIjVKotLsYoSBVmSgMSFgICAglQBk7m/P86kBAgwk1k+n5l5Px+PPCaZTOZzGM58cnI/957rvPeIiIiIhEkk6ABERERE1qYCRUREREJHBYqIiIiEjgoUERERCR0VKCIiIhI6KlBEREQkdDZaoDjnhjvnFjrnpjW6r71zboxzblbstl2j713vnPvcOVftnDsiXYGLJEJ5LNlOOSz5Jp4RlCeBI9e6bzAwznvfBRgX+xrnXAnQHyiN/cwjzrmClEUr0nxPojyW7PYkymHJIxstULz37wFL1rr7eGBE7PMRwAmN7n/ee7/Se/8F8Dmwb2pCFWk+5bFkO+Ww5JvmzkHZ1nv/DUDsdpvY/TsAcxo9rjZ2n0gYKY8l2ymHJWcVpvj5XBP3NdlL3zl3PnA+QJs2bfYpLi5OcSiSryoqKhZ577dO4imUxxIo5bDkgmTzuLkFygLnXEfv/TfOuY7Awtj9tcBOjR63IzCvqSfw3g8DhgH07NnTT5o0qZmhiKzJOfdVnA9VHksoKYclFySQx01q7iWe0cDA2OcDgVGN7u/vnGvpnOsEdAE+SiZAkTRSHku2Uw5LztroCIpz7jngUKCDc64WGALcDYx0zp0DfA2cAuC9n+6cGwnMAOqAS7z39WmKXSRuymPJdsphyTcbLVC896et51u91/P4O4A7kglKJNWUx5LtlMOSb9RJVkREREJHBYqIiIiEjgoUERERCR0VKCIiIhI6KlBEREQkdFSgZEBNTQ2lpaUUFhZSWlpKTU1N0CGJJKympoaSEuWxZC+di7OLCpQMKCsro6qqivr6eqqqqigrKws6JJGEfPQR9OgxlcrKidTXX01lpfJYso/OxdlFBUoGVFdXE41GAYhGo1RXVwcckcjGrVgBI0ZAr16w336wdOnhwGfA3Xj/KFVVnwcdokhCdC7OLipQMqCoqIhIxF7qSCRCUVFRwBGJrN9XX8HgwbDjjvC738Hy5fDww1BU1BvnDsF6f53PppuO5YcfAg5WJAE6F2cXFSgZUF5eTnFxMQUFBRQXF1NeXh50SCJr8B7GjoUTToDOneHee+GQQ+y+GTPgkkvg9defp1u3IgoKhtCx4x9YseIgDj4Y5s4NOnqR+OhcnF2au5uxJKBz585Mnz496DBE1rFsmV3G+fOfoboaOnSA666DCy+EnXde87Fr5/Gbb8Kvfw377w///CfsuWeGgxdJkM7F2UUjKBIKml2fWQ2jIjvsAJdfDltuCU89BXPmwJ13rlucNOWII2DCBBt9OeggeOut9McdZsphyXZhy2EVKBIKml2ffnV18MorcPjhUFoKTzwBJ59sK3QmToQBA6BVq8Sec6+94MMPoVMnOPpoGD48PbFnA+WwZLuysjIqK1dSX38+lZXVgeewLvFIKGh2ffosXAiPPw6PPQa1tTY6cvfdcM45dkknWTvuCP/+N5xyij1nTQ3cdhs4l/xzZxPlsGS7qqrleP8esAveV1BdXRFoPBpBaSRsw1v5RLPrU6MhhwsKCunUqT8nnvgDO+0EN90ExcXw6qtWQFx3XWqKkwZbbAGvvWYFyh132GjMypWpe/5soBxODZ2Hg7FoERQWjgfaAVGcOyL4HPbeB/6xzz77+DAoKSnxkUjEAz4SifiSkpJA4pg9e7YvKSnxBQUFvqSkxM+ePTuQODIplf9mYJLP0zwuKSnxzu3t4SMP3kciP/jLLvO+sjIzx49Gvb/jDu/B+9atJ/pIZCvlcDPkew7rPJxZy5Z536uX9y1a1Ptddvmth49869YfJ/1vTjaPAy9OfEjeFN57X1BQ4IH/fRQUFAQSR1jeoNkqn0/ulsPneJu6+riPRLYMJI4ddrjGwwoPLyqHm0E5rPNwpqxY4X2fPt4XFHg/apTdd/313hcWer90aXLPnWwe6xJPI2EZotW1bGmuoqIinPs7MBM4iKKiXQKJY/78ocArQA/lsCRE5+HMqa+HM8+0fkfDh8Nxx9n9/frZpPp33gk0PBUojYWliU9Y3qCSfcrLy+nWbTcikWuAYk4+eVwgcVjOfgnsjHObKIclbjoPZ4b3cNFF8NJLMHQo/Pa3q7/3y19CmzYhaB2QzPBLqj7CMKwYJqm69hmma6iZjIU8Hh5vEI16f8QR3m+5pfcLF2b++LNnz/YdO/7Bg/e7794nJ3I4k/Eoh4OXi+fhxvE4d7cH7y++eEmTjzvmGO+7dEnuWMnmceDFidebIm3CdA01k7Ho5G5mzLDryhdcEMzxx4yxM8z48fH/TH299zNnev/ii97ffLP3m202zsPnHq4IPIe9z1weK4dzR5jOw957361biXducGye2mO+W7em43noIXv/1tQ0/1jJ5rH6oOSwMF1DDVMs+aJbN7j0UvjTn6x1/d57Z/b4nTrZ7RdfwGGHrfv9Zcvgs89gypTVt1Onwo8/2vcjEYhGtwM6AcWhyBvlsSQqTDlTUQGVlcOAA4EXgIuZObPphkX9+tntmDFw/vmZinBNmoMSUqnoBRCma6hhiiWfDBkC7dvDFVfY30uZ9PPPNUA95557J126HMUjjyxgyBDbkLBTJ2uvf/DBVkS9+CJsuimcd551uJ00yXZRLi4+AztNzQlF3iiP80uunIfnz7ceRb16QUFBEc6dB5xOJMJ64ykqsiaMY8ZkNtY1JDP8kqoPDSuuKxXDgmG69qk5KMF59FEbqh05MrPHLSkp8fBVbCjZx/qyeF9c7P2pp1q/lNde837OHJsz05Tx4+3nnftd4Dnsveag5JtsPw+vWOH9Pfd4v/nm3m+yifdXX+395Mk1ccdz9tnet23rfV1d846fbB4nlczAVcB0YBrwHNAKaA+MAWbFbttt7Hn0plhXWHoBZKNE3hSpymEf4jyuq/N+zz2933ln73/8MXPHtRwe6OEhD2f7SGRf/9//JvYcb79tZ6mxY9MSYmglemLXuTg9svU8HI16P3q097vvbu+fY4/1vro68ed5/nn7+Q8/bF4cyRYozb7E45zbAbgc6Om93wMoAPoDg4Fx3vsuwLjY15KgMAwL5rp8yeGCAnjoIfj6a7jvvswd13L4aeAKIpEnKS5eTuvWiT1Hba3d7rhjysPLGfmSx0HIxvPwjBlw5JHW06SwEN54A8rLoWvXxJ+rd2/bUyuo5cbJzkEpBDZ1zhUCrYF5wPHAiNj3RwAnJHmMvBSWXgB5IC9y+NBD4de/hrvugjlzMnPMVORwQ4Gyww4pDi735EUeZ1o2nYeXLIHLL4c997Qdyh96yCafH3lk85+zQwfYZ58A+6EkM/wCXAEsB74Fnond9/1aj/luPT97PjAJmLTzzjs3b/xIpAkkdomn2TnssyyPv/jC+5YtvT/99KAjid8ll9g18HyTSA57nYvz2s8/e//nP3vfvr3N8broIu+//TZ1z3/DDdauoDlt7xPN47U/krnE0w6r0DsB2wNtnHNnxvvz3vth3vue3vueW2+9dXPDEGm2ZHMYsiuPd90VrrkGnn0W3n8/6GjiU1sLO+0UdBThpnNx/ho3Drp3h0sugb32gk8/hUceSe1O5X37Wkv8t99O3XPGK5lLPH2AL7z333rvf8Y23jgAWOCc6wgQu12YfJgiaZF3OTx4sF0uufxyiLVmCLXaWs0/iUPe5XG+q6mBk06CPn1sOf7LL1uxsueeqT9WQ9v7IJYbJ1OgfA3s75xr7ZxzQG+gEhgNDIw9ZiAwKrkQRdIm73K4TRv44x/hk0/gySeDjmbj5sxRgRKHvMvjfPXDD3D99daE8a234M47obLSihXXdL+1pLVsaXPYgpiH0uwCxXs/EXgJ+ASYGnuuYcDdQF/n3Cygb+xrkdDJ1xw+/XQ44AA70S1bFnQ067dyJSxcqAJlY/I1j/NJNAojRthKnLvvhv79YeZMew+3apX+4/frB7NmWVfoTEqq1b33fggwZK27V2IVvEjo5WMOO2cz/Hv1gttvh3vuCTqips2bZ7cqUDYuH/M4X3z4oV2S/fhj2G8/ePVVu82koNreq9W9SB7q2RPOOgsefND+MgqjhiXGmiQr+WjuXBgwwOaA1NbCU0/Bf/6T+eIErO39Tjtl/jKPChSRPHXnnXZ9edCgoCNpmpq0ST766Scb2eza1faouvFGu5wzYIBtoBkE52w1z7hxUFeXueOqQBHJU9ttBzffbF0m33wz6GjW1dBQTgWK5APv4aWXbALszTfDUUfZBNjbb4fNNgs6OrvM8/33tpFnpqhAEcljV1wBu+0GV10FP/8cdDRrqq2FLbaAzTcPOhKR9JoyBQ47DE45xXb5Hj/eipVOnYKObLWGtveZXG6sAkUkj7VsCUOH2l9qjzwSdDRrUg8UyXXffgsXXgg9esC0afDoo1BRYcVK2ATR9l4FikieKyuz68tDhtgJMyxUoEiuWrUKHngAunSBJ56wVTqzZlmxUpjU2tr06tcPPvggc+0JVKCI5DnnbDXP8uXwhz8EHc1qanMvueiNN6zj6+9/D/vvbxv6PfAAtGsXdGQb169fZtveq0AREUpKbD+PYcPsenjQfv4Z5s/XCIrkjupqOOYYOPpoa7z22mtWrHTrFnRk8Wtoe5+pyzwqUEQEgFtusb/irrzSVhQEad48i0EFimS777+3pfx77AETJsB999l8k2OOSV97+nRp0SKzbe9VoIgIYMXJbbfBO+/AK68EG4t6oEi2q6+3EcmuXe0Szlln2TyTQYPsF3226tcPPv88M23vVaBI3GpqaigtLaWwsJDS0lJqamqCDklS7Lzz4Be/gKuvtoZRQUlXgaIclkx4911b8XLBBVBcbCtzhg2DbbZJ/rmDzuHGbe/TTQWKxK2srIyqqirq6+upqqqirKws6JAkxQoLbcLsl1/C/fcHF0e62twrhyWdvvoKfvMbuwyyZAm88IIVK927p+4YQedwJtveq0CRuFVXVxONRgGIRqNUV1cHHJGkw+GH2/btd921ulDItNpa6565xRapfV7lsKTDf/9rK+CKi23y6623QlWVFSupnmcSdA47Z6MomWh7rwJF4lZUVEQkthlEJBKhqKgo4IgkXe67z66hDx4czPHnzLHLO6k+uSuHJZW8h2eesVGF226zwr662oqV1q3Tc8ww5HDfvplpe68CReJWXl5OcXExBQUFFBcXU15eHnRIkiadOtk8lGeesR1UMy1dTdqUw5IqH38MBx4IZ55p+1pNmGDvl3T37glDDje0vU/3ZZ4Q96yTsOncuTPTp08POgzJkMGD4W9/s/16Jk7M7E6qtbX2V1qqKYclWd98AzfcAE8+CdtuC8OHw8CBmXt/hCGHG7e9T2dzR42giEiTNtsM/vhHG8Z96qnMHbeuzn4JaImxhMnKlfZ+6NrVRkquvRZmzrTlw5ks3sOiXz/48ENYujR9x8jDl1VE4nX66daOe/DgzO2/MX++ddpUm3sJA+9h1CgoLbX3weGHw/TpVqykehJ3NslE23sVKCKyXpEIPPQQLFgAd96ZmWOqSZuExbRpdqnxhBNs5++33rJipUuXoCMLXkPb+3T2Q1GBIlkn6EZF+Wbffe0a+wMPWAfJdJszx25zuUBRDofb4sVw6aWw117wySfw//6f7VGVjnlR2aq2tgbn3uGRR2alLYdVoEjWCbpRUT666y5rzz1oUPqPlQ8jKMrhcKqrg4cfthGSRx+Fiy6y9vSXXmpNDGW1Y48tY/nyGUAXKit/TEsOq0CRrBN0o6J81LEj3HQTjB6d/qWFtbWw6abZsf18cymHw2fsWNh7b7jsMuv8OnmyFStbbRV0ZOEzcyZUVj4IXAxU4P2StOSwChTJOmFoVJSPrrwSdtsNrroKfv45fcdp6IGSbTu9JkI5HB6ff25zTPr2tf2n/vEPK1Z+8YugIwufn36yZcW/+AVEIvvj3GXAvkQiy9OSw0kVKM65ts65l5xzVc65SufcL51z7Z1zY5xzs2K3Ofx3kAQh1Y2KlMfxadnS9ueZMQMeeyx9x6mtzf0VPMrh4C1bBtddZ6tzxo2Du++23D7hhNwujpvrX/+ywuS22+Dkk+H995fQrdt4Cgpc2hrGJTuC8hDwL+99MbAXUAkMBsZ577sA42Jfi6RMQ6Oiuro6pk+fTufOnZN9SuVxnI47Dvr0sb+iFi1KzzEa2tznMuVwcKJRa0DYtSvcc48tpZ8504qVli2Dji58amvhlFPgqKOgoMBGl559Fvbff5dU5/A6ml2gOOe2AA4BngDw3q/y3n8PHA+MiD1sBHBCciGKpI/yODHO2WqeH36AIUNS//z19TBvXu4XKKmkHI7ff/5jq9LOPtu2c/joIytWOnYMOrLwqauDoUOhWzfbAPG22+Czz6zNfaYkM4LSGfgW+Jtz7lPn3F+dc22Abb333wDEbrdJQZwi6aI8TtAee9jqhscesxNWKi1YYEWKCpSEKIc3orYWzjjD9s6ZPx/+/ncrVnr1CjqycHr/fWtlP2gQHHKINaa76abMjzAlU6AUAj2AR7333YH/ksAQonPufOfcJOfcpG+//TaJMESSojxuhltvhbZtbeKs96l73nxYYpwGyuH1+PFH+L//s92GX3kFbr7Zdhs+4wzNM2nKokVw7rlw0EGwZAm8/LKNnqTh6k1ckilQaoFa7/3E2NcvYW+SBc65jgCx24VN/bD3fpj3vqf3vufWW2+dRBgiSVEeN0P79nbif/ttW/WQKg0FSq5Pkk0x5fBavIeRI+3yxJAhcMwxUFlpOdumTdDRhU80Ck88AcXFtgni1Vfb63XSScEWcs0uULz384E5zrmGtUW9gRnAaGBg7L6BwKikIhRJI+Vx811wgV3uGTQIVqxIzXNqBCVxyuE1ffop/OpXcOqp1kvnnXesWNl116AjC6fPPoODD7aRk27d7PW7917bLDRoyfbGuwx4xjnXAqgBzsKKnpHOuXOAr4FTkjyGSLopj5uhsBAefNBW9QwdalvQJ2vOHLvOreZYCcv7HF640OZJ/PWvlj9/+Qucc46tPJF1/fAD3HKL7bXVti0MH25bWoRpZ+akChTv/WSgZxPfyuA8X5HkKI+br3dvOPFE20hw4EDYYYfkni8fmrSlQz7n8KpV1vH11lttzsmVV9oy+LZtg44snLy3uSVXXglz58J559lWFmH8oyBEtZKIZKP77rPOstdfn/xzNRQoIhvjPfzzn9Y8bNAgm9g5bZqN5qk4adrs2XD00dbXpEMH+OADGDYsnMUJqEARkSR17my/IJ5+Gj78MLnnUoEi8aistF+0xx5ro23//Kd9aMeApq1YYROES0thwgTrZTRpEuy/f9CRbZgKFBFJ2vXXW7Oryy+3FQHNEY3akLNW8Mj6fPed7QW155721//QoTbJ8+ijg44svMaMsddryBA4/nioqrLLO9mwO7MKFBFJ2uab214mH39sIynNsXChXSrSCIqsrb7eJr127WqTOs8+29rTX3UVtGgRdHThNG8e9O8P/frZ5bA334QXXkh+nlgmqUARkZQ480zYbz8YPNhWCCRKS4ylKe+8Az16wIUX2iWKTz6xYmWbvO2Lu2F1dVbEFRfDq6/aSp2pU61QyTYqUEQkJSIROzHOn2+rehKlAkUa++IL+PWv4bDDYOlSePFFawy4995BRxZeH35o7fuvvBIOOMAmDQ8ZAq1aBR1Z86hAEZGU2W8/+O1vbW7A7NmJ/awKFAFYvtz6mXTrBm+8YZvUVVZasaLl501bssQaJx5wgF0qHTnSXrvddw86suSoQBGRlLrrLthkE2uXnYjaWptPkCPd1iVB0aht4ldUBHfcYQVJdbUVK5tuGnR04eS9taYvKrJW9VdeaZNgTzklN4o5FSgiklLbbw833mjXv8eOjf/namttAl+YOllKZnz0ke00PGCA5c/771uxotG09Zs2zVr6n3UWdOkCFRU2crn55kFHljo6FYhIyl11FXTqZH/R1dXF9zNz5ugXUr6ZN886EO+3H3z5pY0GTJxolyqkacuXw7XXQvfuMH06PP649TbZa6+gI0s9FSgiknKtWsH999sJ9LHH4vsZNWnLHytW2KXArl3h+edt5dfMmeHbCyZMvLedw0tKbDO/3/7WLoGde27uvmY5+s8SkaCdcAIcfrjti7J48YYf670KlHzQ+JfsDTdA374wY4YVK7l0aSLVvvgCysrgpJOsjf+ECTbnpEOHoCNLLxUoIpIWztmy46VLbanjhixaZJu+qUDJXVOn2s7XJ50ErVtbh9N//AN22y3oyMJr5UqbMFxSYv1g7rvP5poceGDQkWWGChQRSZs99oCLLoJHH7VfUOvTsMRYbe5zz6JFcPHF1r9k8mT485/ttk+fgAMLufHjbV7JTTfBMcfY6pxBg2yFXL5QgSIiaXXrrbDlljZh1vumHzNnjt1qBCV3/Pwz/OlPtsJk2DC45BKYNcuKlWzYByYo8+fDGWdA7972Gr7+Orz0Un6+N1SgiEhabbWV7aQ6fjyMGtX0Y9SkLbe8+ab99X/FFdbZdMoUK1batw86svCqr4eHH7aeJi+9BDffbEuJjzoq6MiCowJFRNKuYR+VQYNsBcfaamvtr2rtr5LdZs2yyZxHHmlzikaNsmKltDToyMLt449tqfVll1lBN3WqFfX53qBOBYqIpF1hITz4INTU2O3aamutQVdBQaYjk1RYuhSuucYKkXffhXvusSXmxx2XGx1N0+X77+2S1377wdy58NxzNnm4a9egIwsHFSgikhF9+sDxx8Ptt1uDrsZqazVBNhvV19ty165dre/NgAHWz+Saa6Bly6CjCy/vV7f1/8tfbOSkqgr691dB15gKFBHJmPvvt4l/11+/5v3qgZJ9JkyAffe1RmG7727t6p94ArbbLujIwq2y0voDDRgAu+5ql3ceesgmksuaVKCISMbsthv8/vfw1FPW0hzsr0m1uc8eX39tf+kffLDtnPvss1as9OwZdGTh9uOPVpjvtZcts37sMfjgA+jRI+jIwksFiohk1A032F/ZV1xhO9guWWITZ1WghNuPP8Itt0BxsU1+HTLELkucdpouS2xMebk1W7v7bjj9dGtRf8EFuduiPlX08ohIRm2+uZ2oJ06EZ57REuOw8972yykutp42xx1nhcktt0CbNkFHF25ffWXzro47zl6rd9+1DRG1Wi0+KlCy3NKlSznxxBNZunRp0KGIxG3AAFtOed118MknPwLQtu3ygKOStVVU2KWc006zfV/ee8+KlV12CTqycFn7PLxqFfzxjzZqMnasfT55MhxySLBxZpukCxTnXIFz7lPn3Guxr9s758Y452bFbtslH6asz+jRo3n11VcpLy8POpSspRzOvEjEJgZ+8w1cfrmdhmbMeDPgqLJbKvN4/nw45xwrImfNgscft8mcBx+cvvizWePz8LvvQvfutkNzv342Kfbaa/OrRX2qpGIE5QqgstHXg4Fx3vsuwLjY1xs0ffp0CgsLKS0tpaamJgUh5Y+//nUEAMOHDw84kqyWdA4DVFRUKIcT8MtfwplnwvLlrQD4xz8eDTiirJd0HldUfMK2295Hly5Rnn7aGuvNnGkrddSjZv3s/Ls111yzNYceavN1ysttM8Sddw46uuzl/Po2x4jnh53bERgB3AH83nt/rHOuGjjUe/+Nc64j8I73vmgjz+MBIpEIxcXFTJ8+vdkx5YM+ffowbtw4oCMwD5hJixa/YNWqVQD07t2bsWPHBhlioJxzFd77uNYUpCqHY8/llcPxWZ3D2wNzAWjRoqVyOCaRHI49PkXn4j08TAPsMs6uu67/sfH86tjYY8LyHM05TmVlJcuWNVxa37/Rd+4A7qB37wPyOoch8TxeW7JbNj0IXAts3ui+bb333wDE3hhxTweKRqNUV1cnGVLuu/HGG3n//WWsWPFi7J6urFr1O2AYrVu35qabbgowuqzzIMrhjLvxxhv54IMP+PHHecAyYAtWraoHUA43z4OkJI9XAu8Ajl13/dV6H+XcxlfuxLOyJxPPka7HFBVtQ0VFLdFoPfAD9tLvD0xUDqdIswsU59yxwELvfYVz7tBm/Pz5wPmN74tEIhQVbfQP1by3aNFhwH+Ab4FfAdcAf6Gw0PPCC8dx6KGHBhle1kg2h2PPsUYeK4fjc9hhh/HCCy9wyimnsGLF6g5VrVq14oUXXlAOJyDV5+JIpDfFxcW8845GATdsK157bWUsh1dvMKUcTp1k5qAcCBznnPsSeB443Dn3d2BBbDiR2O3Cpn7Yez/Me9/Te9+zVatWFBQUUFxcrMmeG1BfbxOvfvMb2HHH72jd+hAikQm0ajUAeIu6usd4/fW2QYeZTZLKYVgzjwHlcAK+//57CgsLiUQibLrppkQiEQoLC/n++++DDi3bpOxcDMrhRCiH08x7n/QHcCjwWuzze4HBsc8HA/ds7Of32WcfLxu2eLH3RxzhPXh/wQXeH3JIHx+JRHz37t39W2+95ffa65cexnvn6vyLLwYdbbCAST7DOeyVxwk79NBD18jh7t27+0gk4g877LCgQwtcc3LY61ycccrhDWtuHjd8pKMPyt1AX+fcLKBv7GtJwtSpttxv/HgYNsxaJLdr14Z7772XSZMm0bdvXyoq/s0dd0ylXbtqTjsNRo8OOuqsphzOgC233HKNHP7444+555572GKLLYIOLVcoj9NMOZxeSa3iSZWePXv6SZMmBR1GKI0cCWedZRtJvfyyLc3ckGXLoG9fawo0ahQceWRGwgyVZGeON5fyWFJFOSy5INk8VifZkGqYb3LqqbD33tbRcWPFCcAWW8C//gWlpXDiiTBuXNpDFRERSTkVKCG0ZAkcfbS1R77gAnj7bejYMf6fb9cO3nrLtkA/7jj497/TF6uIiEg6qEAJmc8+s/km77yzer5JixaJP0+HDrYHxM47W7Hz4YcpD1VERCRtVKCEyMiRdhnnp59s18vzzkvu+bbd1i7xbLedzUWpqEhNnCIiIummAiUE6uttV9fG803233+jPxaX7be31T/t2tnk2SlTUvO8IiIi6aQCJWAN803uuQcuvDDx+Sbx2GknK1LatIE+fWDGjNQ+v4iISKqpQAlQ4/kmjz8Ojz7avPkm8ejUyYqUwkLo3dt2KBUREQkrFSgBeeGFNeebnHtu+o/ZpYvNSamvh8MPh5qa9B9TRESkOVSgZFh9PVx7LfTvD927p3a+STxKSmx1z08/WZHy9deZO7aIiEi8VKBk0JIlcNRRcO+9cNFFdskl1fNN4rHnnjBmDHz/vRUpc+dmPgYREZENUYGSIZ99Bj172uWcv/4VHnkkffNN4tGjB7z5JixYYHNSFiwILhYREZG1qUDJgIb5JitXWoFyzjlBR2T22w/eeAPmzLHVPYsWBR2RiIiIUYGSRkHPN4nHQQdBeTl8/rn1Sfnuu6AjEhERUYGSNosXrzvfZLvtgo6qaYcfDq++av1RjjgCli4NOiIREcl3KlDSYMoU628Slvkm8TjiCHjpJfj0U2sct3x50BGJiEg+U4GSYs8/v3q+yXvvhWe+STzKyiz+iRPt8x9/DDoiERHJVypQUqSuzuabnHaarZCpqLBJqNnm5JPh6aetuDrhBFixIuiIREQkH6lASYFsmm8Sj9NOg+HDrVfK1lu/S0HBppSWllKj1rOSZWpqaigtLaWwsFA5LFkpn3NYBUqSGuabvPde9sw3icfAgdCx4y0sX/4rotHrqKqqoqysLOiwRBJSVlZGVVUV9fX1ymHJSvmcwypQktAw32TVquybbxKPhQtvBxYDHYhGo1RXVwcdkkhCqquriUajAMphyUr5nMMqUJqhrg6uucYuheyzD0yalJ3zTTama9dioC3wHZFIhKKiooAjEklMUVERkYid5pTDko3yOYdVoCSoYb7JfffBxRfb7sDZPN9kQ557rhwowLmlFBcXU15eHnRIIgkpLy+nuLiYgoIC5bBkpXzO4cKgA8gmU6bYypZ58+CJJ+Dss4OOKL223LITAE88cR9nnXVfwNGIJK5z585Mnz496DBEmi2fc1gjKHFqmG/y88/w73/nfnECq9vet2sXbBwiIpJ/ml2gOOd2cs697ZyrdM5Nd85dEbu/vXNujHNuVuw2q3+9NTXfZN99g44qM/KhQMmXPJbcpRyWXJXMCEodMMh73w3YH7jEOVcCDAbGee+7AONiX2elxvNNLrkkt+ebNCUfChTyII8l5ymHJSc1u0Dx3n/jvf8k9vkPQCWwA3A8MCL2sBHACUnGGIjJk6FnT1s+PHw4PPxwbvQ3SUQ+FCi5nseS+5TDkqtSMgfFObcr0B2YCGzrvf8G7I0DbLOenznfOTfJOTfp22+/TUUYKfPcc3DAAavnm5x1VtARBaOhQGnbNtAwMibX8ljyj3JYcknSBYpzbjPgZeBK7/2yeH/Oez/Me9/Te99z6623TjaMlKirg6uvhtNPt9GTior8mW/SlO++g4IC2GyzoCNJv1zKY8lPymHJNUkVKM65TbA3xDPe+1didy9wznWMfb8jsDC5EDNj8WI48ki4/36bbzJ2LGy7bdBRBeu77+zyjnNBR5JeuZTHkp+Uw5KLklnF44AngErv/dBG3xoNDIx9PhAY1fzwMqNhvsmECfk736QpDQVKLsulPJb8pByWXJVMo7YDgQHAVOfc5Nh9NwB3AyOdc+cAXwOnJBVhmj37LJx7LrRvb/NNevUKOqLwyIcChRzJY8lrymHJSc0uULz3E4D1Df73bu7zZkpdHVx3HQwdCgcfDC++qEs6a/vuOyvcclm257GIclhyVV52kl20yOabDB0Kl15q/U1UnKwrT0ZQREQkhPJuL57Jk20/nfnz4W9/g9/9LuCAQkwFioiIBCWvRlCefdb6m9TV2XwTFSfrN3t2DYsX1/HYY3dRWlpKTU1N0CGJJKSmpobS0lIKCwuVw5KV8j2H86JAqauDQYPgjDNsEmxFhSbDrs/SpfD223DAAaOAQrxfTFVVFWVlZUGHJpKQsrIyqqqqqK+vVw5LVsr3HM75SzyLFsGpp8L48XDZZdbnZJNNgo4qHH76yS55ffzx6o/q6obvXgV8DrxLNBqlevU3RLJCdXU10WgUQDksWSnfczinC5RPP4UTT9R8E7C2/VOn2m7MDcXItGlQX2/f79jRRpXOPNNuL7/8AD7/fCLRaJRIJEJRUVGw/wCRBBUVFVFVVaUclqyV7zmcswVKQ3+TrbbKv/4m9fU2EtK4GJk8GVautO+3b2+N6Y491l6XXr1g++3XfI433vg7ZWVlVFdXU1RURHl5ecb/HSLJKC8vVw5LVsv3HM65AqWuDq69Fh54AA45BEaOzO0lxN7DF19YEdJQkFRUwPLl9v02bWCffWw5dUMx0qnTxtvXd+7cmenTp6f/HyCSJsphyXb5nsM5VaDkw3yTefNWj4pMmmQfixfb91q2hL33hoEDVxcjRUW24Z+IiEg2yZkCpfF8kyeftF/S2W7x4tWjIg238+bZ9woKYI89rKdLQzGyxx7aQ0hERHJDThQozzxj8006dLAN/3r2DDqixP3wA3zyyZqjI42XvBcVwWGHrS5G9t4bWrcOLFwREZG0yuoCZe35Ji++CNtsE3RUG7diBUyZsuby3qoqm08CsMsuVmSdf74VI/vsA1tuGWzMIiIimZS1Bcq339p8k7ffDvd8k7o6mD59zWJk6lS7H2wCb69e9m/p1csKk2woskRERNIpqwqUmpqaWGe91hQUjMK57XjyyUho5ptEozBr1prFyKef2ogJQNu2VoBcffXqSzU77rjxFTWSOxpyuPGywc6dOwcdlkjclMOSKVlVoJSVlVFZ2Q3vnyYa3YTttrudI474A9EoRDLctN97+OqrNXuNVFTAsmX2/datoUcPuPDC1cXIbrtlPk4Jl4bW1dFo9H+tq/N5GaFkH+WwZEpWFSjV1dV4fxOwKQDz5/+Bjh1t5coOO8DOO8NOOzX90a5dciMV8+evuZpm0iS7zAR2aWmvvWyvn549rRjp1g0Ks+rVlUzI99bVkv2Uw5IpWfUrtKioiMrKM/H+cpzbhR133J9rr32YOXP438d778HcuatbuDdo3doKlfUVMXV1X9C//7FUV1ez++69uOGGV5g7t+P/Rkdqa+15IhEoKbEurA3FyJ57Wg8SkY1Jd+tqDb9LuimHJVOyqkBZs+3vNpSX/56m8ra+3kY8GhcujT+mTbPvN6yaMZ2ACcAyqqt3+d+8lt13h4MPXl2MdO8Om22W/n+r5KZ0t67W8Lukm3JYMsX5NX9LB6Jnz55+0qRJGT3mqlXW9Ozrr61oGTDgBrzfAWgHTCMS+YRFi/5Fu3YZDUtSwDlX4b3PeDecIPJ4bYWFhdQ3Gj4sKCigrmHJmGQN5bByOBckm8dZNYKSSi1awK672gfAnXeOWmPYsri4WMWJZJ183/1Usp9yWBpoTUlMeXk5xcXFFBQUUFxcnHe7RkpuUB5LtlMOS4O8HUFZW77vGim5QXks2U45LA00giIiIiKhk7YCxTl3pHOu2jn3uXNucLqOI5IuymHJdsphyWZpKVCccwXAn4GjgBLgNOdcSTqOle1qamooLS2lsLCQ0tJSahpvYSyBUQ4nRnkcPsrhxCiHwyddIyj7Ap9772u896uA54Hj03SsrNaw5r++vv5/a/4lFJTDCVAeh5JyOAHK4fBJV4GyAzCn0de1sftkLWobHVrK4QQoj0NJOZwA5XD4pGsVT1O73qzREc45dz5wfuzLlc65aWmKpbk6AIsycJxSoFXDF/X19Succ+ubwp6pmBIRxphS0ThhozkMoc/jTP7fxJvHYcyXMMakHF5N5+L4hDGmpPI4XQVKLbBTo693BOY1foD3fhgwDMA5NymIrokbopjiE9aYUvA0G81hCHcehy0eUEzxUg6vppjiE9aYkvn5dF3i+Rjo4pzr5JxrAfQHRqfpWCLpoByWbKcclqyWlhEU732dc+5S4E2gABjuvVfnHckaymHJdsphyXZp6yTrvX8deD3Ohw9LVxxJUEzxydmYEszhlB03hcIWDyimeCmHV1NM8cm5mEKxm7GIiIhIY2p1LyIiIqETeIEShlbMzrmdnHNvO+cqnXPTnXNXxO6/xTk31zk3OfZxdIbj+tI5NzV27Emx+9o758Y452bFbttlMJ6iRq/FZOfcMufclZl+nZxzw51zCxsvh9zQ6+Kcuz6WX9XOuSPSEI9yeP1xKYebjkM5vG4MyuH44smfHPbeB/aBTdyaDXQGWgBTgJIA4ugI9Ih9vjkwE2sNfQtwdYCvz5dAh7XuuwcYHPt8MPDHAP/v5gO7ZPp1Ag4BegDTNva6xP4fpwAtgU6xfCtI8eugHF5/XMrhpo+tHF43DuVw8/7vcjaHgx5BCUUrZu/9N977T2Kf/wBUEt6Oi8cDI2KfjwBOCCiO3sBs7/1XmT6w9/49YMlad6/vdTkeeN57v9J7/wXwOZZ3qaIcTpxyWDm8DuVws+R0DgddoISuFbNzblegOzAxdtelzrnPYsNZGRvGi/HAW865CmfdHgG29d5/A/aGBrbJcEwN+gPPNfo6yNcJ1v+6pDvHlMMbphyOn3I4Rjkct5zO4aALlLhaMWeKc24z4GXgSu/9MuBRYDdgb+Ab4P4Mh3Sg974HthvpJc65QzJ8/CY5a/p0HPBi7K6gX6cNSXeOKYc3TDmcPOWwcngd+ZDDQRcocbVizgTn3CbYm+IZ7/0rAN77Bd77eu99FHic1A6rbpT3fl7sdiHwj9jxFzjnOsZi7ggszGRMMUcBn3jvF8TiC/R1ilnf65LuHFMOb4ByOCHKYeVwInI+h4MuUELRitk554AngErv/dBG93ds9LATgYxtouWca+Oc27zhc6Bf7PijgYGxhw0ERmUqpkZOo9GwYpCvUyPre11GA/2dcy2dc52ALsBHKTyucnj9MSmHE6McVg4nIvdzOFMzfjcwE/hobLb2bODGgGI4CBtu+gyYHPs4GngamBq7fzTQMYMxdcZmPU8Bpje8NsBWwDhgVuy2fYZfq9bAYmDLRvdl9HXC3pTfAD9jlfk5G3pdgBtj+VUNHJWGeJTDTcekHF5/DMrhdWNQDscfV17ksDrJioiISOgEfYlHREREZB0qUERERCR0VKCIiIhI6KhAERERkdBRgSIiIiKhowJFREREQkcFioiIiISOChQREREJnf8POSBovv1MCwwAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 648x216 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "inst = deepcopy(inst_copy)\n",
    "print('--- REOPTIMIZATION (SDVRP) ---')\n",
    "combined = np.array([inst.tour[1:], [inst.demands[c] for c in inst.tour[1:]]])\n",
    "print('\\nTour (Row 1), Demand (Row 2):')\n",
    "print(combined)\n",
    "segments = solve_SDVRP(inst, capacity)\n",
    "print('\\nTrip count:\\t', get_trip_count(segments))\n",
    "print('Radial cost:\\t', np.round(sum([get_radial_cost(inst,seg) for seg in segments]), 1))\n",
    "print('Circular cost:\\t', np.round(sum([get_circular_cost(inst,seg) for seg in segments]), 1))\n",
    "print('Total cost:\\t', np.round(sum([get_total_cost(inst,seg) for seg in segments]), 1))\n",
    "print('\\nRealized trips:', *segments, sep=\"\\n\")\n",
    "plot_routes(inst, segments, 'blue')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### e) Simulation Setup: Rotating Routes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This last part illustrates the route selection process in the simulation code, in which we want to estimate the expected cost over various customer locations and demands. The steps are outlined below.\n",
    "\n",
    "At the beginning of the simulation of a given problem size...\n",
    "\n",
    "1. Generate several location customer instances, each with several demand instances.\n",
    "2. **For each customer instance,** create extended routes starting with the first customer in the TSP tour.\n",
    "3. Find the average overlapped routing cost over all demand instances using this set of extended routes.\n",
    "4. Rotate through all the customers, and repeat steps 2 and 3 using a new set of routes with each new starting customer.\n",
    "5. Keep the starting customer and set of routes that yields the lowest average cost under overlapped routing. Update the TSP tour to begin with this starting customer. As a result, the dedicated, overlapped, and fully flexible strategies will be simulated using routes generated from this starting customer for all demand instances.\n",
    "6. Repeat the route rotation process in steps 2-5 for each independent set of customer locations.\n",
    "\n",
    "After setting the lowest cost tour for all customers, proceed to simulate all strategies to find their routing costs.\n",
    "\n",
    "**Important:** Demand instances are created according to the scenario. Below we specify a \"baseline\" scenario in which each customer's demand is uniformly drawn from 0,1,2,...,8. Update this function in this notebook and in the actual simulation files if you wish to define new scenarios. Note that in the actual simulation files, *undefined scenarios default to the baseline demand.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_instances(scenario, num_cust, cust_sims, dem_sims):\n",
    "    \"\"\"Returns cust_sims by dem_sims array of Instances\"\"\"\n",
    "\n",
    "    np.random.seed(1)\n",
    "\n",
    "    def gen_new_instance(num_cust, scenario):\n",
    "        # Randomly generate depot locations\n",
    "        depot_x = field_width * np.random.random(1)[0] # Depot x-coordinate\n",
    "        depot_y = field_height * np.random.random(1)[0] # Depot y-coordinate\n",
    "\n",
    "        # Generate customer locations\n",
    "        new_xlocs = field_width * np.random.random(num_cust)  # x coordinates of all customers\n",
    "        new_ylocs = field_height * np.random.random(num_cust)  # y coordinates of all customers\n",
    "\n",
    "        # Generate demands depending on scenario\n",
    "        if scenario == 'stochastic_customers':\n",
    "            # Equal probability of selecting 0 or 8\n",
    "            new_dems = list(np.random.choice([0,8], num_cust))\n",
    "        elif scenario == 'binomial':\n",
    "            # Binomial(8,0.5) distribution\n",
    "            new_dems = list(np.random.binomial(8, 0.5, num_cust))\n",
    "        else:\n",
    "            # Uniformly distributed between 0 and 8\n",
    "            new_dems = list(np.random.randint(0, 8, num_cust))\n",
    "\n",
    "\n",
    "        # Return new instance\n",
    "        new_xlocs = list(np.append([depot_x], new_xlocs))  # include depot in customer x-coords\n",
    "        new_ylocs = list(np.append([depot_y], new_ylocs))  # include depot in customer y-coords\n",
    "        new_dems = list(np.append([0], new_dems))  # include depot in customer demands\n",
    "        return Instance(new_xlocs, new_ylocs, new_dems)\n",
    "\n",
    "    def update_demands(inst, scenario):\n",
    "        # Creates copy of instance with updated demands depending on scenario\n",
    "        if scenario in ['baseline']:\n",
    "            new_dems = list(np.random.randint(0, 8, num_cust))  # Uniformly distributed between 0 and 8\n",
    "        else:\n",
    "            raise ValueError('Scenario is undefined. Use \\\"baseline\\\" or define a new scenario in the update_demands function.')\n",
    "            \n",
    "        new_dems = list(np.append([0], new_dems))  # include depot in customer demands\n",
    "        new_inst = Instance(inst.xlocs, inst.ylocs, new_dems, solve_TSP=False)\n",
    "        new_inst.tour = inst.tour\n",
    "        return new_inst\n",
    "\n",
    "    # Create instance array with new customer instances\n",
    "    instances = [[None for j in range(dem_sims)] for i in range(cust_sims)]\n",
    "    customer_instances = [gen_new_instance(num_cust, scenario) for i in range(cust_sims)]\n",
    "\n",
    "    # Create demand instances for each customer instance\n",
    "    for i in range(cust_sims):\n",
    "        for j in range(dem_sims):\n",
    "            instances[i][j] = update_demands(customer_instances[i], scenario)\n",
    "\n",
    "    return instances\n",
    "\n",
    "\n",
    "def set_best_tours(demand_instances, primary_routes, extended_routes, capacity, route_size, overlap_size):\n",
    "    \"\"\"Updates the tour of all instances to the sequence that minimizes the average cost of the routes over all demand instances.\n",
    "    Assumes all instances in list demand_instances have identical customer locations.\"\"\"\n",
    "\n",
    "    # Get any customer instance\n",
    "    inst = demand_instances[0]\n",
    "    # Set current tour and cumulative cost over all demand instances as best so far\n",
    "    # Note: cumulative cost yields same tour ranking as average cost across demand instances\n",
    "    best_tour = inst.tour\n",
    "    segments = implement_k_overlapped_alg(inst, primary_routes, extended_routes, capacity, route_size, overlap_size)\n",
    "    lowest_cumul_cost = sum([get_total_cost(inst, seg) for seg in segments for inst in demand_instances])\n",
    "    print('Initial Tour: {}, Cost: {}'.format(best_tour, lowest_cumul_cost.round(2)))\n",
    "\n",
    "    # Copy of tour (for rotating below)\n",
    "    tour = inst.tour\n",
    "\n",
    "    # Loop over all customers\n",
    "    for c in range(inst.size):\n",
    "\n",
    "        # Rotate tour by one customer (keeps depot at very first spot)\n",
    "        tour = tour[0:1] + tour[2:] + tour[1:2]\n",
    "        inst.update_tour(tour)\n",
    "        tour_cost = 0\n",
    "        \n",
    "        # Get cumulative cost over all demand instances\n",
    "        for inst in demand_instances:\n",
    "            segments = implement_k_overlapped_alg(inst, primary_routes, extended_routes, capacity, route_size,\n",
    "                                                  overlap_size)\n",
    "            for seg in segments:\n",
    "                tour_cost += get_total_cost(inst, seg)\n",
    "        print('Candidate Tour: {}, Cost: {}'.format(tour, tour_cost.round(2)))\n",
    "        if tour_cost < lowest_cumul_cost:\n",
    "            # Set as new best tour and cost\n",
    "            best_tour = tour\n",
    "            lowest_cumul_cost = tour_cost\n",
    "            print('--> NEW BEST TOUR: {}, COST: {}'.format(best_tour, lowest_cumul_cost.round(2)))\n",
    "    # Update tour for all demand instances in this customer row\n",
    "    for inst in demand_instances:\n",
    "        inst.update_tour(best_tour)\n",
    "    return\n",
    "\n",
    "\n",
    "def example_setup(scenario, num_cust, capacity, route_size, overlap_size, cust_sims, dem_sims):\n",
    "\n",
    "    # Create all customer and demand instances for this problem size\n",
    "    print('Creating customer instances')\n",
    "    instances = create_instances(scenario, num_cust, cust_sims, dem_sims)\n",
    "\n",
    "    # Find cost minimizing starting customer / tour sequence for each set of customer locations\n",
    "    print('Finding best tours across demand sets')\n",
    "    for r in range(len(instances)):\n",
    "        print('\\nStarting customer instance {}'.format(r+1))\n",
    "        row = instances[r]\n",
    "        inst = row[0]  # customer instance\n",
    "        primary_routes = get_primary_routes(inst, route_size)\n",
    "        extended_routes = get_extended_routes(inst, route_size, overlap_size)\n",
    "        set_best_tours(row, primary_routes, extended_routes, capacity, route_size,\n",
    "                      overlap_size)  # set cost-minimizing sequence\n",
    "#         set_best_chain(row, primary_routes, extended_routes, capacity, route_size,\n",
    "#                        overlap_size)  # set cost-minimizing sequence\n",
    "    print('\\nSimulation setup complete.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "route_size = 2\n",
    "overlap_size = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Creating customer instances\n",
      "Finding best tours across demand sets\n",
      "\n",
      "Starting customer instance 1\n"
     ]
    },
    {
     "ename": "AssertionError",
     "evalue": "The number of customers must be evenly divisible by route_size.",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-27-fc11335ae013>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m example_setup(scenario = 'baseline',\n\u001b[0m\u001b[0;32m      2\u001b[0m               \u001b[0mnum_cust\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0minst\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msize\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m               \u001b[0mcapacity\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mcapacity\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m               \u001b[0mroute_size\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mroute_size\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m               \u001b[0moverlap_size\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0moverlap_size\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m<ipython-input-25-e928fa6b02b6>\u001b[0m in \u001b[0;36mexample_setup\u001b[1;34m(scenario, num_cust, capacity, route_size, overlap_size, cust_sims, dem_sims)\u001b[0m\n\u001b[0;32m    109\u001b[0m         \u001b[0mrow\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0minstances\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mr\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    110\u001b[0m         \u001b[0minst\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mrow\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m  \u001b[1;31m# customer instance\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 111\u001b[1;33m         \u001b[0mprimary_routes\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mget_primary_routes\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0minst\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mroute_size\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    112\u001b[0m         \u001b[0mextended_routes\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mget_extended_routes\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0minst\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mroute_size\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0moverlap_size\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    113\u001b[0m         set_best_tours(row, primary_routes, extended_routes, capacity, route_size,\n",
      "\u001b[1;32m<ipython-input-5-403021029054>\u001b[0m in \u001b[0;36mget_primary_routes\u001b[1;34m(inst, route_size)\u001b[0m\n\u001b[0;32m      3\u001b[0m     Requires that number of customers is evenly divisible by route_size.\"\"\"\n\u001b[0;32m      4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m     \u001b[1;32massert\u001b[0m \u001b[0minst\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msize\u001b[0m\u001b[1;33m%\u001b[0m\u001b[0mroute_size\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"The number of customers must be evenly divisible by route_size.\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      6\u001b[0m     \u001b[0mtour\u001b[0m \u001b[1;33m=\u001b[0m  \u001b[0minst\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtour\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;31m# Exclude depot\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      7\u001b[0m     \u001b[0mroutes\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mAssertionError\u001b[0m: The number of customers must be evenly divisible by route_size."
     ]
    }
   ],
   "source": [
    "example_setup(scenario = 'baseline',\n",
    "              num_cust = inst.size,\n",
    "              capacity = capacity,\n",
    "              route_size = route_size,\n",
    "              overlap_size = overlap_size,\n",
    "              cust_sims = 2,\n",
    "              dem_sims = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "example_setup(scenario = 'baseline',\n",
    "              num_cust = inst.size,\n",
    "              capacity = capacity,\n",
    "              route_size = route_size,\n",
    "              overlap_size = overlap_size,\n",
    "              cust_sims = 2,\n",
    "              dem_sims = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "@webio": {
   "lastCommId": null,
   "lastKernelId": null
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}