01. Recherche opérationnelle/01. Notebooks d'optimisation - création en cours/18. Annexe - Manipulation des variables de décision.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Manipulation des variables de décision.\n",
    "\n",
    "Dans ce notebook, on va voir comment créer des <b>variables de décision</b> rapidement dans un solveur python.\n",
    "\n",
    "On va aussi voir comment <b> itérer </b> sur ces variables de décision, dans la fonction objectif et les contraintes.\n",
    "\n",
    "## Sommaire\n",
    "\n",
    "1. <b>Méthode de base</b>\n",
    "2. <b>Méthode avec le dictionnaire Python Pulp</b>\n",
    "3. <b>Créer des contraintes plus rapidement avec les dictionnaires pulp.</b>\n",
    "4. <b>Utiliser un dictionnaire de variables de décisions dans la fonction objectif</b>\n",
    "    - Le problème à traiter : Minimisation de coût en livraison (Transport).\n",
    "    - Solutionner en écrivant à la main les variables de décision \n",
    "        - Contraintes lignes\n",
    "        - Curiosité : On change les contraintes\n",
    "        - Contraintes colonnes\n",
    "    - Solutionner avec les <b>itérations</b> et les <b>dictionnaires de variables de décision.</b>\n",
    "    - Importer un fichier Excel\n",
    "5. <b>Utiliser une matrice dans les contraintes</b>\n",
    "6. <b>Itérer</b>\n",
    "    - avec le solveur Python Gekko \n",
    "    - avec le solveur Python Cplex\n",
    "    - avec le solveur Python Cvxopt\n",
    "\n",
    "Etude globale proposée par <b>Estelle Derrien - Github estellederrien</b>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Méthode de base"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Rappel :\n",
    "Une variable de décision <b>contient</b> une valeur qui sera ensuite <b>calculée</b> par le solveur pour être <b>la meilleure valeur possible</b> pour <b>minimiser</b> ou <b>maximiser</b> une <b>fonction objectif</b> ( C'est ça, <b>l'optimisation</b>)\n",
    "\n",
    "En général, dans les problèmes simples et linéaires, le solveur applique l'algoritme du simplexe, bien sur, ce n'est pas comme à l'école et on ne calcule pas le simplexe à la main, avec Python Pulp, tout est automatique, et rapide !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x\n",
      "y\n"
     ]
    }
   ],
   "source": [
    "# La méthode de base :\n",
    "\n",
    "# -----------------------------------\n",
    "# Import de Python Pulp\n",
    "# -----------------------------------\n",
    "from pulp import *\n",
    "\n",
    "# -----------------------------------\n",
    "# Type du problème\n",
    "# -----------------------------------\n",
    "# On choisit de résoudre un problème de Maximisation\n",
    "Lp_prob = LpProblem('Problem', LpMaximize)\n",
    "\n",
    "# -----------------------------------\n",
    "# Variables de décision\n",
    "# -----------------------------------\n",
    "# On définit nos variables de décision ci-dessous\n",
    "\n",
    "x = LpVariable(\"x\", lowBound=0, cat='Integer')   # Créer une variable x >= 0\n",
    "y = LpVariable(\"y\", lowBound=0, cat='Integer')   # Créer une variable y >= 0\n",
    "\n",
    "# -----------------------------------\n",
    "# Affichage\n",
    "# -----------------------------------\n",
    "print(x)\n",
    "print(y)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Méthode avec le dictionnaire de Python Pulp\n",
    "\n",
    "Dans l'exemple précédent, ca va parce qu'on a que deux variables de décisions, mais qu'en sera-t-il si on en a 100 ?\n",
    "On peut aussi utiliser cette méthode pour créer plus rapidement des variables de décision.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'automobile': produits__automobile, 'cycle1': produits__cycle1, 'cycle2': produits__cycle2, 'dragon': produits__dragon, 'nounours': produits__nounours, 'poupee': produits__poupee, 'arc': produits__arc}\n"
     ]
    }
   ],
   "source": [
    "# -----------------------------------\n",
    "# Import de Python Pulp\n",
    "# -----------------------------------\n",
    "from pulp import *\n",
    "\n",
    "# -----------------------------------\n",
    "# Type du problème\n",
    "# -----------------------------------\n",
    "prob = LpProblem (\"MaximiserProfit\", LpMaximize)\n",
    "\n",
    "# -----------------------------------\n",
    "# Nos données\n",
    "# -----------------------------------\n",
    "produits = [\"automobile\", \"cycle1\",\"cycle2\",\"dragon\",\"nounours\",\"poupee\",\"arc\"]\n",
    "\n",
    "# -----------------------------------\n",
    "# Variables de décision\n",
    "# -----------------------------------\n",
    "# Ici, on crée nos variable de décision en créant un \"dicts\".\n",
    "x = LpVariable.dicts(\"produits \", produits , 0)\n",
    "\n",
    "# -----------------------------------\n",
    "# Impression\n",
    "# -----------------------------------\n",
    "# On visualise notre dicts\n",
    "# Chaque produit est désormais une variable de décision qui peut prendre une valeur.\n",
    "print(x)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Créer des contraintes plus rapidement avec les dictionnaires\n",
    "\n",
    "Dans cet exemple ci-dessous, on crée des valeurs de contraintes dans des dictionnaires python afin de pouvoir <b>itérer</b> dessus ensuite, pour aller plus vite.\n",
    "\n",
    "En fait, c'est aussi une association de valeurs à nos variables de décisions, réalisées aux format dictionnaire python, ce qui permet d'écrire plus vite ensuite dans la fonction objectif et dans les contraintes. \n",
    "\n",
    "Mais attention, le nombre de variables de décisions doit correspondre au nombre dans les dictionnaires Python , ici, on a 7 variables de décisions, donc dans les dictionnaires, on retrouve cette taille de 7 variables de décision.\n",
    "\n",
    "Ceci peut faciliter les choses dans le cas ou l'on importe ces données à partir d'une base de données, il devient plus facile de les placer dans un dictionnaire.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Status: Optimal\n",
      "produits__arc = 2.0\n",
      "produits__automobile = 40.0\n",
      "produits__cycle1 = 2.0\n",
      "produits__cycle2 = 2.0\n",
      "produits__dragon = 2.0\n",
      "produits__nounours = 26.0\n",
      "produits__poupee = 2.0\n",
      "TotalProfit 584.0\n"
     ]
    }
   ],
   "source": [
    "# -----------------------------------\n",
    "# Import de Pulp\n",
    "# -----------------------------------\n",
    "from pulp import *\n",
    "\n",
    "# -----------------------------------\n",
    "# Nos données\n",
    "# -----------------------------------\n",
    "\n",
    "# La liste de nos produits ( des jouets), ca va être les variables de décision, \n",
    "# elles pourront prendre une valeur entière, vu que ce sont des objets uniques. \n",
    "# Par exemple , produire 15 automobiles, produire 25 arcs etc ...\n",
    "produits = [\"automobile\", \"cycle1\",\"cycle2\",\"dragon\",\"nounours\",\"poupee\",\"arc\"]\n",
    "\n",
    "# Les bénéfices en EUROS par produits\n",
    "benefices = {\"automobile\": 8, \"cycle1\": 12, \"cycle2\": 14,\"dragon\": 3,\"nounours\":6,\"poupee\":13,\"arc\":12}\n",
    "\n",
    "# Emplois (en kgs)\n",
    "plastique = {\"automobile\": 2, \"cycle1\": 4, \"cycle2\": 5,\"dragon\": 3,\"nounours\":1,\"poupee\":4,\"arc\":2}\n",
    "bois      = {\"automobile\": 1, \"cycle1\": 1, \"cycle2\": 2,\"dragon\": 2,\"nounours\":1,\"poupee\":5,\"arc\":1}\n",
    "acier     = {\"automobile\": 1, \"cycle1\": 2, \"cycle2\": 3,\"dragon\": 3,\"nounours\":2,\"poupee\":2,\"arc\":5}\n",
    "\n",
    "# Les noms de nos ressources\n",
    "ressources = {\"plastique\", \"bois\", \"acier\"}\n",
    "\n",
    "# Les stocks de nos ressources en KG\n",
    "stocks = {\"plastique\": 142, \"bois \": 117, \"acier\": 124}\n",
    "\n",
    "# -----------------------------------\n",
    "# Type du problème\n",
    "# -----------------------------------\n",
    "\n",
    "# Créer le type de problème, ici, on veut maximiser notre profit de notre usine de jouets\n",
    "prob = LpProblem (\"MaximiserProfit\", LpMaximize)\n",
    "\n",
    "# -----------------------------------\n",
    "# Variables de décision\n",
    "# -----------------------------------\n",
    "\n",
    "# On crée nos variables, en se basant sur le tableau x ( array en Anglais)\n",
    "# On stipule que ce sont des variables entières, normal, puisque ce sont des jouets (On ne peut pas avoir 1/2 jouet...).\n",
    "x = LpVariable.dicts(\"produits \", produits , lowBound=0, cat='Integer')\n",
    "\n",
    "# -----------------------------------\n",
    "# Fonction objectif\n",
    "# -----------------------------------\n",
    "\n",
    "# La fonction objectif, Maximiser le bénéfice.\n",
    "# Ici, on voit qu'on itère à l'aide de notre tableau produits, sur les bénéfices qui sont contenus dans un \n",
    "# dictionnaire Python. Cette méthode revient souvent sur StackOverflow et en général.\n",
    "prob += lpSum([benefices[i] * x[i] for i in produits ]), \"MaximiserBenefice\" \n",
    "\n",
    "# -----------------------------------\n",
    "# Contraintes\n",
    "# -----------------------------------\n",
    "\n",
    "# Nos contraintes.\n",
    "# On respecte notre production sous contrainte de stocks\n",
    "# Ici, n voit qu'on itère à l'aide de notre tableau produits, sur les stocks qui sont contenus dans un \n",
    "# dictionnaire Python. Cette méthode revient souvent sur StackOverflow et en général.\n",
    "prob += lpSum([plastique[i] * x[i] for i in  produits]) <= 142 ,\"MaxPlastique\"\n",
    "\n",
    "# La ligne suivante veut dire : \n",
    "# \"\" Prends chaque valeur du tableau bois indicé par i et multiplie le par la \n",
    "# variable de décision x indice i, fait la somme de tout\n",
    "# et cette somme doit être inférieure à notre stock de bois de 117\n",
    "prob += lpSum([bois[i]      * x[i] for i in  produits]) <= 117 ,\"MaxBois\"\n",
    "\n",
    "prob += lpSum([acier[i]     * x[i] for i in  produits]) <= 124 ,\"MaxAcier\"\n",
    "\n",
    "# Production minimale par produits pour les clients : 2 unités\n",
    "for p in produits:\n",
    "   prob += x[p] >= 2, f\"min production units for product {p}\"\n",
    "\n",
    "\n",
    "# -----------------------------------\n",
    "# Solution\n",
    "# -----------------------------------\n",
    "   \n",
    "# On utilise le solver pulp\n",
    "prob.solve()\n",
    "\n",
    "# On affiche le statut de la solution\n",
    "print (\"Status:\", LpStatus [prob.status])\n",
    "\n",
    "# On écrit aussi le probleme dans un fichier\n",
    "# prob.writeLP ( \"JouetsModel.lp\")\n",
    "\n",
    "# Afficher l'optimium de chaques variables produits qui s'exprime en unité construites\n",
    "for v in prob.variables ():\n",
    "    print (v.name, \"=\", v.varValue)\n",
    "\n",
    "\n",
    "# Le résultat de la fonction objectif est ici :\n",
    "print (\"TotalProfit\", value (prob.objective))\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Utiliser un dictionnaire de variables de décisions dans la fonction objectif"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour comprendre cette technique, on va utiliser un problème simplifié de minimisation de coût en livraison, généralement appelé problème de Transport, (Transportation, en Anglais).\n",
    "\n",
    "- J'ai 4 fournisseurs et 4 dépots.\n",
    "- Chaque trajet entre un fournisseur et un dépot a un coût exprimé en euros.\n",
    "- Je veux minimiser le coût global de livraison, tout en m'assurant que <b> chaque fournisseur</b> soit utilisé, je ne suis pas obligé de livrer chaque dépot.\n",
    "\n",
    "On peut aussi en retrouver un similaire dans mon fichier 13 \" Optimisation chimie et pétrole \"avec un import excel \n",
    "\n",
    "Voici la matrice des coûts de livraison de notre problème :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {},
   "outputs": [],
   "source": [
    "                #Depot_A #Depot_B #Depot_C #Depot_D\n",
    "# Fournisseur_A 350       450       300       250\n",
    "# Fournisseur_B 450       390       310       268\n",
    "# Fournisseur_C 600       395       420       290 \n",
    "# Fournisseur_D 385       700       290       320"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Dans le tableau précédent, on voit que transporter une livraison du fournisseur A au dépot A coûte 350 euros, \n",
    "mais ne coûte que 250 euros jusqu'au dépot D.\n",
    "\n",
    "\n",
    "Voici un schéma rudimentaire de toutes les relations possibles, on voit déjà que c'est compliqué à tracer, alors imaginer avec 300 fournisseurs et 300 dépots ...\n",
    "\n",
    "<div style=\"text-align:center\">\n",
    "<img src=\"img/schemaintro.jpg\">\n",
    "</div>\n",
    "\n",
    "Dans ce problème, nous définissons la variable de décision binaire, X(i, j) telle que\n",
    "\n",
    "     X (i, j) = 1 si le Fournisseur 'i' est attribué au dépot 'j' sinon 0 pour tous i∈ (1,..4) et j ∈ (1,…4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {},
   "outputs": [],
   "source": [
    "# -----------------------------------\n",
    "# Import de Pulp\n",
    "# -----------------------------------\n",
    "from pulp import *\n",
    "\n",
    "# -----------------------------------\n",
    "# Nos données\n",
    "# -----------------------------------\n",
    "\n",
    "# On commence par créer nos données\n",
    "\n",
    "fournisseurs = ['Fournisseur_A','Fournisseur_B','Fournisseur_C','Fournisseur_D']\n",
    "\n",
    "depots = ['Depot_A','Depot_B','Depot_C','Depot_D']\n",
    "\n",
    "couts = [  \n",
    "\n",
    "# dépots   # A    B    C    D  \n",
    "            [350, 450, 300, 250],       # A   fournisseurs\n",
    "            [450, 390, 250, 268],       # B\n",
    "            [600, 395, 420, 290],       # C\n",
    "            [385, 700, 290, 320],       # D\n",
    "]\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Etape 1 : Résoudre en tapant les variables de décision à la main.\n",
    "\n",
    "Dans un premier temps, afin de bien comprendre l'intérêt du dictionnaire de variables de décisions, on va résoudre en tapant les variables de décision à la main. Cela signifie donc qu'on crée une variable de décision pour chaque relation possible du schéma précédent.\n",
    "\n",
    "Le but est de bien comprendre combien il est rébarbatif de taper les variables de décision à la main ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Selection : FADD = 1.0\n",
      "Selection : FBDC = 1.0\n",
      "Selection : FCDD = 1.0\n",
      "Selection : FDDC = 1.0\n",
      "Coût total minimisé : Euros 1080.0\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# -----------------------------------\n",
    "# Type du problème\n",
    "# -----------------------------------\n",
    "\n",
    "# On déclare un problème de Minimisation avec Python Pulp\n",
    "model = LpProblem(\"minimiser_couts\", LpMinimize)\n",
    "\n",
    "# -----------------------------------\n",
    "# Nos Variables de décision\n",
    "# -----------------------------------\n",
    "\n",
    "# On déclare les variables de décision à la main, une par une, c'est vraiment rébarbatif.\n",
    "# On le fait quand même afin de bien comprendre l'intérêt du dictionnaire de variables de décisions ensuite.\n",
    "# Ce sont donc chaque relation possible entre les dépots et fournisseurs, comme dans le schéma présenté au dessus.\n",
    "# FADA veut dire ' Du fournisseur A au dépot A'\n",
    "\n",
    "FADA = LpVariable(\"FADA\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "FADB = LpVariable(\"FADB\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "FADC = LpVariable(\"FADC\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "FADD = LpVariable(\"FADD\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "\n",
    "FBDA = LpVariable(\"FBDA\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "FBDB = LpVariable(\"FBDB\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "FBDC = LpVariable(\"FBDC\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "FBDD = LpVariable(\"FBDD\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "\n",
    "FCDA = LpVariable(\"FCDA\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "FCDB = LpVariable(\"FCDB\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "FCDC = LpVariable(\"FCDC\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "FCDD = LpVariable(\"FCDD\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "\n",
    "FDDA = LpVariable(\"FDDA\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "FDDB = LpVariable(\"FDDB\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "FDDC = LpVariable(\"FDDC\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "FDDD = LpVariable(\"FDDD\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "\n",
    "# -----------------------------------\n",
    "# Fonction objectif\n",
    "# -----------------------------------\n",
    "\n",
    "# Maintenant on va créer la fonction objectif coût à minimiser, forcément, \n",
    "# sans dictionnaire de décision, ni boucle d'itération,\n",
    "# C'est très lourd à écrire.\n",
    "\n",
    "# L'objectif est de réduire la somme du coût global de chaque relation\n",
    "model += (350 * FADA +  450 * FADB + 300 * FADC + 250 * FADD \n",
    "          + 450 * FBDA + 390 * FBDB + 250 * FBDC + 268 * FBDD + \n",
    "          600 *  FCDA + 395 * FCDB + 420 * FCDC + 290 * FCDD + \n",
    "          385 * FDDA + 700 * FDDB + 290 * FDDC + 320 * FDDD)\n",
    "\n",
    "# -----------------------------------\n",
    "# Contraintes\n",
    "# -----------------------------------\n",
    "\n",
    "# Les contraintes sont que chaque fournisseur livre au moins un dépot\n",
    "# Souvent, en Anglais, ils disent que ce sont des \"contraintes lignes\"\n",
    "# cette ligne veut dire : \n",
    "# Il doit forcément exister une relation entre Le fournisseur A et un des 4 dépots.\n",
    "# Comme il va minimiser le tout, il va choisir celle ayant la valeur minimum\n",
    "model += FADA +  FADB + FADC + FADD == 1\n",
    "# cette ligne de contrainte veut dire : \n",
    "# Il doit forcément exister une relation entre Le fournisseur B et un des 4 dépots.\n",
    "# Comme il va minimiser le tout, il va choisir celle ayant la valeur minimum\n",
    "model += FBDA +  FBDB + FBDC + FBDD == 1\n",
    "# cette ligne de contrainte veut dire : \n",
    "# Il doit forcément exister une relation entre Le fournisseur C et un des 4 dépots.\n",
    "# Comme il va minimiser le tout, il va choisir celle ayant la valeur minimum\n",
    "model += FCDA +  FCDB + FCDC + FCDD == 1\n",
    "# cette ligne de contrainte veut dire : \n",
    "# Il doit forcément exister une relation entre Le fournisseur D et un des 4 dépots.\n",
    "# Comme il va minimiser le tout, il va choisir celle ayant la valeur minimum\n",
    "model += FDDA +  FDDB + FDDC + FDDD == 1\n",
    "\n",
    "\n",
    "# -----------------------------------\n",
    "# Solution\n",
    "# -----------------------------------\n",
    "\n",
    "# On résouds avec Python Pulp, il va minimiser le coût global.\n",
    "model.solve()\n",
    "\n",
    "# On affiche la valeur de chaque variable > 0, c'est à dire, la relation selectionnée\n",
    "for i in model.variables():\n",
    "    if i.varValue > 0:\n",
    "        print('Selection :',i.name, '=', i.varValue)\n",
    "\n",
    "# On affiche la valeur de la fonction objectif coût minimisée\n",
    "print(\"Coût total minimisé : Euros {}\".format(value(model.objective)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Donc, le résultat est que le solveur selectionne bien les valeurs minimales pour chaque  relation Fournisseur/Dépot.\n",
    "Du fournisseur A au dépot D, on a un coût de 250 euros, donc il a choisi cette relation.. etc\n",
    "Il a donc minimisé le coût total en parcourant les valeurs de la matrice.\n",
    "On voit qu'il livre plusieurs fois le dépot D, parce qu'on a pas créé de contrainte stipulant qu'on veut livrer chaque dépot une seule fois, et au moins une fois."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Curiosité 1 : On change nos contraintes.\n",
    "\n",
    "On va changer les contraintes par curiosité.\n",
    "Finalement, on ne veut pas forcement que chaque fournisseur soit utilisé , on peut en utiliser un seul, et je ne suis pas obligé d'utiliser chaque dépot mais je veux exactement 4 trajets(routes), tant que cela minimise le coût global, \n",
    "comment faire?\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Selection : FADD = 1.0\n",
      "Selection : FBDC = 1.0\n",
      "Selection : FBDD = 1.0\n",
      "Selection : FCDD = 1.0\n",
      "Coût total minimisé : Euros 1058.0\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# -----------------------------------\n",
    "# Type du problème\n",
    "# -----------------------------------\n",
    "model = LpProblem(\"minimiser_couts\", LpMinimize)\n",
    "\n",
    "# -----------------------------------\n",
    "# Variables de décision\n",
    "# -----------------------------------\n",
    "\n",
    "FADA = LpVariable(\"FADA\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "FADB = LpVariable(\"FADB\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "FADC = LpVariable(\"FADC\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "FADD = LpVariable(\"FADD\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "\n",
    "FBDA = LpVariable(\"FBDA\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "FBDB = LpVariable(\"FBDB\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "FBDC = LpVariable(\"FBDC\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "FBDD = LpVariable(\"FBDD\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "\n",
    "FCDA = LpVariable(\"FCDA\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "FCDB = LpVariable(\"FCDB\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "FCDC = LpVariable(\"FCDC\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "FCDD = LpVariable(\"FCDD\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "\n",
    "FDDA = LpVariable(\"FDDA\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "FDDB = LpVariable(\"FDDB\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "FDDC = LpVariable(\"FDDC\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "FDDD = LpVariable(\"FDDD\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "\n",
    "# -----------------------------------\n",
    "# Fonction objectif\n",
    "# -----------------------------------\n",
    "\n",
    "# L'objectif est de réduire la somme du coût global de chaque relation\n",
    "model += (350 * FADA +  450 * FADB + 300 * FADC + 250 * FADD \n",
    "          + 450 * FBDA + 390 * FBDB + 250 * FBDC + 268 * FBDD \n",
    "          + 600 *  FCDA + 395 * FCDB + 420 * FCDC + 290 * FCDD \n",
    "          + 385 * FDDA + 700 * FDDB + 290 * FDDC + 320 * FDDD)\n",
    "\n",
    "# -----------------------------------\n",
    "# Contraintes\n",
    "# -----------------------------------\n",
    "\n",
    "# on peut désormais utiliser qu'un seul fournisseur si il faut.\n",
    "# On a pas du tout à livrer chaque dépot.\n",
    "# On veut donc que Pulp choisisse exactement 4 routes, et que cela minimise l'intégralité du total des données.\n",
    "model +=    (FADA +  FADB + FADC  + FADD + \n",
    "             FBDA + FBDB + FBDC + FBDD + \n",
    "             FCDA + FCDB + FCDC + FCDD + \n",
    "             FDDA + FDDB + FDDC + FDDD) == 4\n",
    "\n",
    "# -----------------------------------\n",
    "# Solution\n",
    "# -----------------------------------\n",
    "\n",
    "# On résouds avec Python Pulp, il va minimiser le coût global.\n",
    "model.solve()\n",
    "\n",
    "# On affiche la valeur de chaque variable > 0, c'est à dire, la relation selectionnée\n",
    "for i in model.variables():\n",
    "    if i.varValue > 0:\n",
    "        print('Selection :',i.name, '=', i.varValue)\n",
    "\n",
    "# On affiche la valeur de la fonction objectif coût minimisée\n",
    "print(\"Coût total minimisé : Euros {}\".format(value(model.objective)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Curiosité 2 : Contraintes colonne\n",
    "\n",
    "On va de nouveau changer nos contraintes, pour s'exercer, désormais, <b>chaque Dépôt doit impérativement être livré</b> mais,\n",
    "le même fournisseur peut être utilisé plusieurs fois!\n",
    "\n",
    "On appelle ça des contraintes 'colonne', en anglais, parce que quand on lit la matrice, on les déduit en lisant les colonnes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Selection : FADA = 1.0\n",
      "Selection : FADD = 1.0\n",
      "Selection : FBDB = 1.0\n",
      "Selection : FBDC = 1.0\n",
      "Coût total minimisé : Euros 1240.0\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# -----------------------------------\n",
    "# Type du problème\n",
    "# -----------------------------------\n",
    "model = LpProblem(\"minimiser_couts\", LpMinimize)\n",
    "\n",
    "# -----------------------------------\n",
    "# Vars de décision\n",
    "# -----------------------------------\n",
    "\n",
    "FADA = LpVariable(\"FADA\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "FADB = LpVariable(\"FADB\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "FADC = LpVariable(\"FADC\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "FADD = LpVariable(\"FADD\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "\n",
    "FBDA = LpVariable(\"FBDA\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "FBDB = LpVariable(\"FBDB\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "FBDC = LpVariable(\"FBDC\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "FBDD = LpVariable(\"FBDD\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "\n",
    "FCDA = LpVariable(\"FCDA\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "FCDB = LpVariable(\"FCDB\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "FCDC = LpVariable(\"FCDC\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "FCDD = LpVariable(\"FCDD\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "\n",
    "FDDA = LpVariable(\"FDDA\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "FDDB = LpVariable(\"FDDB\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "FDDC = LpVariable(\"FDDC\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "FDDD = LpVariable(\"FDDD\", lowBound=0, cat='Binary')   # Créer une variable binaire\n",
    "\n",
    "# -----------------------------------\n",
    "# Objectif\n",
    "# -----------------------------------\n",
    "\n",
    "# L'objectif est de réduire la somme du coût global de chaque relation\n",
    "model += (350 * FADA +  450 * FADB + 300 * FADC + 250 * FADD \n",
    "          + 450 * FBDA + 390 * FBDB + 250 * FBDC + 268 * FBDD + \n",
    "          600 *  FCDA + 395 * FCDB + 420 * FCDC + 290 * FCDD + \n",
    "          385 * FDDA + 700 * FDDB + 290 * FDDC + 320 * FDDD)\n",
    "\n",
    "# -----------------------------------\n",
    "# Contraintes\n",
    "# -----------------------------------\n",
    "\n",
    "# Les contraintes sont que chaque dépot soies impérativement livré.\n",
    "# On voit que ce sont des contraintes de type \"colonne\"\n",
    "\n",
    "model += FADA + FBDA + FCDA + FDDA == 1\n",
    "model += FADB + FBDB + FCDB + FDDB == 1\n",
    "model += FADC + FBDC + FCDC + FDDC == 1\n",
    "model += FADD + FBDD + FCDD + FDDD == 1\n",
    "\n",
    "# -----------------------------------\n",
    "# Solution\n",
    "# -----------------------------------\n",
    "\n",
    "# On résouds avec Python Pulp, il va minimiser le coût global.\n",
    "model.solve()\n",
    "\n",
    "# On affiche la valeur de chaque variable > 0, c'est à dire, la relation selectionnée\n",
    "for i in model.variables():\n",
    "    if i.varValue > 0:\n",
    "        print('Selection :',i.name, '=', i.varValue)\n",
    "\n",
    "# On affiche la valeur de la fonction objectif coût minimisée\n",
    "print(\"Coût total minimisé : Euros {}\".format(value(model.objective)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On voit donc qu'il selectionne FADA, soit la relation fournisseur A à Dépot A, parce qu'il a lu les données en colonne et qu'il a trouvé que la valeur 350 et celle qui minimise la première colonne. Et ainsi de suite pour les 4 colonnes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Etape 2 : Résoudre en utilisant le dictionnaire de variables de décision.\n",
    "\n",
    "On a donc réussi précédemment à obtenir un bon résultat.\n",
    "Admettons maintenant qu'on nous fournisse un fichier avec 500 fournisseurs et 500 Dépots, va-t-il falloir écrire chaque relations possible à la main ?\n",
    "Non, bien sur, on va donc voir les techniques de création de dictionnaires de variables de décision et les méthodes d'itération.\n",
    "\n",
    "Basiquement, l'itération ne fait que remplacer un problème qu'on taperait à la main comme dans la séquence précédente, mais permet d'aller plus vite. Il faut donc ne pas paniquer lorsque l'on voit les itérations un peu partout, et se dire qu'en fait, cela ne fait que recréer un problème qui aurait pu être posé à la main, mais que il y a tellement de relations en jeu, qu'il faut bien utiliser les itérations pour résoudre le problème, pour aller plus vite.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2-A. On Crée un dictionnaire des variables de décision automatiquement, en itérant.\n",
    "\n",
    "Afin de ne pas avoir à taper le code imbuvable de la partie précédente et que tout soit fait automatiquement.\n",
    "On tape ce code qui va nous mettre à disposition toutes les relations possibles entre les fournisseurs et les dépots."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " La méthode de l'indien:\n",
      "[relation_('Fournisseur_A',_'Depot_A'), relation_('Fournisseur_A',_'Depot_B'), relation_('Fournisseur_A',_'Depot_C'), relation_('Fournisseur_A',_'Depot_D'), relation_('Fournisseur_B',_'Depot_A'), relation_('Fournisseur_B',_'Depot_B'), relation_('Fournisseur_B',_'Depot_C'), relation_('Fournisseur_B',_'Depot_D'), relation_('Fournisseur_C',_'Depot_A'), relation_('Fournisseur_C',_'Depot_B')]\n",
      " La méthode de l'auteur de Python Pulp:\n",
      "{'Fournisseur_A': {'Depot_A': Relations_Fournisseur_A_Depot_A, 'Depot_B': Relations_Fournisseur_A_Depot_B, 'Depot_C': Relations_Fournisseur_A_Depot_C, 'Depot_D': Relations_Fournisseur_A_Depot_D}, 'Fournisseur_B': {'Depot_A': Relations_Fournisseur_B_Depot_A, 'Depot_B': Relations_Fournisseur_B_Depot_B, 'Depot_C': Relations_Fournisseur_B_Depot_C, 'Depot_D': Relations_Fournisseur_B_Depot_D}, 'Fournisseur_C': {'Depot_A': Relations_Fournisseur_C_Depot_A, 'Depot_B': Relations_Fournisseur_C_Depot_B, 'Depot_C': Relations_Fournisseur_C_Depot_C, 'Depot_D': Relations_Fournisseur_C_Depot_D}, 'Fournisseur_D': {'Depot_A': Relations_Fournisseur_D_Depot_A, 'Depot_B': Relations_Fournisseur_D_Depot_B, 'Depot_C': Relations_Fournisseur_D_Depot_C, 'Depot_D': Relations_Fournisseur_D_Depot_D}}\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "# -----------------------------------\n",
    "# Type du problème\n",
    "# -----------------------------------\n",
    "model = LpProblem(\"minimiser_couts\", LpMinimize)\n",
    "\n",
    "\n",
    "# -----------------------------------\n",
    "# Variables de décision\n",
    "# -----------------------------------\n",
    "\n",
    "# On crée les variables de décisions\n",
    "# C'est chaque relation possible entre les fournisseurs et les dépots\n",
    "# On compte s'en servir ensuite parce que si une relation est choisie, la variable\n",
    "# de décision prendra la valeur de 1, mais si elle ne l'est pas, elle sera à 0\n",
    "# Elle sera choisie si elle minimise le résultat final.\n",
    "\n",
    "# J'ai répéré 2 techniques différentes, que l'on va voir ici :\n",
    "\n",
    "\n",
    "\n",
    "# --------------  OPTION 1 , de l'auteur de Python PULP, Stuart Mitchell\n",
    "relations = LpVariable.dicts(\"Relations\", (fournisseurs , depots), 0, None, LpBinary)\n",
    "\n",
    "print(\" La méthode de l'auteur de Python Pulp, Stuart Mitchell:\")\n",
    "print(relations)\n",
    "\n",
    "# --------------  OPTION 2, d'un auteur Indien, Prathamesh Mohite\n",
    "# je la trouve plus simple, on va voir ensuite comment itérer dessus.\n",
    "var_dict = LpVariable.dicts(\n",
    "    name=\"relation\",\n",
    "    indexs=[(i, j) for i in fournisseurs for j in depots], \n",
    "    lowBound=0,\n",
    "    cat=\"Binary\")\n",
    "\n",
    "print(\" La méthode de Prathamesh Mohite de mon fichier numéro 13 Opt Chimie et pétrole:\")\n",
    "print([var_dict[(i,j)] for i in fournisseurs for j in depots][:10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2-B. On ajoute maintenant la fonction objectif \n",
    "\n",
    "Notre fonction objectif ne vas plus être écrite en dur, mais va itérer sur notre dictionnaire de variables de décision précédemment créé.\n",
    "\n",
    "Je recopie le code intégral pour que cela soies plus facile à comprendre et utilise d'abord le dictionnaire au format de l'auteur de Python Pulp, puis, on va essayer avec le dictionnaire de L'indien qui a l'air plus simple à mettre en place.\n",
    "\n",
    "Tout d'abord, la technique de Stuart Mitchell, qui a créé Python Pulp :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<bound method LpProblem.writeLP of minimiser_couts:\n",
      "MINIMIZE\n",
      "350*Relations_Fournisseur_A_Depot_A + 450*Relations_Fournisseur_A_Depot_B + 300*Relations_Fournisseur_A_Depot_C + 250*Relations_Fournisseur_A_Depot_D + 450*Relations_Fournisseur_B_Depot_A + 390*Relations_Fournisseur_B_Depot_B + 250*Relations_Fournisseur_B_Depot_C + 268*Relations_Fournisseur_B_Depot_D + 600*Relations_Fournisseur_C_Depot_A + 395*Relations_Fournisseur_C_Depot_B + 420*Relations_Fournisseur_C_Depot_C + 290*Relations_Fournisseur_C_Depot_D + 385*Relations_Fournisseur_D_Depot_A + 700*Relations_Fournisseur_D_Depot_B + 290*Relations_Fournisseur_D_Depot_C + 320*Relations_Fournisseur_D_Depot_D + 0\n",
      "VARIABLES\n",
      "0 <= Relations_Fournisseur_A_Depot_A <= 1 Integer\n",
      "0 <= Relations_Fournisseur_A_Depot_B <= 1 Integer\n",
      "0 <= Relations_Fournisseur_A_Depot_C <= 1 Integer\n",
      "0 <= Relations_Fournisseur_A_Depot_D <= 1 Integer\n",
      "0 <= Relations_Fournisseur_B_Depot_A <= 1 Integer\n",
      "0 <= Relations_Fournisseur_B_Depot_B <= 1 Integer\n",
      "0 <= Relations_Fournisseur_B_Depot_C <= 1 Integer\n",
      "0 <= Relations_Fournisseur_B_Depot_D <= 1 Integer\n",
      "0 <= Relations_Fournisseur_C_Depot_A <= 1 Integer\n",
      "0 <= Relations_Fournisseur_C_Depot_B <= 1 Integer\n",
      "0 <= Relations_Fournisseur_C_Depot_C <= 1 Integer\n",
      "0 <= Relations_Fournisseur_C_Depot_D <= 1 Integer\n",
      "0 <= Relations_Fournisseur_D_Depot_A <= 1 Integer\n",
      "0 <= Relations_Fournisseur_D_Depot_B <= 1 Integer\n",
      "0 <= Relations_Fournisseur_D_Depot_C <= 1 Integer\n",
      "0 <= Relations_Fournisseur_D_Depot_D <= 1 Integer\n",
      ">\n"
     ]
    }
   ],
   "source": [
    "# -----------------------------------\n",
    "# Type du problème\n",
    "# -----------------------------------\n",
    "mon_modele = LpProblem(\"minimiser_couts\", LpMinimize)\n",
    "\n",
    "# -----------------------------------\n",
    "# Nos données\n",
    "# -----------------------------------\n",
    "\n",
    "# On commence par créer nos données\n",
    "\n",
    "fournisseurs = ['Fournisseur_A','Fournisseur_B','Fournisseur_C','Fournisseur_D']\n",
    "depots = ['Depot_A','Depot_B','Depot_C','Depot_D']\n",
    "couts = [  \n",
    "\n",
    "# dépots   # A    B    C    D  \n",
    "            [350, 450, 300, 250],       # A   fournisseurs\n",
    "            [450, 390, 250, 268],       # B\n",
    "            [600, 395, 420, 290],       # C\n",
    "            [385, 700, 290, 320],       # D\n",
    "]\n",
    "\n",
    "# Créer une liste de toutes les relations possibles\n",
    "# Ca va ensuite nous servir à itérer dessus dans les fonctions objectifs et les contraintes\n",
    "liste_relations = [(w, b) for w in fournisseurs  for b in depots]\n",
    "\n",
    "# Créer un dictionnaire des coûts de chaque relations\n",
    "dictionnaire_couts = makeDict([fournisseurs,depots], couts, 0)\n",
    "\n",
    "# -----------------------------------\n",
    "# Variables de décision\n",
    "# -----------------------------------\n",
    "\n",
    "# Créer un dictionnaire de toutes les relations possibles entre les fournisseurs et les dépots\n",
    "# Attention , cette fois ci ce n'est pas une liste, mais bel et bien des variables de décision.\n",
    "# Ici, c'est la méthode de l'auteur de Python Pulp.\n",
    "\n",
    "relations = LpVariable.dicts(\"Relations\", (fournisseurs , depots), 0, None, LpBinary)\n",
    "\n",
    "# -----------------------------------\n",
    "# Fonction objectif.\n",
    "# -----------------------------------\n",
    "\n",
    "# On crée désormais la fonction objectif de minimisation de coûts, en itérant plutôt qu'en dur.\n",
    "mon_modele += lpSum([dictionnaire_couts[w][b]  * relations[w][b]  for (w, b) in liste_relations])\n",
    "\n",
    "# La ligne précédente équivaut à cette ligne, écrite en dur , en fait, cela la recrée dynamiquement parlant: \n",
    "# La ligne précédente parait impressionnante, mais en réalité, on ne fait qu'itérer sur des tableaux en même temps\n",
    "# model += (350 * FADA +  450 * FADB + 300 * FADC + 250 * FADD \n",
    "#           + 450 * FBDA + 390 * FBDB + 250 * FBDC + 268 * FBDD + \n",
    "#           600 *  FCDA + 395 * FCDB + 420 * FCDC + 290 * FCDD + \n",
    "#           385 * FDDA + 700 * FDDB + 290 * FDDC + 320 * FDDD)\n",
    "\n",
    "# On vérifie la similarité des fonction objectifs en imprimant le modèle :\n",
    "# On vérifie donc bien que l'itération est la même qu'en tapant en dur la fonction objectif\n",
    "print(mon_modele.writeLP)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2-C : On crée désormais les contraintes en itérant\n",
    "\n",
    "On crée donc les contraintes en itérant, plutôt qu'en les tapant en dur dans le code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code à venir !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. Exemple 2 - L'auteur du solveur Python Pulp en action .\n",
    "\n",
    "\n",
    "Dans cet exemple, on voit que l'auteur de Python Pulp crée les variables de décision en associant 2 tableaux : les fournisseurs et les clients.\n",
    "\n",
    "Ca permet de créer toutes les solutions possibles à l'aide du dictionnaire de variables de décision.\n",
    "\n",
    "On s'en sert, après , pendant l'optimisation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Statut: Optimal\n",
      "Cout total minimisé =  17.0\n",
      "Choix de la route : Route_A_1 = 1.0\n",
      "Choix de la route : Route_A_2 = 1.0\n",
      "Choix de la route : Route_A_3 = 1.0\n",
      "Choix de la route : Route_A_4 = 1.0\n",
      "Choix de la route : Route_B_5 = 1.0\n"
     ]
    }
   ],
   "source": [
    "import pulp as p\n",
    "\n",
    "# Variables de décision\n",
    "fournisseurs = ['A','B']\n",
    "clients = ['1','2','3','4','5']\n",
    "costs = [  \n",
    "# clients   # 1  2  3  4  5\n",
    "                [3, 1, 3, 2,9],      # A   fournisseurs\n",
    "                [25, 15, 32, 22,8],  # B\n",
    "]\n",
    "\n",
    "# C'est un problème de minimisation\n",
    "Problem = p.LpProblem('optimisation_transport',p.LpMinimize)\n",
    "\n",
    "# Créer une liste de toutes les routes possibles\n",
    "Routes = [(w, b) for w in fournisseurs  for b in clients]\n",
    "\n",
    "# Créer un dictionnaire de variables de décisions des routes\n",
    "vars = p.LpVariable.dicts(\"Route\", (fournisseurs , clients), 0, None, p.LpBinary)\n",
    "\n",
    "# Créer un dictionnaire des coûts de chaque routes\n",
    "cost = p.makeDict([fournisseurs,clients], costs, 0)\n",
    "\n",
    "# Fonction objectif\n",
    "Problem += p.lpSum([cost[w][b]  * vars[w][b]  for (w, b) in Routes])\n",
    "\n",
    "# Contrainte\n",
    "Problem += (p.lpSum([ vars[w][b]  for (w, b) in Routes]) >= 5 , \"minimum_de_5_routes\")\n",
    "\n",
    "# On résouds\n",
    "Problem.solve()\n",
    " \n",
    "# On imprime le résultat\n",
    "print('Statut:', p.LpStatus[Problem.status])\n",
    "print('Cout total minimisé = ', p.value(Problem.objective))\n",
    " \n",
    "for i in Problem.variables():\n",
    "    if i.varValue > 0:\n",
    "        print('Choix de la route :',i.name, '=', i.varValue)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La syntaxe des problèmes linéaire peut être organisée différemment selon les auteurs des programmes, voici l'exemple de la production agrégée de Aaon Stubberfield ou il associe aussi des tableaux pour créer des variables de décision, mais de façon différente que le premier exemple .\n",
    "\n",
    "D'autant plus qu'un code est toujours l'application d'un modèle mathématique écrit, mais là, cela devient difficile, il faut s'habituer et prendre le temps de lire et de comprendre. On est censé savoir faire le va et vient entre le modèle mathématique et le code, et vice-versa.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{('A', 0): prod_('A',_0), ('A', 1): prod_('A',_1), ('A', 2): prod_('A',_2), ('B', 0): prod_('B',_0), ('B', 1): prod_('B',_1), ('B', 2): prod_('B',_2)}\n",
      "prod_('A',_0) = 5.0\n",
      "prod_('A',_1) = 0.0\n",
      "prod_('A',_2) = 0.0\n",
      "prod_('B',_0) = 8.0\n",
      "prod_('B',_1) = 7.0\n",
      "prod_('B',_2) = 6.0\n",
      "Coût total =  422.0\n"
     ]
    }
   ],
   "source": [
    "from pulp import *\n",
    "demand = {'A':[5,0,0],'B':[8,7,6]}\n",
    "costs = {'A':[20,17,18],'B':[15,16,15]}\n",
    "\n",
    "# On crée le problème\n",
    "model = LpProblem(\"Aggregate_Production_Planning\",LpMinimize)\n",
    "\n",
    "# On définit les variables\n",
    "time = [0, 1, 2]\n",
    "prod = ['A','B']\n",
    "\n",
    "# On crée un dictionnaire de toutes les variables de décision de productions possibles et leur temps\n",
    "#### C'est là que l'on crée des variables de décision en associant les 2 tableaux.***\n",
    "X = LpVariable.dicts(\"prod\", [(p, t) for p in prod for t in time],lowBound=0, cat=\"Integer\")\n",
    "# On regarde l'association créee :\n",
    "print(X)\n",
    "\n",
    "# On crée la fonction objectif : minimiser les coûts\n",
    "model += lpSum([costs[p][t] * X[(p, t)] for p in prod for t in time])\n",
    "\n",
    "# On définit la contrainte que la production >= demande\n",
    "for p in prod:\n",
    "    for t in time:\n",
    "        model += X[(p, t)] >= demand[p][t] \n",
    "\n",
    "# Résoudre\n",
    "model.solve()\n",
    "\n",
    "# On imprime les variables qui ont leur valeur optimisées\n",
    "for v in model.variables():\n",
    "    print(v.name, \"=\", v.varValue)\n",
    "    \n",
    "# La valeur de la fonction objective optimisée est imprimée à l'écran\n",
    "print(\"Coût total = \", value(model.objective))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. <b>Utiliser une matrice dans les contraintes</b>\n",
    "\n",
    "Parfois, des matrices sont utiles pour associer par exemple deux modèles de données par un caractère particulier .\n",
    "Exemple, j'ai 4 développeurs, et 5 langages qu'il pratiquent ou pas, on peut résumer cet état de fait par une matrice aux valeurs binaires.\n",
    "\n",
    "Voici un exemple de code Python Pulp mettant en jeu une matrice.\n",
    "\n",
    "Pour plus de détails, on la retrouve dans mon fichier 03, optimisation réseaux, Partie \" Sélection d'employés par couverture minimale\".\n",
    "En d'autres termes, cela permet d'employer le minimum de personnes tout en couvrant tous les langages nécessaires au projet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Lien entre les index \n",
      "0 COLLIN\n",
      "1 BOB\n",
      "2 ALICE\n",
      "3 DAVE\n",
      "-------------Résultat----------------\n",
      "nombre d employés minimisé =  2.0\n",
      "Selection de l employé: EMPLOYE_ALICE = 0.0\n",
      "Selection de l employé: EMPLOYE_BOB = 0.0\n",
      "Selection de l employé: EMPLOYE_COLLIN = 1.0\n",
      "Selection de l employé: EMPLOYE_DAVE = 1.0\n"
     ]
    }
   ],
   "source": [
    "\n",
    "from pulp import *\n",
    " \n",
    "# les variables de décision sont les employés\n",
    "employes=[\"COLLIN\",\"BOB\",\"ALICE\",\"DAVE\"]\n",
    "langages=[\"PYTHON\",\"RUBY\",\"C++\",\"JAVA\",\"C\"]\n",
    "\n",
    "# Matrice des aptitudes\n",
    "           # COLLIN , BOB, ALICE, DAVE\n",
    "aptitudes = [[1,0,0,0], #python\n",
    "             [1,0,0,0], # Ruby\n",
    "             [1,1,1,0], # C++\n",
    "             [0,1,0,1], # Java\n",
    "             [0,0,1,1] # C\n",
    "             ]\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# On définit votre problème de minimisation\n",
    "Problem = LpProblem('couverture_minimale_dEmployes',LpMinimize)\n",
    "\n",
    "# A la place d'écrire en dur les variables de décision, on laisse Pulp les créér automatiquement\n",
    "# à l'aide du tableau employes.\n",
    "vars = LpVariable.dicts(\"EMPLOYE\", employes, 0, None, LpBinary)\n",
    "\n",
    "# On créée la fonction objectif qui est la même que celle écrite en dur\n",
    "Problem += lpSum(vars[i] for i in employes)\n",
    "\n",
    "# Pour les contraintes, on utilise énumérate \n",
    "# pour faire la liaison entre les indices de type nombre entier(idx) et\n",
    "# les indices de type STRING ( Les noms des employés)\n",
    "\n",
    "# On les affiche pour le fun\n",
    "print (\" Lien entre les index \")\n",
    "for idx, x in enumerate(employes):\n",
    "    print(idx, x)\n",
    "\n",
    "# On créée la contrainte en une seule ligne\n",
    "for j in aptitudes:# Pour chaque ligne de la matrice aptitudes\n",
    "    Problem += lpSum(j[idx] * vars[i] for idx,i in enumerate(employes)) >= 1 \n",
    "\n",
    "# La contrainte précédente veut dire : \n",
    "# Multiplie la valeur de l'index  de la ligne de la matrice par la variable de décision du même rang\n",
    "# et ça doit être supérieur ou égal à 1. et cela pour chaque ligne de la matrice.\n",
    "\n",
    "\n",
    "print(\"-------------Résultat----------------\")\n",
    "# On résouds le pb, et on peut choisir le solveur entre les parenthèses\n",
    "Problem.solve()\n",
    "\n",
    "print('nombre d employés minimisé = ', value(Problem.objective))\n",
    " \n",
    "for i in Problem.variables():\n",
    "    print('Selection de l employé:',i.name, '=', i.varValue)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6. Itérer avec Python Gekko , le  solveur non  linéaire.\n",
    "\n",
    "C'est différent d'avec Pulp .\n",
    "\n",
    "Lien : https://stackoverflow.com/questions/64542594/how-could-constraints-be-dynamically-constructed-in-gekko\n",
    "\n",
    "Voici un exemple de réduction de coût avec une itération dans la contrainte de temps de travail :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x1 3.9999999998\n",
      "x2 1.8225924919e-09\n",
      "Cost: 400.00000021\n"
     ]
    }
   ],
   "source": [
    "from gekko import GEKKO\n",
    "\n",
    "# stored as list\n",
    "my_vars = ['x1','x2']\n",
    "# stored as dictionaries\n",
    "Cost = {'x1':100,'x2':125}\n",
    "Min = {'x1':0,'x2':0}\n",
    "Max = {'x1':70,'x2':40}\n",
    "Work = {'x1':50,'x2':50}\n",
    "\n",
    "LP = GEKKO(remote=False)\n",
    "\n",
    "\n",
    "va = LP.Array(LP.Var, (len(my_vars)))  # array\n",
    "\n",
    "# Le truc qui diffère , en fait il crée un dictionnaire à l'aide du tableau créé juste avant :\n",
    "vd = {}                                # dictionary\n",
    "for i,xi in enumerate(my_vars):\n",
    "    vd[xi] = va[i]\n",
    "    vd[xi].lower = Min[xi]\n",
    "    vd[xi].upper = Max[xi]\n",
    "\n",
    "\n",
    "# Fonction coût\n",
    "LP.Minimize(LP.sum([Cost[xi]*vd[xi] for xi in my_vars])) \n",
    "\n",
    "\n",
    "# On voit que l'itération fonctionne !\n",
    "LP.Equation(LP.sum([Work[xi]*vd[xi] for xi in my_vars])>=200)\n",
    "\n",
    "\n",
    "LP.solve(disp=False)\n",
    "\n",
    "# On affiche le résultat\n",
    "for xi in my_vars:\n",
    "    print(xi,vd[xi].value[0])\n",
    "print ('Cost: ' + str(LP.options.OBJFCNVAL))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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.8.0"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}