Notebook Tino 2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Projet de base"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import math\n",
    "import networkx as nx\n",
    "from networkx.drawing.nx_pydot import graphviz_layout\n",
    "from matplotlib import pyplot as plt\n",
    "import copy\n",
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Node:\n",
    "    \n",
    "    def __init__(self,idx, parent, children, lb, visited):\n",
    "        self.idx = idx\n",
    "        self.parent = parent\n",
    "        self.children = children\n",
    "        self.lb = lb\n",
    "        self.visited = visited\n",
    "        \n",
    "    def __str__(self):\n",
    "        return (\"Parent : \" +str(self.parent)+\n",
    "                \"\\n Children : \"+str(self.children) + \n",
    "                \"\\n lb : \"+str(self.lb)+ \n",
    "                \"\\n visited : \"+str(self.visited))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def arborescence(node,Tree):\n",
    "    branch = []\n",
    "    while node.parent != None:\n",
    "        branch.append(node)\n",
    "        node = Tree[node.parent]\n",
    "    branch.append(node)\n",
    "    \n",
    "    return branch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def computeCost(p,d,w,order):\n",
    "    t=0\n",
    "    cost=0\n",
    "    for idx in order:\n",
    "        t += p[idx]\n",
    "        cost += max(0,(t-d[idx])*w[idx])\n",
    "    return cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "p = [12,8,15,9]\n",
    "d = [16,26,25,27]\n",
    "w = [4,5,3,5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getPrimal_0(p,d,w):\n",
    "    sortedTasks = np.argsort(d)\n",
    "    cost = computeCost(p,d,w,sortedTasks)\n",
    "    return(cost,sortedTasks)\n",
    "\n",
    "\n",
    "def getPrimal_1(p,d,w):\n",
    "    sortedTasks = (np.argsort((np.array(d)-np.array(p))*np.array(w)))[::-1]\n",
    "    cost = computeCost(p,d,w,sortedTasks)\n",
    "    return(cost,sortedTasks)\n",
    "\n",
    "\n",
    "def getPrimal_2(p,d,w):\n",
    "    tasksLeft = [int(i) for i in range(len(p))]\n",
    "    order = []\n",
    "    while len(tasksLeft)!= 0:\n",
    "        time = np.sum(np.array(p)[tasksLeft])\n",
    "        penalities = (time-np.array(d)[tasksLeft])*np.array(w)[tasksLeft]\n",
    "        sortedTasks = np.argsort(penalities)\n",
    "        order.append(tasksLeft[sortedTasks[0]])\n",
    "        tasksLeft.pop(sortedTasks[0])\n",
    "    order.reverse()\n",
    "    cost = computeCost(p,d,w,order)\n",
    "    return(cost,order)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getDual_0(p,d,w,visited):\n",
    "    dual=0\n",
    "    time=0\n",
    "    notVisited=list(range(len(p)))\n",
    "    for i in visited:\n",
    "        retard=((p[i]+time)-d[i])\n",
    "        dual+=retard*w[i]*(retard>0)\n",
    "        time+=p[i]\n",
    "        notVisited.remove(i)\n",
    "        \n",
    "    for j in notVisited:\n",
    "        retard=(p[j]+time)-d[j]\n",
    "        dual+=retard*w[j]*(retard>0)\n",
    "    return dual\n",
    "\n",
    "def getDual_1(p,d,w,visited):\n",
    "    dual = 0\n",
    "    time = 0\n",
    "    notVisited = list(range(len(p)))\n",
    "    for i in visited:\n",
    "        retard = ((p[i]+time)-d[i])\n",
    "        dual += retard*w[i]*(retard>0)\n",
    "        time += p[i]\n",
    "        notVisited.remove(i)\n",
    "    return dual\n",
    "\n",
    "def getDual_2(p,d,w,visited):\n",
    "    dual = 0\n",
    "    time = np.sum(p)\n",
    "    for i in visited:\n",
    "        retard = (time-d[i])\n",
    "        dual += retard*w[i]*(retard>0)\n",
    "        time -= p[i] \n",
    "    return dual\n",
    "\n",
    "def getDual_3(p,d,w,visited):\n",
    "    dual = 0\n",
    "    time = np.sum(p)\n",
    "    notVisited=list(range(len(p)))\n",
    "    for i in visited:\n",
    "        retard = (time-d[i])\n",
    "        dual += retard*w[i]*(retard>0)\n",
    "        time -= p[i] \n",
    "        notVisited.remove(i)\n",
    "    for j in notVisited:\n",
    "        if time - p[j] < d[j]:\n",
    "            retard = time-d[j]\n",
    "            dual+=retard*w[j]*(retard>0)\n",
    "    return dual"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def exploration_0(Queue,Tree,UB):\n",
    "    return(Queue[0])\n",
    "\n",
    "def exploration_1(Queue,Tree,UB):\n",
    "    return(Queue[-1])\n",
    "\n",
    "def exploration_2(Queue,Tree,UB):\n",
    "    bestNode = Queue[-1]\n",
    "    bestLB = -math.inf\n",
    "    for idx in Queue:\n",
    "        if Tree[idx].lb > bestLB and Tree[idx].lb < UB:\n",
    "            bestLB = Tree[idx].lb\n",
    "            bestNode = idx\n",
    "    return(bestNode)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def branch_and_bound(p,d,w,byLast,getPrimal,getDual,exploration):\n",
    "    \n",
    "    Tasks = list(range(len(p)))\n",
    "    Tree = [] # list of all nodes created (a list of Node objects)\n",
    "    Queue = [] # list of nodes to process (a list of integers with the index of nodes to process in the Tree)\n",
    "    UB = 10000000 # Upper Bound of the problem\n",
    "    LB = 0 # best Lower Bound of the problem \n",
    "    \n",
    "    UB,currentOrder = getPrimal(p,d,w) #We start by computing the first primal/upper bound.\n",
    "\n",
    "    bestNode = Node(-1,-1, [], 0 ,[]) #default best node\n",
    "    \n",
    "    root = Node(0,None, [], 0, []) # define the root node of the tree\n",
    "    Tree.append(root) # start the tree with the root node\n",
    "    Queue.append(0) # start the list of nodes to process with the root node\n",
    "    \n",
    "    #continue processing nodes until the queue is empty\n",
    "    \n",
    "    nbIterations = 0\n",
    "    \n",
    "    while len(Queue)!=0 :\n",
    "        \n",
    "        # process the nodes in the queue according to the chosen exploration method\n",
    "        \n",
    "        currentIndex = exploration(Queue,Tree,UB)\n",
    "        currentNode = Tree[currentIndex]\n",
    "        nbIterations += 1\n",
    "        \n",
    "        if currentNode.lb < UB:\n",
    "            \n",
    "            # If the processed node corresponds to a \"full-schedule\" we check whether this solution is an improvement or not\n",
    "            # If so, we update the problem Upper Bound / best order / best node\n",
    "            \n",
    "            if len(currentNode.visited) == len(p):\n",
    "                order = copy.copy(currentNode.visited)\n",
    "                if byLast:\n",
    "                    order.reverse()\n",
    "                solutionCost = computeCost(p,d,w,order)\n",
    "                if solutionCost <= UB:\n",
    "                    UB = solutionCost\n",
    "                    currentOrder = order\n",
    "                    bestNode = currentNode\n",
    "            else:\n",
    "                \n",
    "                #for each task not processed yet we create a new node\n",
    "                for nextTask in (set(Tasks)-set(currentNode.visited)):\n",
    "                    nextVisited = copy.copy(currentNode.visited)\n",
    "                    nextVisited.append(nextTask)\n",
    "                    nextLb = getDual(p,d,w, nextVisited)\n",
    "\n",
    "                    newNode = Node(len(Tree),currentIndex, [], nextLb,nextVisited)\n",
    "                    Tree.append(newNode)\n",
    "                    Queue.append(len(Tree)-1)\n",
    "                    currentNode.children.append(len(Tree)-1)\n",
    "            \n",
    "        # When the processing of the node is completed remove the node from the queue     \n",
    "        Queue.remove(currentIndex)\n",
    "\n",
    "    # return the  solution\n",
    "    \n",
    "    if (UB-bestNode.lb)<=0.0001:\n",
    "        branch = arborescence(bestNode,Tree)\n",
    "    \n",
    "    # If the best node is not a leaf, the bestNode variable is still the default one default\n",
    "    else:\n",
    "        bestLB = -math.inf\n",
    "        for node in Tree:\n",
    "            if node.lb > bestLB and node.lb <=UB:\n",
    "                bestLB = node.lb\n",
    "                bestNode=node\n",
    "        branch = arborescence(bestNode,Tree)\n",
    "\n",
    "    return UB, currentOrder, nbIterations, branch, Tree"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Extension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__>__ Nous allons maintenant considérer une extension de notre problème dans lequel l'atelier dispose de plusieurs machines : \n",
    "Nous ne changeons pas la structure du code, nous nous appuierons toujours sur la classe Node, les fonctions _getPrimal_, _getDual_, _exploration_ et sur la fonction _Branch and Bound_.\n",
    "\n",
    "\n",
    "Le changement majeur est le changement de format de l'attribut _visited_ de chacun de nos noeuds. En effet, auparavant, cet attribut était une liste stockant les tâches déja réalisées (visted = [0,4,7] <=> les tâches 0,4,7 sont éffectuées, que ce soit en partant de la fin ou du début. \n",
    "Donéranavant, l'attribut _visited_ sera une liste de listes, où la liste à l'index 0 correspondra aux tâches réalisées dans l'odre par la machine 0, etc... \n",
    "\n",
    "\n",
    "visited : [0,2,3] -> [[0,2],[3]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Node:\n",
    "    \n",
    "    def __init__(self,idx, parent, children, lb, visited):\n",
    "        self.idx = idx\n",
    "        self.parent = parent\n",
    "        self.children = children\n",
    "        self.lb = lb\n",
    "        self.visited = visited\n",
    "        \n",
    "    def __str__(self):\n",
    "        return (\"Parent : \" +str(self.parent)+\n",
    "                \"\\n Children : \"+str(self.children) + \n",
    "                \"\\n lb : \"+str(self.lb)+ \n",
    "                \"\\n visited : \"+str(self.visited))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__>__ Une des premières fonctions à redéfinir pour ce nouveau problème était la fonction _computeCost_ qui nous permettra de calculer le coût d'une solution proposée. Le fonctionnement est le même qu'aparavant, on prend juste soin d'itérer sur chaque machine en pensant à réinitialiser le temps à 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def computeCost(p,d,w,orders,n):\n",
    "    cost=0\n",
    "    for order in orders:\n",
    "        t=0\n",
    "        for idx in order:\n",
    "            t += p[idx]\n",
    "            cost += max(0,(t-d[idx])*w[idx])\n",
    "    return cost"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "def getPrimal_2(p,d,w,n):\n",
    "    tasksLeft = [int(i) for i in range(len(p))]\n",
    "    orders = []\n",
    "    while len(tasksLeft)!= 0:\n",
    "        time = np.sum(np.array(p)[tasksLeft])\n",
    "        penalities = (time-np.array(d)[tasksLeft])*np.array(w)[tasksLeft]\n",
    "        sortedTasks = np.argsort(penalities)\n",
    "        order.append(tasksLeft[sortedTasks[0]])\n",
    "        tasksLeft.pop(sortedTasks[0])\n",
    "    order.reverse()\n",
    "    cost = computeCost(p,d,w,orders,n)\n",
    "    return(cost,order)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "def getPrimal_2(p,d,w,n):\n",
    "    tasksLeft = [int(i) for i in range(len(p))]\n",
    "    orders = [[] for _ in range(n)]\n",
    "    time = [np.sum(np.array(p)[tasksLeft])]*n\n",
    "    \n",
    "    while len(tasksLeft)!= 0:\n",
    "        bestPenalty = (1e99,0,0)\n",
    "        for k in range(n):\n",
    "            penalties = (time[k]-np.array(d)[tasksLeft])*np.array(w)[tasksLeft]\n",
    "            sortedTasks = np.argsort(penalties)\n",
    "            if sortedTasks[0]<bestPenalty[0]:\n",
    "                bestPenalty = (sortedTasks[0], k, tasksLeft[sortedTasks[0]]) #Penalty / machine / task\n",
    "        \n",
    "        orders[bestPenalty[1]].append(bestPenalty[2]) #orders[machine].append(task)\n",
    "        time[bestPenalty[1]] -= p[bestPenalty[2]]\n",
    "        tasksLeft.pop(sortedTasks[0])\n",
    "    for order in orders:\n",
    "        order.reverse()\n",
    "    order.reverse()\n",
    "    cost = computeCost(p,d,w,orders,n)\n",
    "    return(cost,order)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__>__ Suite à ça, nous définissons une nouvelle fonction _getPrimal_. La manière la plus simple de calculer une borne primale que nous ayons trouvé est de ranger les tâches par odre croissant de date limite et de les affecter une par une à chacune des machines. À défaut d'être optimale voir même performante, cette méthode nous a néanmoins permis de vérifier le bon fonctionnement de notre algorithme."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getPrimal(p,d,w,n):\n",
    "    sortedTasks = np.argsort(d)\n",
    "    orders = [[] for _ in range(n)]\n",
    "    for i in range(len(sortedTasks)):\n",
    "        orders[i%n].append(sortedTasks[i])\n",
    "    cost = computeCost(p,d,w,orders,n)\n",
    "    return(cost,orders)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "def getDual(p,d,w,visited,n):\n",
    "    dual = 0\n",
    "    time = [np.sum(p)]*n #-> [90,90,90] pour n = 3 par exemple\n",
    "    for k in range(n):\n",
    "        machine = visited[k]\n",
    "        for i in machine:\n",
    "            retard = (time[k]-d[i])\n",
    "            dual += retard*w[i]*(retard>0)\n",
    "            time[k] -= p[i] \n",
    "    return dual"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__>__ Nous définissons ensuite notre fonction _getDual_ qui sera exécutée à chaque création d'un nouveau noeud de l'arbre pour en calculer sa borne primale. Si on a fixé l'ordre de $k$ pièces on calcule les pénalités de retard de ces $k$ pièces pour chaque machine et on ajoute les pénalités des autres pièces en supposant qu'elles sont en $(k_i+1)$ème position, et en prenant la pénalité de retard minimum parmis toutes les machines.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getDual(p,d,w,visited,n):\n",
    "    dual = 0\n",
    "    notVisited=list(range(len(p)))\n",
    "    time = [0]*n \n",
    "    for k in range(n):\n",
    "        machine = visited[k]\n",
    "        for i in machine:\n",
    "            retard = (time[k] + p[i] -d[i])\n",
    "            dual += retard*w[i]*(retard>0)\n",
    "            time[k] += p[i]\n",
    "            notVisited.remove(i)\n",
    "    for j in notVisited:\n",
    "        retard=min([(p[j]+time[k])-d[j] for k in range(n)])\n",
    "        dual+=retard*w[j]*(retard>0)\n",
    "    return dual"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getDual_2(p,d,w,visited,n):\n",
    "    dual = 0\n",
    "    notVisited=list(range(len(p)))\n",
    "    time = [0]*n \n",
    "    for k in range(n):\n",
    "        machine = visited[k]\n",
    "        for i in machine:\n",
    "            retard = (time[k] + p[i] -d[i])\n",
    "            dual += retard*w[i]*(retard>0)\n",
    "            time[k] += p[i]\n",
    "            notVisited.remove(i)\n",
    "    return dual"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On conserve les mêmes méthodes d'exploration que précédemment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def exploration_0(Queue,Tree,UB):\n",
    "    return(Queue[0])\n",
    "\n",
    "def exploration_1(Queue,Tree,UB):\n",
    "    return(Queue[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finalement, nous modifions notre algorithme _Branch and Bound_ pour correspondre à ce problème. Les éléments que nous avons changé sont : \n",
    "\n",
    "__Entrée :__ \n",
    "\n",
    "* __n :__ Ajout d'un nouveau paramètre pour indiquer le nombre de machines à disposition.\n",
    "\n",
    "__Exécution :__\n",
    "\n",
    "* __getPrimal :__ Utilisation de notre nouvelle fonction getPrimal pour n machines\n",
    "\n",
    "* __root node :__ Changement de format de root.visited.\n",
    "\n",
    "* __Vérification tâches éffectuées :__ On ne peut plus simplement regarder la longueur/composition de noeud.visited mais on doit additionner la longueur de chaque liste/ itérer sur les listes en plusieurs lignes.\n",
    "\n",
    "* __computeCost :__ Utilisation de notre nouvelle fonction computeCost pour n machines\n",
    "\n",
    "* __getDual :__ Utilisation de notre nouvelle fonction getDual pour n machines\n",
    "\n",
    "* __nextVisited :__ Une utilisation d'un simple copy.copy() n'était plus suffisante pour une liste de listes. L'ajout d'un noeud à nextVisited l'ajoutait aussi à currentNode. Nous avons domc remplacé par un deepcopy()\n",
    "\n",
    "* __Création nouveau noeud :__ On crée un nouveau noeud par tâche non visitée pour chaque machine."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def branch_and_bound(p,d,w,byLast,getPrimal,getDual,exploration,n):\n",
    "    \n",
    "    Tasks = list(range(len(p)))\n",
    "    Tree = [] \n",
    "    Queue = [] \n",
    "    UB = 10000000 \n",
    "    LB = 0 \n",
    "    \n",
    "    UB,currentOrder = getPrimal(p,d,w,n) #New primal bound computation\n",
    "    #print(\"Primal Bound : {} | Order : {}\".format(UB,currentOrder))\n",
    "    bestNode = Node(-1,-1, [], 0 ,[])\n",
    "    \n",
    "    #NEW\n",
    "    #We changed the root node visited attribute to match the problem\n",
    "    root = Node(0,None, [], 0, [[] for _ in range(n)]) \n",
    "    Tree.append(root) \n",
    "    Queue.append(0) \n",
    "    \n",
    "    nbIterations = 0\n",
    "    \n",
    "    while len(Queue)!=0 :\n",
    "        \n",
    "        currentIndex = exploration(Queue,Tree,UB)\n",
    "        currentNode = Tree[currentIndex]\n",
    "        nbIterations += 1\n",
    "        \n",
    "        if currentNode.lb < UB:\n",
    "            \n",
    "            #NEW\n",
    "            #We needed to change the conition to know whether we visited all the tasks or not\n",
    "            if sum([len(visited) for visited in currentNode.visited]) >= len(p):\n",
    "                orders = copy.copy(currentNode.visited)\n",
    "                if byLast:\n",
    "                    for order in orders:\n",
    "                        order.reverse()\n",
    "                #NEW\n",
    "                #ComputeCost changed\n",
    "                solutionCost = computeCost(p,d,w,orders,n)\n",
    "                if solutionCost <= UB:\n",
    "                    UB = solutionCost\n",
    "                    currentOrder = orders\n",
    "                    bestNode = currentNode\n",
    "            else:\n",
    "                \n",
    "                #NEW\n",
    "                #Listing all the visited tasks is now too difficult to be nicely written in a single line\n",
    "                allVisitedTasks = []\n",
    "                visited_copy = copy.copy(currentNode.visited)\n",
    "                for machine in visited_copy:\n",
    "                    for task in machine:\n",
    "                        allVisitedTasks.append(task)\n",
    "                \n",
    "                #print(currentNode.visited)\n",
    "                \n",
    "                #NEW\n",
    "                #Iterate over all the machines\n",
    "                for k in range(n):\n",
    "                    for nextTask in (set(Tasks)-set(allVisitedTasks)):\n",
    "                        #NEW\n",
    "                        #visited is now a list of lists so we need to deepcopy it\n",
    "                        nextVisited = copy.deepcopy(currentNode.visited)\n",
    "                        #machine by machine\n",
    "                        nextVisited[k].append(nextTask)\n",
    "                        nextLb = getDual(p,d,w, nextVisited,n) #New dual bound computation\n",
    "\n",
    "                        newNode = Node(len(Tree),currentIndex, [], nextLb,nextVisited)\n",
    "                        Tree.append(newNode)\n",
    "                        Queue.append(len(Tree)-1)\n",
    "                        currentNode.children.append(len(Tree)-1)\n",
    "               \n",
    "        Queue.remove(currentIndex)\n",
    "\n",
    "    \n",
    "    if (UB-bestNode.lb)<=0.0001:\n",
    "        branch = arborescence(bestNode,Tree)\n",
    "    \n",
    "    else:\n",
    "        bestLB = -math.inf\n",
    "        for node in Tree:\n",
    "            if node.lb > bestLB and node.lb <=UB:\n",
    "                bestLB = node.lb\n",
    "                bestNode=node\n",
    "        branch = arborescence(bestNode,Tree)\n",
    "\n",
    "    return UB, currentOrder, nbIterations, branch, Tree"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test de nos fonctions : "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans un premier temps nous définissons un exemple assez simple qui nous permettra de vérifier le bon fonctionnement de notre algortihme. Nous choisissons de n'utiliser que deux machines et de ne donner que 6 pièces à produire. Toutes les pièces seront usinables en temps sauf une, la pièce 6, qui engendrera un pénalité. \n",
    "\n",
    "* __Temps de produiction :__ p = [2,3,4,2,3,6]\n",
    "\n",
    "\n",
    "* __Dates limite :__ d = [2,5,9,2,5,7]\n",
    "\n",
    "\n",
    "* __Poids de pénalité :__ w = [1,1,1,1,1,1]\n",
    "\n",
    "\n",
    "Si notre algorithme fonctionne correctement, il devrait renvoyer une solution de 4 illustrée sur le schéma ci-dessous. \n",
    "\n",
    "<img src=\"img/2machinestoyexample.png\"\n",
    "     style=\"\" />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = [2,3,4,2,3,6]\n",
    "d = [2,5,9,2,5,7]\n",
    "w = [1,1,1,1,1,1]\n",
    "\n",
    "orders = [[0,1,2],[3,4,5]]\n",
    "computeCost(p,d,w,orders,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Solution : 4\n",
      "Ordre :  [[0, 1, 5], [3, 4, 2]]\n"
     ]
    }
   ],
   "source": [
    "sol, order, _ ,_ ,_= branch_and_bound(p,d,w,True,getPrimal,getDual,exploration_1,2)\n",
    "print(\"Solution :\", sol)\n",
    "print(\"Ordre : \", order)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Conclusion :__ Notre algorithme nous a renvoyé la bonne réponse sur ce problème particulièrement simple. Nous allons maintenant le tester sur différentes intances aléatoires de notre problème."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Instances aléatoires :__ Comme précédemment nous allons définir une fonction pour générer des instances aléatoires de notre problème. Le code est globalement le même mais nous divisons la date limite maximum par le nombre de machines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def genMultiInstances(n,alpha,n_machines):\n",
    "    p=np.random.randint(1,15,n)\n",
    "    d=np.random.randint(3,int(alpha*n*15/n_machines),n)\n",
    "    w=np.random.randint(1,5,n)\n",
    "    return(p,d,w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "______________________\n",
      "p :  [12  6  4  1  1  7]\n",
      "d :  [14 15 17 17  4  3]\n",
      "w :  [3 1 1 1 2 4]\n",
      "Solution : 37 | Ordre : [[5, 0, 2], [4, 1, 3]] | nbit : 23025\n",
      "Solution : 37 | Ordre : [[5, 0, 2], [4, 1, 3]] | nbit : 43365\n",
      "______________________\n",
      "p :  [ 3  9  4  3  6 11]\n",
      "d :  [13  4  9  7  6 15]\n",
      "w :  [1 4 4 1 2 4]\n",
      "Solution : 55 | Ordre : [[1, 3, 0], [4, 2, 5]] | nbit : 9009\n",
      "Solution : 55 | Ordre : [[1, 3, 0], [4, 2, 5]] | nbit : 38841\n",
      "______________________\n",
      "p :  [ 7  5 10  3 12  7]\n",
      "d :  [ 8 12  5 14  4  8]\n",
      "w :  [2 1 2 4 1 3]\n",
      "Solution : 66 | Ordre : [[0, 1, 4], [2, 3, 5]] | nbit : 22795\n",
      "Solution : 66 | Ordre : [[0, 1, 4], [2, 3, 5]] | nbit : 50591\n"
     ]
    }
   ],
   "source": [
    "for _ in range(3):\n",
    "    print(\"______________________\")\n",
    "    p,d,w = genMultiInstances(6,.4,2)\n",
    "    print(\"p : \", p)\n",
    "    print(\"d : \", d)\n",
    "    print(\"w : \", w)\n",
    "    sol, order, nbIt ,_ ,_= branch_and_bound(p,d,w,True,getPrimal,getDual,exploration_1,2)\n",
    "    print(\"Solution : {} | Ordre : {} | nbit : {}\".format(sol,order,nbIt))\n",
    "    sol, order, nbIt ,_ ,_= branch_and_bound(p,d,w,True,getPrimal,getDual_2,exploration_1,2)\n",
    "    print(\"Solution : {} | Ordre : {} | nbit : {}\".format(sol,order,nbIt))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Résultats :__ On remarque que comme on pouvait s'y attendre, la méthode $getDual\\_2$ est moins performante que $getDual$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, \"Temps d'exécution en fonction de la taille du problème - alpha:0.4 | N=1 | n_machines=2/3\")"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "N = 1 #Nombre d'échantillons\n",
    "n = 7 #Taille maximum du problème\n",
    "alpha = 0.4\n",
    "\n",
    "resultats_BB = [[] for i in range(3,n)]\n",
    "resultats_BB_2 = [[] for i in range(3,n)]\n",
    "\n",
    "for _ in range(N):\n",
    "    for i in range(3,n):\n",
    "        p,d,w = genMultiInstances(i,alpha,2)\n",
    "        \n",
    "        #n_machines = 2 \n",
    "        start = time.time()\n",
    "        _, _, _, _, _ = branch_and_bound(p,d,w, True, getPrimal, getDual,exploration_1, 2)\n",
    "        end = time.time()\n",
    "        resultats_BB[i-3].append(end-start)\n",
    "        \n",
    "        p,d,w = genMultiInstances(i,alpha,3)\n",
    "        #n_machines = 3\n",
    "        start = time.time()\n",
    "        _, _, _, _, _ = branch_and_bound(p,d,w, True, getPrimal, getDual,exploration_1, 3)\n",
    "        end = time.time()\n",
    "        resultats_BB_2[i-3].append(end-start)\n",
    "\n",
    "resultats_BB_2 = [np.mean(res) for res in resultats_BB_2]\n",
    "resultats_BB_2 = np.array(resultats_BB_2)\n",
    "\n",
    "resultats_BB = [np.mean(res) for res in resultats_BB]\n",
    "resultats_BB = np.array(resultats_BB)\n",
    "\n",
    "plt.figure(figsize=(10,6))\n",
    "X = list(range(3,n))\n",
    "plt.plot(X,resultats_BB, label=\"2 machines\")\n",
    "plt.plot(X,resultats_BB_2, label=\"3 machines\")\n",
    "plt.xlabel(\"Taille du problème\")\n",
    "plt.xticks(X)\n",
    "plt.legend()\n",
    "plt.ylabel(\"Temps d'exécution\")\n",
    "plt.title(\"Temps d'exécution en fonction de la taille du problème - alpha:{} | N={} | n_machines={}\".format(alpha,N,\"2/3\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, \"Temps d'exécution en fonction de la taille du problème - alpha:0.4 | N=1 | n_machines=2/3\")"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmUAAAGECAYAAAB3f1edAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAABJX0lEQVR4nO3deZxU5Zn28d/dTbPvi8hOAyoI2AjN7oISjRqNxgSXaIRoNK5JJokmmTfvmMxkRmfGmegbIYoad42YRI1GTVyiSaRZZVEBlR0EWZodGujlfv84p6G6qequXqpOdff1/Xwaqs561alTVXed85ynzN0RERERkWhlRR1ARERERFSUiYiIiGQEFWUiIiIiGUBFmYiIiEgGUFEmIiIikgFUlImIiIhkABVlGcTMJpnZxhQtO8vM/mhm16do+f9sZg+nYtn1xQKPmtlOM5uXxvX2NbN9ZpadhnW9Y2bfqsV8/c3MzaxZKnJVWleF7RGb2cymmdk/6mk9PzOzp+pjWXUVbttBCcZVeMxm1tnM5pvZuPQlrDszW2tmX6jvaaMU7kM/izpHZeFnxTtR56iN6l7jZvaamU1NZ6ZM0uiKsvDNvvyvzMyKYu5fFXW+mgjfuPrX0+L+HXjL3R+q64LiFY/u/h/uXuNiIM1OA84Berv7mFStpPIHjruvd/e27l6aqnVGqaaFVGPfHnXl7juAC4G7zaxP1HkynZm1MLPfmNkeM/vczL6f5HyPVlUsJ7kMN7MPzCwrZtgvzOyxWixrppl9HH5uTattpobO3c9398ejzmFmx5nZs2a2ycx2m9l7ZjY2znQzzewGMzsr3Bd2mVmhmb1gZr1qut5GV5SFb/Zt3b0tsB64KGbY01Hni4q7/8Td74s6R8T6AWvdfX/UQaTxSMXRRXff4u6T3H1DfS+7EfoZcALB6/ss4A4zO6+qGczsNGBgPa2/J3BFPSxnCXAz8H49LEvqri0wHxgFdAYeB/5kZm0rTXce8CqwDPiiu3ck2Cc+BX5d05U2uqIskfD03Y/NbFVYxc4ys87huPJTN980sw3h6a0bzWy0mS0NK9/7Y5Y1LayafxVW0CvMbHKl8avNbK+ZrUl0hM7MWpnZY+H6lgGjq8jfwszuMbP1ZrbFzB4ws1bhuFfN7H9ipn3OzH4T3u5gZo+Y2WYz+yz8FpcdM+31ZrY8zLrMzEaGwyt8gwxz/sLM2gCvAT1jjkD2tEqniszsy2b2Ubjt3jGzITHj1prZD8NtuzvM27KKx35tmHGnmf3ZzPrFjPPwufo0HD/dzCzOMq4DHgbGh5l/HvP4V5rZDgtO7/ZMdtnxtp2ZPQn0BV4O13OHVTo1GG6vP4brXGkxp5TD7TjLzJ4Il/uRmeVXsW3OCfe/3eE+apXGJ9x2VQlfC+WPbbWZfTvBdEOAB2K2665w+JfMbJEFRy82WMwpoMrbo5ocg83sjXBbfWxml1Uxba6ZvRtmfgPoGjPumKO7VsUptHB/fyBc995wuZX3u1vM7FOCN98q96XQBeG23G5m/20xR1eqeMyfmNkVMeMeM7MZFpzi2WfB+9DxZnZv+ByvMLNTY6bvaWa/N7NtFrwXfSfR9quOmQ00s7cteP/cbmZPm1nHBNP+zMx+Z8Fre6+ZvW9meZUmG2Fx3gPMrJOZvRJm3hne7l1FtGuAf3P3ne6+HHgImFbF42gG/Aq4tQYPvyr/Bfw8mf25Ku4+3d3fAg7WNZAF77n/Fu4fe83sL2bWtZp5avo5WOX+YGZ9zOwP4fNYGDtvOP6ecB1rzOz8StkrNGeoYtqEn29mNih83e4O8z1Xk23o7qvd/X/dfbO7l7r7TKA5cFLM+k8Bdrn7xvCL1KaYRZQCNT8K6+6N9g9YC3whvP09YA7QG2gBPAg8G47rDzjBh0tL4FyCF8aLwHFAL2ArcGY4/TSgBPgnIAe4HNhNUE23AfYAJ4XT9gCGJsh3N/D3cL4+wIfAxgTT3gv8MZy2HfAycFc47vgw39nAVcBqoF047sXwsbYJH8s84NvhuCnAZwTFoIU7UL9wnAODYtb/GPCL8PakyjkJvq0+Fd4+EdhPcKowB7gDWAk0j3le5hF8m+gMLAduTPC4LwnnHQI0A34KzI4Z78ArQEeCYmgbcF6CZU0D/hFz/2xgOzAy3Cd+BfwtmWVXs+3WEu53lfavZuH9d4EZBPvaiHC5k2O240HgAiAbuAuYk+DxdCXY174Wbud/Itgvv5XMtqu0rMoZv0RwJMGAM4EDwMhktmvMPjKc4IvfKcAW4JIE63onJvORZRHssxuAb4b5R4bPV6LXUwHwv+FzeQawl6P75CSO3WcrPE+Vxj0Wzn9GuLz7qLjvOPAGwf7biuT2pb+G0/cFPqnmMX8rfMyjgB3A8Jhc28PhLYG3gTUEhUk28Avgr+G0WcBC4F8IPkwGELw3fLGW76eDCF7TLYBuwN+AexO83/4MKObovvnDMGdOde8BQBfgq0Brgve654EXY9bzY+CV8HancNt2jxn/NeCDKh7H7cB98d7n4kz7M+BnVYx3gqN0C2Oez18Aj8VMs6uKvx/HWeY/gGnVPBeTgHeqGP8OsIrgvbhVeP/uapbZn5p9DibcH8J9cQnwS4J9uiVwWsz+XgxcH053E7AJsATvB1VN+yKJP9+eBf4PwevgyPrDcUureE5mJNg+I8Lt0aHSvnhXzP2+4TLKwtxVPo9x11ObF2dD+aPim8Rywg++8H6PcKM1i9kZe8WMLwQuj7n/e+B7MTvKkR0jHDYP+Ea4c+wieFNpVU2+1cQUEMANxCnKCD4Y9wMDY4aNB9bE3L+U4M18e8zO3x04FJsDuJKjb9p/Br6bIFtdirL/C8yKGZdFUMBMinlero4Z/1/AAwlyvAZcV2lZB6hYPMa+2GYR540u5nmL/WB9BPivmPttw32if3XLrmbbHdnvwvvl+1czguK7lLBoDsffRfgmHm7HN2PGnQwUJVjPNcQUbOF+spGjb2hVbrtKyzqSMcG6Xqzi8VbYrgmmuRf4Zbx1kbgouxz4e6XlPAjcGWf5fQkK0jYxw56hbkXZbyvtG6VAn5h94+wa7kuxr/WbCdp4xnvM71XKMpOwMAhzPRQz7jZgecz94QTf3AHGAusrLesnwKNVPVfJ/hEU/YvibU+C/Th238wCNgOnx0yb7HvACGBngnF9wm3bMmbYOQTNFBJNv5Lwg5X6KcoGEXyJWk9QoFQoymqxXeurKPtppf3t9WqW2Z8afA5WtT8QfD5tI877Sbi/r4y53zpc7/Ex2b9V3bRU//n2BMFrp3c97OvtgQ+An1Qa/vfyfbrS8M7Aj4BxNV1Xkzl9SdDe4IXwEOwugiKtlOCJLbcl5nZRnPux55I/83Drh9YBPT1or3Q5cCOw2cz+ZGaDE2TqSVBIxS4jnm4EO+PCmPyvh8PLvULwTeJjdy9vdN2P4Fvq5pj5HiT4RgHBG9SqBOusi57EPBZ3LyN4nLGNHj+PuX2Aits2Vj/gvpj8OwiKj9osq7qc+wjehJJZdm23XU9gh7vvjRm2rpp1tkxwaqTC/hPuj7H7UzLbLi4zO9/M5oSn0HYRfOhUefqj0vxjzeyv4amL3QSvh6Tnj8k/tjx/mOMqgjfkynoSfHDHthdM9HpKVuy23Uew/XrGG09y+1Ll13rl05sQPOZh4WnIFWa2gqDNSqeYaZJ9n+pH0Mwgdvv9MxXf84AKV8TuM7N9cXKVN3z+bXiaaA/wFFU/p7Hbr4zgC0PsY4772jKz1mb2oJmtC9fzN6Cjxb96uTxr+5hh7QmOcsZzL/Cv7r67itw15u6vEhRlN9Tncuuotu+LSe1f1ewPfYB17l5SXTZ3PxDeTJQv0bTVfb7dQfB+N8+CZiDXJlh+lSxoJvQywZeMu2KGdwQGA7Mrz+PBxTqPAy/V9LR2UyrKNgDnu3vHmL+W7v5ZLZfXy6xC26W+BEfPcPc/u/s5BEfjVhC0cYhnM8HOG7uMeLYTvBiGxmTv4MHFDOX+naDQ7GFmV4bDNhB8k+gaM197dx8aMz5RY9cDBIVgudgPQqdqmwheMEDQFQXB46zNtt5AcDg69nlr5e7HvBBqoXLONgSnTpLJWdW2q2r7bAI6m1m7mGF9k1xnZRX2n5jtHJuxxtvOzFoQfCO+h+C0UEeChqzHtNULxXu8zxCcbu/j7h0ITokkmj+RDcC7lfK3dfeb4ky7GegUPoflYl9P+4nZn8MP+NgvNfHEbtu2BN9+Y9uMxD7uZPalyq/12GWV2wAscPfBMX993f271WSNZwPB0fTY7dfO3S+oPKEfvSK2/CKpeO4ieMynuHt74Gqqfk5jt18WQdOReI+5sh8QtNsZG67njPLFxMm9k+C5z4sZnAd8lGDZk4H/tuAqzfIP+wIz+3oSuarzU4LTZbHvm5V7BKj898/1sN6oVLU/bAD61rQgqaEqP9/c/XN3v97dewLfBmZY2E46LNISPScPlK8gfC98keB1XLld7RcJjnYnuoq8GUGB2D7B+LiaUlH2APDvFjbWNbNuZnZxHZZ3HPAdM8sxsykE7XZeNbPuFjRyb0Oww+wjOCIXzyzgJxY0bO1NcCriGOG3zIeAX5rZcWH+Xmb2xfD2GQTtbq4J/35lZr3cfTPwF+B/zKy9BRc7DDSzM8NFPwz80MxGWWCQHW3MvBj4upllW3AlU/k8EHxz6mJmHap4XF8ys8lmlkPwJnuION8okvAAwTYaGj7WDuH2rg/PAN80sxHhi+8/gLnuvjaJeavadlsI2u8cw4Or6WYDd5lZSwsail4H1ObK4D8BQ83s0vDN7ztULJ5ru+2aE5yG2QaUWNCw9twqpt8C9Daz5jHD2hEcETxoZmOA2nzovQKcaGbfCF9nORY0Oh5SeUJ3XwcsIGhw3dyCq+suipnkE4Ijjl8K98mfho+xKheY2Wnh4/o3gn0j0dWQyexLt4ev9T7Ad4F4DY9fAU6woIFz86oecxLmAXvM7EcWXFSUbWbDzCzhBUXVaEfwfrbLgkv9b69m+lEx++b3CN4D5iS5nqJwPZ2BO6uZ/gngp+G2HUzQ/uixBNOeSFC0jQj/INhPXkgiV5Xc/R2CU1xTKw1vW8Xff5RPFz7fLQkKm5zw/SGTP6Or2h/mERTLd5tZm/CxTKzPlVf3+WZmU+zoBSI7CQrI0nDeoVU8JzeG8+cAvyPYF68JP4djfYngyyrh9Jea2Ulhjm4E7VsXhUfNkpbJT3h9u4/gm/tfzGwvwZvDMX2O1MBcggae2wmOUn3N3QsJtukPCL4R7iAoZm5OsIyfE5zGWEOwcz1Zxfp+RNAWYo4Fh4rfBE4ys/YEb0q3uvtn4anLR4BHzcwIirTmBJfr7iTYyXoAuPvzYfZnCA73v0hwNACCD42LCNrHXRWOI5xvBUEjytUWHDaucBrG3T8m+Nb0q3D7XETQNcnhKh5fXO7+AvCfwG/Dx/0hcH7VcyW97LcI2r/9nuANZCBJXtpezba7i+BDYpeZ/TDO7FcStN/YRPBhcKe7v1GL/NsJLji4m+BU2QnAezHja7XtwlOr3yEorncSFFR/rGKWtwmOTHxuZtvDYTcD/xq+1v4lXFaNhDnOJXhONhGcxvhPEhdTXyd4Te8g+CB/ImZZu8NMDxN8691PcDqtKs+Ey9lB0LA+YT+HSe5LLxE0CF9MUFA/Emc5ewnaRJVfSFLdY04o/AZ/EUHxsYbgtfgwkOjLVHV+TnAhw26C/H+oZvqXCJpy7CRob3upuxcnsZ57CRqnbyd4n349dqQFHVW/FjPoToKmBOsILqL5b3d/PWb6fWZ2OoC7bw2PoHzu7uVHyra7e1ESuZLxU46+D9TUXwgKgAkEbaGKOHqUMBMl3B9i9r1BBKd1NxLsC/Ut4ecbwUVYcy04Hf9Hgjaxa2qw7AkE/QWeS1B4lh9JOz38bD2Hivtmr/D+XoLivAz4Sk0fUPkVDFIDFnTs9y13Py3qLCJS/yzo/HOju/806iwNkQVdoAxy96ujzlIX4ePA3X8WbZKKzGwSwQUIk6JN0jSFR//v9xR0Qt6UjpSJiIiI1IfqTqvXSsp/505ERKSBeifqAAmsJXG7uYQs6Mj8wTij1sVcACbVcPeU/XayTl+KiIiIZACdvhQRERHJACrKRERERDJAStuUWfCj2BcCW919WDisM0H/PP0JzotfFnYAiJn9hKDPplLgO+7+5+rW0bVrV+/fv38q4ouIiIjUq4ULF25397idV6e0TVnYqek+4ImYouy/CDqVvNvMfgx0cvcfmdnJBH1fjSH4KY43gROr6C0XgPz8fF+wYEHKHoOIiIhIfTGzhe6eH29cSk9fuvvfCDpejHUxwW9CEf5/Sczw37r7obCDt5UEBZqIiIhIoxdFm7Lu4c8jlP9MQvmPh/ai4g/2biSJH04WERERaQwyqaF/vB+2jXtu1cxuMLMFZrZg27ZtKY4lIiIiknpRdB67xcx6uPtmM+sBbA2HbwT6xEzXm+D37o7h7jMJfhuM/Pz8Ywq34uJiNm7cyMGDB+s3uSTUsmVLevfuTU5OTtRRREREGqQoirI/AlMJfkR5KsGP1pYPf8bM/pegof8JBL80X2MbN26kXbt29O/fn+B3QyWV3J3CwkI2btxIbm5u1HFEREQapJSevjSzZ4EC4CQz22hm1xEUY+eY2acEv7J+N4C7fwTMIvi199eBW6q78jKRgwcP0qVLFxVkaWJmdOnSRUcmRURE6iClR8rc/coEoyYnmP7fgX+vj3WrIEsvbW8REZG6yaSG/o3Ghg0bOOussxgyZAhDhw7lvvvuS9u6H3vsMW699da44y644AJ27dqVtiwiIiKSvCjalDV6zZo143/+538YOXIke/fuZdSoUZxzzjmcfPLJkeZ69dVXI12/iIiIJKYjZSnQo0cPRo4cCUC7du0YMmQIn3322THTTZs2jZtuuomzzjqLAQMG8O6773LttdcyZMgQpk2bdmS6m266ifz8fIYOHcqdd955ZPj8+fOZMGECeXl5jBkzhr179wKwadMmzjvvPE444QTuuOOOI9P379+f7du3s3btWoYMGcL111/P0KFDOffccykqKgJg1apVnHfeeYwaNYrTTz+dFStWAPD8888zbNgw8vLyOOOMM+p9m4mIiDR57t6g/0aNGuWVLVu27JhhUVmzZo336dPHd+/efcy4qVOn+uWXX+5lZWX+4osvert27Xzp0qVeWlrqI0eO9EWLFrm7e2Fhobu7l5SU+JlnnulLlizxQ4cOeW5urs+bN8/d3Xfv3u3FxcX+6KOPem5uru/atcuLioq8b9++vn79end379evn2/bts3XrFnj2dnZR5Y/ZcoUf/LJJ93d/eyzz/ZPPvnE3d3nzJnjZ511lru7Dxs2zDdu3Oju7jt37oz7WDNpu4uIiGQiYIEnqGka/enLn7/8Ecs27anXZZ7csz13XjS02un27dvHV7/6Ve69917at28fd5qLLroIM2P48OF0796d4cOHAzB06FDWrl3LiBEjmDVrFjNnzqSkpITNmzezbNkyzIwePXowevRogArLnzx5Mh06dAiynnwy69ato0+fPhXWm5uby4gRIwAYNWoUa9euZd++fcyePZspU6Ycme7QoUMATJw4kWnTpnHZZZdx6aWXJrmlREREGgh3iPiitUZflEWluLiYr371q1x11VVVFjEtWrQAICsr68jt8vslJSWsWbOGe+65h/nz59OpUyemTZvGwYMHcfeEVzzGLic7O5uSkpJqpykqKqKsrIyOHTuyePHiY6Z/4IEHmDt3Ln/6058YMWIEixcvpkuXLtVuBxERkYy37WOYdQ185UHoOSKyGI2+KEvmiFZ9c3euu+46hgwZwve///06LWvPnj20adOGDh06sGXLFl577TUmTZrE4MGD2bRpE/Pnz2f06NHs3buXVq1a1Wld7du3Jzc3l+eff54pU6bg7ixdupS8vDxWrVrF2LFjGTt2LC+//DIbNmxQUSYiIo1DwXTYuRY69I40hhr6p8B7773Hk08+ydtvv82IESMYMWJEra98zMvL49RTT2Xo0KFce+21TJw4EYDmzZvz3HPPcdttt5GXl8c555xTL523Pv300zzyyCPk5eUxdOhQXnop+MGF22+/neHDhzNs2DDOOOMM8vLy6rwuERGRyO3fDkt+C3lXQJuukUaxoM1Zw5Wfn+8LFiyoMGz58uUMGTIkokRNl7a7iIg0OO/8J7zzH3DLfOh2YspXZ2YL3T0/3jgdKRMREZGmqfggzH8ITvhiWgqy6qgoExERkabpg1mwfxuMvyXqJICKMhEREWmK3IMG/t2HQ25mdIquokxERESanlVvwbYVwVGyiPsnK6eiTERERJqegunQ9ngY9tWokxyhokxERESali0fwaq3YewN0Kx51GmOUFGWAgcPHmTMmDFH+vqK/RHxVHvssce49dZb44674IIL2LVrV9qyiIiIZKSCGZDTGkZ9M+okFTT6Hv2j0KJFC95++23atm1LcXExp512Gueffz7jxo2LNFdtO7AVERFpNPZuCa66HHkNtO4cdZoKdKQsBcyMtm3bAsFvYBYXF8f9ncpp06Zx0003cdZZZzFgwADeffddrr32WoYMGcK0adOOTHfTTTeRn59/zFG3+fPnM2HCBPLy8hgzZgx79+4FYNOmTZx33nmccMIJ3HHHHUem79+/P9u3b2ft2rUMGTKE66+/nqFDh3LuuedSVFQEwKpVqzjvvPMYNWoUp59+OitWrADg+eefZ9iwYeTl5XHGGZlxlYqIiEiNzX8YSoth3M1RJzmWuzfov1GjRnlly5YtO2ZYupWUlHheXp63adPG77jjjrjTTJ061S+//HIvKyvzF1980du1a+dLly710tJSHzlypC9atMjd3QsLC48s88wzz/QlS5b4oUOHPDc31+fNm+fu7rt37/bi4mJ/9NFHPTc313ft2uVFRUXet29fX79+vbu79+vXz7dt2+Zr1qzx7OzsI8ufMmWKP/nkk+7ufvbZZ/snn3zi7u5z5szxs846y93dhw0b5hs3bnR39507d8Z9PJmw3UVERBI6tN/97v7uz1wZWQRggSeoaRr/6cvXfgyff1C/yzx+OJx/d5WTZGdns3jxYnbt2sVXvvIVPvzwQ4YNG3bMdBdddBFmxvDhw+nevTvDhw8HYOjQoaxdu5YRI0Ywa9YsZs6cSUlJCZs3b2bZsmWYGT169GD06NFA8GPi5SZPnkyHDh0AOPnkk1m3bh19+vSpsN7c3FxGjBgBwKhRo1i7di379u1j9uzZTJky5ch0hw4dAmDixIlMmzaNyy67jEsvvbSGG0xERCQDLP0tFO3ImM5iK2v8RVnEOnbsyKRJk3j99dfjFmUtWrQAICsr68jt8vslJSWsWbOGe+65h/nz59OpUyemTZvGwYMHcfe4p0RjlwlBcVhSUlLtNEVFRZSVldGxY0cWL158zPQPPPAAc+fO5U9/+hMjRoxg8eLFdOnSJentICIiEqmysqCBf48R0G9C1GniavxFWTVHtFJh27Zt5OTk0LFjR4qKinjzzTf50Y9+VKtl7dmzhzZt2tChQwe2bNnCa6+9xqRJkxg8eDCbNm1i/vz5jB49mr1799KqVas65W7fvj25ubk8//zzTJkyBXdn6dKl5OXlsWrVKsaOHcvYsWN5+eWX2bBhg4oyERFpOFa+AYWfwlcfyZjOYitr/EVZBDZv3szUqVMpLS2lrKyMyy67jAsvvLBWy8rLy+PUU09l6NChDBgwgIkTJwLQvHlznnvuOW677TaKiopo1aoVb775Zp2zP/3009x000384he/oLi4mCuuuIK8vDxuv/12Pv30U9ydyZMnk5eXV+d1iYiIpM3sX0H7XnDyxVEnSciCNmcNV35+vi9YsKDCsOXLlzNkyJCIEjVd2u4iIpKRNi+BB8+Ac/4VJn430ihmttDd8+ONU5cYIiIi0rgVzIDmbWHk1KiTVElFmYiIiDReezbBh7+DU78BrTpGnaZKKspERESk8Zo3E7wMxn476iTVarRFWUNvK9fQaHuLiEjGObQPFvwGBl8InXOjTlOtRlmUtWzZksLCQhUKaeLuFBYW0rJly6ijiIiIHLXkWTi4G8bfGnWSpDTKLjF69+7Nxo0b2bZtW9RRmoyWLVvSu3fvqGOIiIgEykphzgzoPRr6jo06TVIaZVGWk5NDbm7mH6YUERGRFPn4NdixGib/S9RJktYoT1+KiIhIE1cwHTr0hcEXRZ0kaSrKREREpHH5bCGsnw3jboTshnNSUEWZiIiINC4FM6BF+6BvsgZERZmIiIg0Hrs2wEcvwMhroGX7qNPUiIoyERERaTzmPRj83wA6i61MRZmIiIg0Dof2wsLH4eSLoWPfqNPUmIoyERERaRwWPQWH9jSYzmIrU1EmIiIiDV9pSdBZbN/x0HtU1GlqRUWZiIiINHwrXoFd62H8LVEnqTUVZSIiItLwFUyHTrlw0gVRJ6k1FWUiIiLSsG2YBxvnwbibISs76jS1pqJMREREGraC+6FlBxjx9aiT1ImKMhEREWm4dq6F5S/DqG9Ci7ZRp6kTFWUiIiLScM19ECwLxtwQdZI6U1EmIiIiDVPRLnj/CRj2VejQK+o0daaiTERERBqm95+Aw/uCBv6NgIoyERERaXhKi4NTl/1Ph54jok5TL1SUiYiISMOz7CXYs7FBdxZbmYoyERERaVjcg24wugyCE74YdZp6o6JMREREGpb1BbBpUdhZbOMpZRrPIxEREZGmoWA6tOoEeVdGnaReqSgTERGRhqNwFaz4E+RfB81bR52mXkVWlJnZP5nZR2b2oZk9a2Ytzayzmb1hZp+G/3eKKp+IiIhkoDm/huycRtFZbGWRFGVm1gv4DpDv7sOAbOAK4MfAW+5+AvBWeF9EREQEDuyAxU/D8CnQrnvUaepdlKcvmwGtzKwZ0BrYBFwMPB6Ofxy4JJpoIiIiknEWPgbFBxpNZ7GVRVKUuftnwD3AemAzsNvd/wJ0d/fN4TSbgeOiyCciIiIZpuQwzJsJAybB8cOiTpMSUZ2+7ERwVCwX6Am0MbOrazD/DWa2wMwWbNu2LVUxRUREJFN89AfYuxnG3xZ1kpSJ6vTlF4A17r7N3YuBPwATgC1m1gMg/H9rvJndfaa757t7frdu3dIWWkRERCJQ3llst8EwaHLUaVImqqJsPTDOzFqbmQGTgeXAH4Gp4TRTgZciyiciIiKZYu3f4fMPgrZkZlGnSZlmUazU3eea2e+A94ESYBEwE2gLzDKz6wgKtylR5BMREZEMUjAdWneFUy6POklKRVKUAbj7ncCdlQYfIjhqJiIiIgLbPoFPXodJP4GcllGnSSn16C8iIiKZa84MyG4R9ODfyKkoExERkcy0vxCWPAt5l0Pbxn9hn4oyERERyUwLfgMlB2HcLVEnSQsVZSIiIpJ5ig8GncUOOgeOGxx1mrRQUSYiIiKZ58Pfwf6tML5pHCUDFWUiIiKSadyDbjCOGxr8rFIToaJMREREMsvqv8LWZcFRskbcWWxlKspEREQks8y+H9p2h+FfizpJWqkoExERkcyxZRmsegvGXA/NWkSdJq1UlImIiEjmmDMDmrWCUddGnSTtVJSJiIhIZti3FZbOghFXQpsuUadJOxVlIiIikhnmPwylh5pMZ7GVqSgTERGR6BUXBUXZiedD10FRp4mEijIRERGJ3tLn4EBhk+ostjIVZSIiIhKtsjIomAHHnwL9T4s6TWRUlImIiEi0Vr4J2z+GCbc1qc5iK1NRJiIiItEquB/a9YSTL4k6SaRUlImIiEh0Pv8A1rwLY2+AZs2jThMpFWUiIiISnYIZkNMGRk2LOknkVJSJiIhINPZshg+eh1Ovhladok4TORVlIiIiEo35D0FZCYy7MeokGUFFmYiIiKTf4f2w4Dcw+EvQeUDUaTKCijIRERFJvyXPQtFOGH9r1EkyhooyERERSa/yzmJ7jYK+46JOkzFUlImIiEh6ffI67FgV/KRSE+4stjIVZSIiIpJeBdOhQx8YcnHUSTKKijIRERFJn02LYN0/YOy3IbtZ1GkyiooyERERSZ+C6dC8HYy8JuokGUdFmYiIiKTH7o3w0QtBQdayQ9RpMo6KMhEREUmPeTPBy4JTl3IMFWUiIiKSeof2wYLHYMiXoVO/qNNkJBVlIiIiknqLnoJDu2HCbVEnyVgqykRERCS1ykphzgzoMxZ650edJmOpKBMREZHUWvEn2LUu6CxWElJRJiIiIqlVMB069oPBF0adJKOpKBMREZHU2bgANsyBcTdDVnbUaTKaijIRERFJnYL7oUUHOPWqqJNkPBVlIiIikho718Gyl2DUVGjRLuo0GU9FmYiIiKTGvJlgWTD2xqiTNAgqykRERKT+HdwNCx+HoV+BDr2iTtMgqCgTERGR+vf+k3B4b9DAX5KiokxERETqV2kJzH0A+k2EXiOjTtNgqCgTERGR+rX8j7B7A4y/NeokDYqKMhEREak/7kE3GJ0HwInnRZ2mQVFRJiIiIvVnw1z4bGHYWazKjJrQ1hIREZH6U3A/tOwII74edZIGR0WZiIiI1I8dq2H5KzD6OmjeJuo0DY6KMhEREakfcx6ArGYw+vqokzRIzZKZyMxOBG4H+sXO4+5npyiXiIiINCRFO2HRUzD8a9C+R9RpGqSkijLgeeAB4CGgNHVxREREpEFa+DgU74fxt0SdpMFKtigrcfdfpzSJiIiINEylxTD3Qcg9E44fHnWaBivZNmUvm9nNZtbDzDqX/6U0mYiIiDQMH70Aezeps9g6SvZI2dTw/9tjhjkwoLYrNrOOwMPAsHBZ1wIfA88B/YG1wGXuvrO26xAREZEUK+8stuuJMOgLUadp0JI6UubuuXH+al2Qhe4DXnf3wUAesBz4MfCWu58AvBXeFxERkUy17j3YvESdxdaDZK++zAFuAs4IB70DPOjuxbVZqZm1D5c1DcDdDwOHzexiYFI42ePhen5Um3WIiIhIGhRMh9ZdIO+KqJM0eMmWtL8GRgEzwr9R4bDaGgBsAx41s0Vm9rCZtQG6u/tmgPD/4+qwDhEREUml7Svh49dg9Lcgp1XUaRq8ZNuUjXb3vJj7b5vZkjqudyRwm7vPNbP7qMGpSjO7AbgBoG/fvnWIISIiIrU2ZwZk5wRFmdRZskfKSs1sYPkdMxtA3for2whsdPe54f3fERRpW8ysR7iOHsDWeDO7+0x3z3f3/G7dutUhhoiIiNTKgR2w+Bk45TJoqxNb9SHZI2W3A381s9WAEfTs/83artTdPzezDWZ2krt/DEwGloV/U4G7w/9fqu06REREJIUW/AZKitQNRj1Kqihz97fM7ATgJIKibIW7H6rjum8Dnjaz5sBqgiIvC5hlZtcB64EpdVyHiIiI1LeSQzBvJgycDMcNiTpNo1FlUWZmZ7v722Z2aaVRA80Md/9DbVfs7ouB/DijJtd2mSIiIpIGH/4e9m2BS/RjP/WpuiNlZwJvAxfFGedArYsyERERaYDcg24wjjsZBp4ddZpGpcqizN3vDG/+q7uviR1nZrkpSyUiIiKZac27sOVDuHg6mEWdplFJ9urL38cZ9rv6DCIiIiINwOz7oc1xMFzNvutbdW3KBgNDgQ6V2pW1B1qmMpiIiIhkmK0rYOUbcNb/gWYtok7T6FTXpuwk4EKgIxXble0Frk9RJhEREclEc2ZAs5aQf23USRql6tqUvQS8ZGbj3b0gTZlEREQk0+zfDkt+CyO+Dm26Rp2mUUq289gbzOyYI2PurlJZRESkKZj/MJQegnE3R52k0Uq2KHsl5nZL4CvApvqPIyIiIhmn+CDMewhO+CJ0OzHqNI1Wsj36V7j60syeBd5MSSIRERHJLB/MggPbYfwtUSdp1JLtEqOyE4C+9RlEREREMlB5Z7HHD4fcM6JO06gldaTMzPYS9OBf7nPgRylJJCIiIplj5VuwbQV85UF1FptiyZ6+bJfqICIiIpKBCu6HtsfD0Mo/gy31LanTl2b2FTPrEHO/o5ldkrJUIiIiEr0tH8Hqv8LYG6BZ86jTNHrJtim70913l99x913AnYknFxERkQavYAbktIZR34w6SZOQbFEWb7pku9MQERGRhmbvluCqyxFXQevOUadpEpItyhaY2f+a2UAzG2BmvwQWpjKYiIiIRGj+Q1BaDONuijpJk5FsUXYbcBh4DpgFFAHqrERERKQxOnwA5j8CJ10AXQZGnabJSPbqy/3Aj82srbvvS3EmERERidLS30LRDphwa9RJmpSER8rMLCfm9gQzWwYsC+/nmdmMNOQTERGRdCorCzqL7Xkq9B0fdZomparTlzeY2Wnh7V8CXwQKAdx9CaBufUVERBqbT/8ChSth/K3qLDbNqirKHgAuK7/j7hsqjS9NSSIRERGJTsH90L4XnHxx1EmanIRFmbuXuvt3wrsbzGwC4GbW3Mx+CCxPS0IRERFJj81LYO3fYeyNkJ1T/fRSr5K9+vJGgqstewEbgRHo6ksREZHGpWA6NG8LI6+JOkmTlGwHsFnuflXsADM7ibCNmYiIiDRwezbBh7+H0ddDq45Rp2mSkj1S9nczO9K+zMx+ALyQmkgiIiKSdvNmgpfBuBujTtJkJXukbBIw08ymAN0J2pONSVUoERERSaND+2DBb2DIRdCpf9RpmqykjpS5+2bgdWA80B94Qp3IioiINBKLn4GDu4NuMCQySR0pM7M3gM3AMKA38Bsz+5u7/zCV4URERCTFykphzgzoPRr66CRYlJJtUzbd3a9x913u/iHBEbPdKcwlIiIi6fDxa7BzDYxXpwpRS/b05YtmdpqZfTMc1Al4KnWxREREJC0KpkPHvjD4oqiTNHlJFWVmdifwI+An4aDmqCgTERFp2D5bCOtnw9ibIDvZa/8kVZI9ffkV4MvAfgB33wS0S1UoERERSYOC6dCiPZx6ddRJhOSLssPu7oADmFmb1EUSERGRlNu1AT56Mei9v2X7qNMIyRdls8zsQaCjmV0PvAk8lLpYIiIiklLzHgz+H6vOYjNFUieQ3f0eMzsH2AOcBPyLu7+R0mQiIiKSGgf3wMLHYegl0LFP1GkklHSrvrAIUyEmIiLS0C16Cg7tgXHqBiOTVFmUmdkagnZk29x9bHoiiYiISMqUlsDcX0Pf8dB7VNRpJEaVRZm756YriIiIiKTBildg13r44l1RJ5FKqjtS1rmq8e6+o37jiIiISEoV3A+dcuGk86NOIpVU16ZsIcHpSwP6AjvD2x2B9YCOpImIiDQUG+bBxvlw/n9DVnbUaaSSKrvEcPdcdx8A/Bm4yN27unsX4ELgD+kIKCIiIvWk4H5o2QFGfD3qJBJHsv2UjXb3V8vvuPtrwJmpiSQiIiL1budaWP4y5F8LLdpGnUbiSLZLjO1m9lOC37t04GqgMGWpREREpH7NeQAsC8bcEHUSSSDZI2VXAt2AF8K/buEwERERyXRFu2DRkzDsq9C+Z9RpJIFke/TfAXw3xVlEREQkFd5/Ag7vg/HqLDaTJXukTERERBqi0mKY+wD0Px165EWdRqqgokxERKQxW/YS7PkMxt8adRKphooyERGRxso96AajyyA44dyo00g1kirKzOy/zKy9meWY2Vtmtt3Mrk51OBEREamD9QWwaRGMuxmydBwm0yX7DJ3r7nsIOo3dCJwI3J6yVCIiIlJ3s++HVp0hTx0mNATJFmU54f8XAM/qNy9FREQyXOEq+PhVGH0dNG8ddRpJQrKdx75sZiuAIuBmM+sGHExdLBEREamTOb+G7BwYfX3USSRJSR0pc/cfA+OBfHcvBvYDF6cymIiIiNTSgR2w+GkYPgXadY86jSQp2Yb+LYFvAs+b2e+BbwO76rpyM8s2s0Vm9kp4v7OZvWFmn4b/d6rrOkRERJqchY9C8QF1FtvAJNum7AlgKPAr4H5gCPBkPaz/u8DymPs/Bt5y9xOAt8L7IiIikqySwzB3Jgw4C7oPjTqN1ECyRdlJ7n6du/81/LuB4ArMWjOz3sCXgIdjBl8MPB7efhy4pC7rEBERaXI++gPs+1ydxTZAyRZli8xsXPkdMxsLvFfHdd8L3AGUxQzr7u6bAcL/j6vjOkRERJqO8s5iuw2GQZOjTiM1lGxRNhaYbWZrzWwtUACcaWYfmNnSmq7UzC4Etrr7wprOG85/g5ktMLMF27Ztq80iREREGp81f4PPPwjakplFnUZqKNkuMc6r5/VOBL5sZhcALYH2ZvYUsMXMerj7ZjPrAWyNN7O7zwRmAuTn53s9ZxMREWmYCqZD664w/LKok0gtJNslxjpgD9AB6FL+5+7rwnE14u4/cffe7t4fuAJ4292vBv4ITA0nmwq8VNNli4iINEnbPoFP/wxjroecllGnkVpI6kiZmf0bMA1YBZQfmXLg7HrOczcwy8yuA9YDU+p5+SIiIo3TnBmQ3QLyr4s6idRSsqcvLwMGuvvh+g7g7u8A74S3CwG1TBQREamJ/dthybOQdwW07RZ1GqmlZBv6fwh0TGEOERERqa0Fv4GSgzDu5qiTSB0ke6TsLoJuMT4EDpUPdPcvpySViIiIJKf4IMybCYPOgeMGR51G6iDZouxx4D+BD6jYr5iIiIhE6cPfwf5t+kmlRiDZomy7u/+/lCYRERGRmnEPusHoPgwGTIo6jdRRskXZQjO7i6DLitjTl++nJJWIiIhUb9XbsHUZXPJrdRbbCCRblJ0a/j8uZlgqusQQERGRZBVMh7bdYdhXo04i9SCposzdz0p1EBEREamBLctg1Vtw9k+hWYuo00g9SKpLDDPrbmaPmNlr4f2Tww5eRUREJApzpkOzVuosthFJtp+yx4A/Az3D+58A30tBHhEREanOvq2wdBaM+Dq07hx1GqknVRZlZlZ+erOru88i7A7D3UuA0hRnExERkXjmPwylh9VZbCNT3ZGyeeH/+82sC+HvXprZOGB3KoOJiIhIHMVFQVF24vnQdVDUaaQeVdfQv/z62u8TdIcx0MzeA7oBX0tlMBEREYljyW/hQCFMuDXqJFLPqivKupnZ98PbLwCvEhRqh4AvAEtTmE1ERERilZXBnBnQIw/6TYw6jdSz6oqybKAtR4+YlWudmjgiIiKS0Mo3YfsncOlD6iy2EaquKNvs7v+aliQiIiJStYL7oV1PGPqVqJNIClTX0F9luIiISCbYvBTWvAtjvw3ZOVGnkRSoriibnJYUIiIiUrU5MyCnDYyaGnUSSZEqizJ335GuICIiIpLAns3wwe/g1KuhVaeo00iKJNujv4iIiERl/kNQVgLjbow6iaSQijIREZFMdng/zH8EhlwInQdEnUZSSEWZiIhIJlv8DBzcBePVWWxjp6JMREQkU5V3FttrFPQZG3UaSTEVZSIiIpnqk9dhx2oYf4s6i20CVJSJiIhkqoL7oUMfGHJx1EkkDVSUiYiIZKLP3od178HYGyG7uh/gkcZARZmIiEgmmjMDmreDkd+IOomkiYoyERGRTLN7I3z0Aoy8Blp2iDqNpImKMhERkUwz90HwMnUW28SoKBMREckkh/bCwsfh5IuhY9+o00gaqSgTERHJJIuehkO71VlsE6SiTEREJFOUlQYN/PuMhd75UaeRNFNRJiIikilWvAK71ukoWROlokxERCRTFEyHjv1g8JeiTiIRUFEmIiKSCTbMhw1zYdzNkJUddRqJgIoyERGRTDBnOrToAKdeHXUSiYiKMhERkajtXAfLXoL8adCibdRpJCIqykRERKI290GwLBjz7aiTSIRUlImIiETp4G54/wkY+hXo0CvqNBIhFWUiIiJRev9JOLwXxt8SdRKJmIoyERGRqJSWwNwHoN9p0PPUqNNIxFSUiYiIRGX5S7B7g46SCaCiTEREJBruMPt+6DwQTjwv6jSSAVSUiYiIRGHDXNj0Poy/GbL0cSwqykRERKIx+1fQqhPkXRl1EskQKspERETSbcdqWPEnyL8WmreJOo1kCBVlIiIi6TbnAchqBqOvjzqJZBAVZSIiIulUtBMWPQXDp0D7HlGnkQyiokxERCSdFj4GxfuDBv4iMVSUiYiIpEvJ4eB3LnPPhOOHR51GMoyKMhERkXRZ9iLs3Qzjb406iWQgFWUiIiLp4A4F90PXk2DQF6JOIxlIRZmIiEg6rP0HbF6izmIloUj2CjPrY2Z/NbPlZvaRmX03HN7ZzN4ws0/D/ztFkU9ERKTeFUyH1l3glMujTiIZKqpSvQT4gbsPAcYBt5jZycCPgbfc/QTgrfC+iIhIw7Z9JXzyGoz+FuS0ijqNZKhIijJ33+zu74e39wLLgV7AxcDj4WSPA5dEkU9ERKRezZkB2S2CokwkgchPaptZf+BUYC7Q3d03Q1C4AcdFGE1ERKTuDuyAxc/AKZdBW32sSWKRFmVm1hb4PfA9d99Tg/luMLMFZrZg27ZtqQsoIiJSVwsegZIiGH9L1Ekkw0VWlJlZDkFB9rS7/yEcvMXMeoTjewBb483r7jPdPd/d87t165aewCIiIjVVcgjmPQQDJ8NxQ6JOIxkuqqsvDXgEWO7u/xsz6o/A1PD2VOCldGcTERGpNx/+HvZtgQnqLFaq1yyi9U4EvgF8YGaLw2H/DNwNzDKz64D1wJRo4omIiNSRO8y+H447GQacFXUaaQAiKcrc/R+AJRg9OZ1ZREREUmL1O7D1I7h4OliijzyRoyK/+lJERKRRKpgObY6D4TrpI8lRUSYiIlLftq6AlW/AmBugWYuo00gDoaJMRESkvs2ZDs1aQv61USeRBkRFmYiISH3atw2WPAd5V0KbLlGnkQZERZmIiEh9WvAIlB6CcTdHnUQaGBVlIiIi9aX4YNBZ7InnQbcTo04jDYyKMhERkfqy9Dk4sF0/qSS1oqJMRESkPrgH3WAcPxz6nx51GmmAVJSJiIjUh5VvwfaPYfyt6ixWakVFmYiISH0ouB/a9YChl0adRBooFWUiIiJ19fmHsPqvYWexzaNOIw2UijIREZG6mjMDclrDqGlRJ5EGTEWZiIhIXez9HJbOghFXQevOUaeRBkxFmYiISF3MfxjKSmDcTVEnkQZORZmIiEhtHT4A8x+BwV+CLgOjTiMNnIoyERGR2lryLBTtUGexUi9UlImIiNRGWVnQwL/nqdB3fNRppBFQUSYiIlIbn/4FCleqs1ipNyrKREREaqPgfmjfG06+OOok0kioKBMREampTYth7d9h7LchOyfqNNJIqCgTERGpqTkzoHlbGHlN1EmkEVFRJiIiUhN7NsGHvw8KslYdo04j9WDn/sO89sFmDpWURpqjWaRrFxERaWjmPgheFpy6lAZp36ES5q/ZwXsrtzN7VSHLP9+DO/z2hnGMG9AlslwqykRERJJ1aB8sfBSGXASd+kedRpJ0sLiU99fvpGBVIbNXFbJkwy5Kypzm2VmM6teJ73/hRCYM6sIpvTtGmlNFmYiISLIWPwMHdwfdYEjGKikt44PPdjN7VSGzV21nwdqdHCopI8vglN4dueGMAUwc1JVR/TrRMic76rhHqCgTERFJRllp0MC/9xjoMybqNBKjrMz5eMteZq8qpGDVduau3sHeQyUADD6+HVeN7ceEgV0YM6Az7Vtm7tWyKspERESS8fGrsHMNfOFnUSdp8tyddYUHmL2qkPdWbWfOqkIK9x8GoH+X1lyY15OJg7owbkAXurZtEXHa5KkoExERSUbBdOjYFwZfGHWSJunz3QeZvWp7eDSskM92FQHQvX0LzjyxG+MHdmHCoK706tgq4qS1p6JMRESkOhsXwvoC+OJdkK2PznTYuf8wc1YHR8Jmrypk9bb9AHRsncP4AV24cdJAJgzswoCubbBG8jNX2rNERESqM2c6tGgPI78RdZJGq7ybitmrtvPeyqPdVLRpns2Y3M5cObovEwZ1Ycjx7cnKahxFWGUqykRERKqyawN89CKMvxlatIs6TaNxsLiURet3HTklGdtNxch+HSt0U5GT3TT6uldRJiIiUpW5DwT/j1FnsXUR201FwapC5q/dcUw3FRMGdiW/f2Z1U5FOKspEREQSObgH3n8Chl4CHftEnaZBKStzPtm6l9krg77CGmo3FemkokxERCSRRU/BoT3qLDYJsd1UzF61nYI43VRMGNiF8QMbVjcV6aSiTEREJJ7SEpjza+g7AXqNjDpNRqqqm4ozTux2pAjr3al1xEkbBhVlIiIi8ax4GXavh/PuijpJxijvpqK809Zjuqk4cwATBnVtVN1UpJOKMhERkXgKpkOnXDjp/KiTRGb/oRLmrd3B7JXB0bBlm4NuKlrHdFMxfmAXTu7ReLupSCcVZSIiIpVtmAcb58MF90BW07kSsLybioJV23kvTjcV//SFE5nYxLqpSCcVZSIiIpXN/hW07Agjvh51kpQqKS3jw017eG/l9mO6qRge003FqH6daNW86RSnUVFRJiIiEmvHGljxCkz8LjRvE3WaeuXufLwlcTcVXx/blwkDuzJW3VREQkWZiIhIrLkPgmXBmBuiTlJn7s76HQd4b+Wx3VT069KaC/N6MGFgV8YN6EK3duqmImoqykRERMoV7YJFT8Kwr0H7nlGnqZUte8JuKlYGV0mWd1NxXLugm4rxA7swQd1UZCQVZSIiIuXefxwO7wt+57KB2HXgMAWrCo902roqTjcV4wd2ZWA3dVOR6VSUiYhI01JWCgcKYf822LcV9m+H/VuD+4uehv6nQ4+8qFMmVN5NRcGqQt5buf2YbiouH92HCQO7qpuKBkhFmYiINHzFRWGRtS34v7zIqnB/e1CEHSgE/NhlZOVAh14w+V/SHr8qh0qCbirK+wpbHNNNxal9g24qJgzsQl4fdVPR0KkoExGRzOMOB3cdLaRii6r9247+lR/pOrw3/nKat4O23aBNN+g8APqMhbbHBffbdKt4u2UHyIDTe+XdVJS3C6vcTcX1ZwxgorqpaJRUlImISHqUFgdHqRIVVpWPbpUVH7sMy4LWXY4WUr1GhYVVV2gTFljlRVibbpDTKv2Ps4YqdlNRyNzVhUe6qTip+9FuKsbkdqZDK3VT0ZipKBMRkdo7vD9xUVX56FbRjvjLyG5x9IhV2+Ph+OFhUVW5yDoOWndu8D3sl3dTMTtsEzZndSHb91XspmL8wK6MVzcVTY6KMhEROaqsLDhteORoVpzThrG3iw/EX07LDkcLqW4nQe7pYZHVteIpwzbdoEW7jDhtmEpVdVNx+gnqpkICKspERBq7ksMVTxdWLqxij24d2A5lJccuw7JjThF2hS4DKxZWFU4hdoVmTfsIz64Dh5mzuvBIp63l3VR0aBV0U/HtM4OfL1I3FRJLRZmISEPjDof2Jtcua/9WOLg7/nJyWh8tqjr2gV6nxj9l2KYbtOoEWbqyL5GquqkY3f9oNxVDerQnW91USAIqykREMkFZKRzYkeCUYez9sPAqORh/Oa06HS2kjh8WU1iVnzaMud3IftcxnarrpuJ7k09k4qAunNK7I82bqZiV5KgoExFJleKDidtlVT66daAQvOzYZWTlhIVVWEh1OynBKcNwmmxdnZcKpWXOB5/tPvL7kfPX7uBgcdhNRa8OXH/GACYM7EJ+v87qpkJqLeOKMjM7D7gPyAYedve7I44kIhJwD04FVjhNGFNYVTiFuB0O7Ym/nObtjhZZnXOhz5j4RVbbbtCyY6NvBJ+J3J1Ptuxj9qrtvLeykLlrCtl78Gg3FVeM7svEQeqmQupXRhVlZpYNTAfOATYC883sj+6+LNpkIlKBe3BUp/yvrLTifS+rNE0142s1f8w0ceevS4bSo8VX5aNbpYfjbBA72ndW227Q81SOvdKwvODqBs0b7xV2ZWVOmTtlDmXuePj/kWEx4z1muvJpS+tp/NH1luc4eru0LPH4g8WlvL9+FwWrth/ppqJv59ZceIq6qZDUy6iiDBgDrHT31QBm9lvgYiCyomzdx4vYtXk1AOaVf5bDE9wmeLMP2TE/5+Fxb1YeUGG+Gqz72JyJ1l1pvjjjYv+NP10Vy68yV1XbJHYbVLH8KrbJMdu8ynUnygh4GeZlgAf/exnG0Q9z89JqxpcdM7z8fjBPOL97OL7i7SPzU3Z0umPulwaPt8K0fmSdR9Z/TM7Yx+AVl3nM8o+u24hziq0RKs3K4VDzLhxs0YWDzTtzsH1/irp2pqh5F4pyOnEgp/ORv6JmHSi1bErLi4Gy8MP+kOMHnbJtYTHgB3Bfd3R8pWKhzJ2yMioVHbUbX7kYcndKE4yPLVCCgiV2mZXWU03R1Rgc164Fpw3qyoRBQRHWp3PjLaIls2RaUdYL2BBzfyMwtvJEZnYDcANA3759Uxpo81szGLd1VkrXIQ1fmRthCYSTdeR2KVkEJU5W3PFlZIXzZoXjKk579Hb5cipOW+qVx2dRRrNK8x67zorzJhh/ZD2x48L7XvX40gSPxzHKvJrx4fzxHm9ZmDnheKoY7/GWfey2LSVolH2IHDhQ3WnDEmBr+BefGWSZkWVgZmSHt7PMgnFZVmF8lkG2WXA7q3xeq7Cc8mHl463C8OD/7CwjJ8sSji+f38wqDC9fT3aF8cfmyM46NpNVWn9V44PHXXHbVM6Rfcy2iT/eYh9T7HasxfjsLKNr2+bqpkIikWlFWbxXwbHHYtxnAjMB8vPzU/rdrO/5P+DjwstjwlSOGHP/mBdx4nEVl1NpPkt0p/J0R+8fk8uqmK/KXMcuI/bfeMvwqh53lbkq8oSZk39siZdROWJymd0My2oWLjcLLAu3LDDDLYvgjLvFfVzVvadbFfli5zWCBpbJqq/11nR8Vcutft7azVfd3NVvi8QqFCFZlYqZ2CIlK06xE1M46MNdRJKVaUXZRqBPzP3ewKaIsgDQM3cw5A6OMoKIiIg0AZnWecp84AQzyzWz5sAVwB8jziQiIiKSchl1pMzdS8zsVuDPBGdsfuPuH0UcS0RERCTlMqooA3D3V4FXo84hIiIikk6ZdvpSREREpElSUSYiIiKSAVSUiYiIiGQAFWUiIiIiGUBFmYiIiEgGUFEmIiIikgFUlImIiIhkABVlIiIiIhlARZmIiIhIBjB3jzpDnZjZNmBdilfTFdie4nVIZtJz33TpuW+69Nw3Tel63vu5e7d4Ixp8UZYOZrbA3fOjziHpp+e+6dJz33TpuW+aMuF51+lLERERkQygokxEREQkA6goS87MqANIZPTcN1167psuPfdNU+TPu9qUiYiIiGQAHSkTERERyQAqyqpgZi3NbJ6ZLTGzj8zs51FnkvQxs2wzW2Rmr0SdRdLHzNaa2QdmttjMFkSdR9LHzDqa2e/MbIWZLTez8VFnktQzs5PC13v53x4z+14UWZpFsdIG5BBwtrvvM7Mc4B9m9pq7z4k6mKTFd4HlQPuog0janeXu6qeq6bkPeN3dv2ZmzYHWUQeS1HP3j4EREHwZBz4DXogii46UVcED+8K7OeGfGuE1AWbWG/gS8HDUWUQk9cysPXAG8AiAux92912RhpIoTAZWuXuqO6WPS0VZNcJTWIuBrcAb7j434kiSHvcCdwBlEeeQ9HPgL2a20MxuiDqMpM0AYBvwaNhs4WEzaxN1KEm7K4Bno1q5irJquHupu48AegNjzGxYxJEkxczsQmCruy+MOotEYqK7jwTOB24xszOiDiRp0QwYCfza3U8F9gM/jjaSpFN4yvrLwPNRZVBRlqTwMPY7wHnRJpE0mAh82czWAr8Fzjazp6KNJOni7pvC/7cStCsZE20iSZONwMaYsyG/IyjSpOk4H3jf3bdEFUBFWRXMrJuZdQxvtwK+AKyINJSknLv/xN17u3t/gkPZb7v71RHHkjQwszZm1q78NnAu8GG0qSQd3P1zYIOZnRQOmgwsizCSpN+VRHjqEnT1ZXV6AI+HV2NkAbPcXd0jiDRe3YEXzAyC98dn3P31aCNJGt0GPB2exloNfDPiPJImZtYaOAf4dqQ51KO/iIiISPR0+lJEREQkA6goExEREckAKspEREREMoCKMhEREZEMoKJMREREJAOoKBMRiYiZfau8L0QRERVlIpJSZtbFzBaHf5+b2Wcx95tXmvZGM7smvP2YmX0tvP2OmeXXcv39zSytHcAmymtm08zs/phBfwXuDzunFpEmTp3HikhKuXshMALAzH4G7HP3exJM+0D6ktWNmTVz95K6LMPdVwH6tQgRAXSkTEQiYGbXm9l8M1tiZr8Pe9PGzH5mZj+sZt5zzazAzN43s+fNrG2caUaFyy4AbokZXuFIlZm9YmaT4sy/1sz+08zmhX+DwuGPmdn/mtlfgf80sxFmNsfMlprZC2bWKWYxV5vZbDP70MyO+f3M8Gfcfm9mC8JtMTFmGzxuZn8Jc1xqZv9lZh+Y2etmlhPzGN81s4Vm9mcz61HlRheRjKeiTESi8Ad3H+3uecBy4LpkZjKzrsBPgS+4+0hgAfD9OJM+CnzH3cfXIeMedx8D3A/cGzP8xHD9PwCeAH7k7qcAHwB3xkzXxt0nADcDv4mz/PuAe909H5hSaZqBwJeAi4GngL+6+3CgCPhSWJj9Cviau48K5/33OjxWEckAOn0pIlEYZma/ADoCbYE/JznfOOBk4L3w9ymbAwWxE5hZB6Cju78bDnoSOL8WGZ+N+f+XMcOfd/fSOOt5HHi+8vzu/jczax+nQf8XgJ7h4wDIjjnq95q7F5vZB0A2UP77mx8A/YGTgGHAG+H82cDmWjxGEckgKspEJAqPAZe4+xIzmwZMSnI+A95w9yurmSbRj/qWUPEMQcsqluMJbu+vMmH8eeLdzwLOd/ei2IFhkXUIwN3LzKzYj/5IcRnB+7YBH9XxSKCIZBidvhSRKLQDNoen4a6qwXxzgIkxbbxam9mJsRO4+y5gt5mdFg6KXf5aYISZZZlZH+CYtl4xLo/5v6DySHffDew0s9PDQd8A3o2Z5PIw42nA7nD6WH8Bbiu/Y2ajqshS2cdANzMbH86bY2ZDazC/iGQgHSkTkSj8X2AusI7glFy7ZGZy923hkbVnzaxFOPinwCeVJv0m8BszO0DFU6PvAWvCdX4IvF/F6lqY2VyCL6+JjsxNBR4IL1RYHa633E4zmw20B66NM+93gOlmtpTgvfhvwMIq8hzh7ofD7kL+X3gatRlBu7ePkplfRDKTHT0qLiIiEFx9CeS7+/aos4hI06HTlyIiIiIZQEfKRERERDKAjpSJiIiIZAAVZSIiIiIZQEWZiIiISAZQUSYiIiKSAVSUiYiIiGQAFWUiIiIiGeD/A4NQlRfGQ7QoAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "N = 1 #Nombre d'échantillons\n",
    "n = 8 #Taille maximum du problème\n",
    "alpha = 0.4\n",
    "\n",
    "resultats_BB = [[] for i in range(3,n)]\n",
    "resultats_BB_2 = [[] for i in range(3,n)]\n",
    "\n",
    "for _ in range(N):\n",
    "    for i in range(3,n):\n",
    "        p,d,w = genMultiInstances(i,alpha,2)\n",
    "        \n",
    "        #n_machines = 2 \n",
    "        start = time.time()\n",
    "        _, _, _, _, _ = branch_and_bound(p,d,w, True, getPrimal, getDual,exploration_1, 2)\n",
    "        end = time.time()\n",
    "        resultats_BB[i-3].append(end-start)\n",
    "        \n",
    "        p,d,w = genMultiInstances(i,alpha,3)\n",
    "        #n_machines = 3\n",
    "        start = time.time()\n",
    "        _, _, _, _, _ = branch_and_bound(p,d,w, True, getPrimal, getDual,exploration_1, 3)\n",
    "        end = time.time()\n",
    "        resultats_BB_2[i-3].append(end-start)\n",
    "\n",
    "resultats_BB_2 = [np.mean(res) for res in resultats_BB_2]\n",
    "resultats_BB_2 = np.array(resultats_BB_2)\n",
    "\n",
    "resultats_BB = [np.mean(res) for res in resultats_BB]\n",
    "resultats_BB = np.array(resultats_BB)\n",
    "\n",
    "plt.figure(figsize=(10,6))\n",
    "X = list(range(3,n))\n",
    "plt.plot(X,resultats_BB, label=\"2 machines\")\n",
    "plt.plot(X,resultats_BB_2, label=\"3 machines\")\n",
    "plt.xlabel(\"Taille du problème\")\n",
    "plt.xticks(X)\n",
    "plt.legend()\n",
    "plt.ylabel(\"Temps d'exécution\")\n",
    "plt.title(\"Temps d'exécution en fonction de la taille du problème - alpha:{} | N={} | n_machines={}\".format(alpha,N,\"2/3\"))\n",
    "#plt.savefig(\"img/2-3-machines.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "N = 1 #Nombre d'échantillons\n",
    "n = 8 #Taille maximum du problème\n",
    "alpha = 0.4\n",
    "\n",
    "resultats_BB = [[] for i in range(3,n)]\n",
    "resultats_BB_2 = [[] for i in range(3,n)]\n",
    "resultats_BB_3 = [[] for i in range(3,n)]\n",
    "\n",
    "for _ in range(N):\n",
    "    for i in range(3,n):\n",
    "        \n",
    "        p,d,w = genMultiInstances(i,alpha,1)\n",
    "        #n_machines = 1 \n",
    "        start = time.time()\n",
    "        _, _, _, _, _ = branch_and_bound(p,d,w, True, getPrimal, getDual,exploration_1, 1)\n",
    "        end = time.time()\n",
    "        resultats_BB[i-3].append(end-start)\n",
    "        \n",
    "        p,d,w = genMultiInstances(i,alpha,2)\n",
    "        #n_machines = 2 \n",
    "        start = time.time()\n",
    "        _, _, _, _, _ = branch_and_bound(p,d,w, True, getPrimal, getDual,exploration_1, 2)\n",
    "        end = time.time()\n",
    "        resultats_BB_2[i-3].append(end-start)\n",
    "        \n",
    "        p,d,w = genMultiInstances(i,alpha,3)\n",
    "        #n_machines = 3\n",
    "        start = time.time()\n",
    "        _, _, _, _, _ = branch_and_bound(p,d,w, True, getPrimal, getDual,exploration_1, 3)\n",
    "        end = time.time()\n",
    "        resultats_BB_3[i-3].append(end-start)\n",
    "\n",
    "\n",
    "resultats_BB_3 = [np.mean(res) for res in resultats_BB_3]\n",
    "resultats_BB_3 = np.array(resultats_BB_3)\n",
    "\n",
    "resultats_BB_2 = [np.mean(res) for res in resultats_BB_2]\n",
    "resultats_BB_2 = np.array(resultats_BB_2)\n",
    "\n",
    "resultats_BB = [np.mean(res) for res in resultats_BB]\n",
    "resultats_BB = np.array(resultats_BB)\n",
    "\n",
    "plt.figure(figsize=(10,6))\n",
    "X = list(range(3,n))\n",
    "plt.plot(X,resultats_BB, label=\"1 machines\")\n",
    "plt.plot(X,resultats_BB_2, label=\"2 machines\")\n",
    "plt.plot(X,resultats_BB_3, label=\"3 machines\")\n",
    "plt.xlabel(\"Taille du problème\")\n",
    "plt.xticks(X)\n",
    "plt.legend()\n",
    "plt.ylabel(\"Temps d'exécution\")\n",
    "plt.title(\"Temps d'exécution en fonction de la taille du problème - alpha:{} | N={} | n_machines={}\".format(alpha,N,\"2/3\"))\n",
    "#plt.savefig(\"img/1-2-3-machines-8.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}