LP02_simplex.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "btS1bfjiNb7F"
   },
   "source": [
    "# <center>The simplex algorithm</center>\n",
    "### <center>Alfred Galichon (NYU & Sciences Po)</center>\n",
    "## <center>'math+econ+code' masterclass series</center>\n",
    "#### <center>With python code examples</center>\n",
    "© 2018–2023 by Alfred Galichon with contributions by Antoine Jacquet. Past and present support from NSF grant DMS-1716489, ERC grant CoG-866274 are acknowledged, as well as inputs from contributors listed [here](http://www.math-econ-code.org/team).\n",
    "\n",
    "**If you reuse material from this masterclass, please cite as:**<br>\n",
    "Alfred Galichon, 'math+econ+code' masterclass series. https://www.math-econ-code.org/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "NvpCAQSJNb7K"
   },
   "source": [
    "## Linear programming: the simplex algorithm\n",
    "\n",
    "### Learning objectives\n",
    "\n",
    "* The simplex algorithm\n",
    "\n",
    "### References\n",
    "\n",
    "* Vanderbei (1996). *Linear programming.* Springer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "v59RjxfwP1iC"
   },
   "source": [
    "### Principle\n",
    "\n",
    "The simplex algorithm was developed by G. B. Dantzig in 1947 as a way to solve linear programming problems of the canonical form\n",
    "\n",
    "\\begin{align}\n",
    "\\max_{x\\in\\mathbb{R}_{+}^{n}}  & ~ c^{\\top} x \\\\\n",
    "\\text{s.t.} & ~ Ax \\leq b\n",
    "\\end{align}\n",
    "\n",
    "where $c \\in \\mathbb{R}^{n}$, $b \\in \\mathbb{R}^{m}$, and $A$ is a $m\\times n$ matrix.\n",
    "\n",
    "The idea of the algorithm is to start from a simple feasible point called a *basic feasible solution*, and then to iteratively identify directions along which the objective function increases."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XTwuussNv7T4"
   },
   "source": [
    "Let's begin by loading the usual packages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "JyB3iJlIMqBh"
   },
   "outputs": [],
   "source": [
    "#!pip install gurobipy\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import scipy.sparse as spr\n",
    "import gurobipy as grb\n",
    "import sympy\n",
    "from sympy.solvers import solve\n",
    "from sympy import *\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def round_expr(expr, num_digits):\n",
    "    return expr.xreplace({n : round(n, num_digits) for n in expr.atoms(Number)})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tdbclc58UxRW"
   },
   "source": [
    "## The simplex algorithm with an example\n",
    "\n",
    "Consider the linear programming problem:\n",
    "\n",
    "\\begin{align*}\n",
    "\\max_{x_1, x_2 \\geq 0}  & ~ x_1 + x_2 \\\\\n",
    "\\text{s.t.} & ~ 2 x_1 + x_2 \\leq 2 \\\\\n",
    "            & ~ x_1 + 2 x_2 \\leq 2.\n",
    "\\end{align*}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "C7g2QwXL8v70"
   },
   "source": [
    "Before even starting the algorithm, we first need to transform this linear program into one in *standard form*, that is, to replace inequality constraints with equality ones. To achieve this, we introduce slack variables $z_i$ to rewrite the problem as\n",
    "\n",
    "\\begin{align*}\n",
    "\\max_{x_1, x_2, z_1, z_2 \\geq 0}  & ~ x_1 + x_2 \\\\\n",
    "\\text{s.t.} & ~ z_1 = 2 - 2 x_1 - x_2 \\\\\n",
    "            & ~ z_2 = 2 - x_1 - 2 x_2 .\n",
    "\\end{align*}\n",
    "\n",
    "The variables $z_i$ are called *basic variables*, and the variables $x_j$ are called *nonbasic variables*.\n",
    "\n",
    "Linear programming problems in this standard form can be summarized by a structure called a *tableau*. We begin by defining a `Tableau` class in Python to handle this type of data.  The expressions of the objective and of the basic variables as a function of the nonbasic ones are encoded into a *dictionary*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "0XnmgEk58vB5"
   },
   "outputs": [],
   "source": [
    "class Tableau():\n",
    "    def __init__(self, names_basic, names_nonbasic, A_i_j, b_i, c_j): # z = d - A @ x\n",
    "        self.A_i_j,self.b_i,self.c_j = A_i_j,b_i,c_j\n",
    "        self.nonbasic = list(symbols(names_nonbasic))\n",
    "        self.base = { Symbol('obj') : c_j @ self.nonbasic }\n",
    "        self.base.update( { list(symbols(names_basic))[i]: b_i[i]  - (A_i_j @ self.nonbasic)[i] for i in range(len(b_i))} )\n",
    "\n",
    "    def variables(self):\n",
    "        return( list(self.base.keys())[1:] + self.nonbasic)\n",
    "\n",
    "    def display(self):\n",
    "        print('-------------------------- \\nObjective and constraints:')\n",
    "        for i in self.base:\n",
    "            print(i,' = ' ,round_expr(self.base[i],2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "W_8CJG1l8t7u"
   },
   "source": [
    "We then define the tableau corresponding to our example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Bk4oGpt69TI9",
    "outputId": "56c0d9a9-d705-40df-bbbe-f307359f1a85"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------- \n",
      "Objective and constraints:\n",
      "obj  =  x_1 + x_2\n",
      "z_1  =  -2*x_1 - x_2 + 2\n",
      "z_2  =  -x_1 - 2*x_2 + 2\n"
     ]
    }
   ],
   "source": [
    "example_tableau = Tableau(names_basic = ['z_1', 'z_2'],\n",
    "                          names_nonbasic = ['x_1', 'x_2'],\n",
    "                          A_i_j = np.array([[2, 1], [1, 2]]),\n",
    "                          b_i = [2,2],\n",
    "                          c_j = np.array([1,1]))\n",
    "\n",
    "example_tableau.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "18VVg1KnOgp5"
   },
   "source": [
    "### Description of the algorithm\n",
    "\n",
    "Let's take a step-by-step approach to understand the simplex algorithm.\n",
    "Along the way, we will also code these steps.\n",
    "\n",
    "#### **Step 1: Initialize.**\n",
    "Our first step is to establish a (feasible) starting point. There is an obvious one which consists in setting $x_1 = x_2 = 0$ and $z_1 = 2$, $z_2 = 2$. This starting point is called a *basic feasible solution* because it is zero outside of the basic variables. The value of the objective at this solution is $0$.\n",
    "\n",
    "We create a method which computes the basic feasible solution associated with a tableau, as well as the value of the objective at this solution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "CzIHclYOOgp6",
    "outputId": "595ce79d-8b88-40c7-87b7-9f107414c563"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "obj = 0.0\n",
      "z_1 = 2.0\n",
      "z_2 = 2.0\n"
     ]
    }
   ],
   "source": [
    "def Tableau_solution(self, verbose=0):\n",
    "    solution = {}\n",
    "    for var in self.base:\n",
    "        solution[var] = float(self.base[var].subs([(variable,0) for variable in self.nonbasic]))\n",
    "        if verbose > 0: print(str(var) + ' = ' + str(solution[var]))\n",
    "    for var in self.nonbasic:\n",
    "        solution[var] = 0.0\n",
    "        if verbose > 1: print(str(var) + ' = ' + str(solution[var]))\n",
    "    return solution\n",
    "\n",
    "Tableau.solution = Tableau_solution\n",
    "\n",
    "current_solution = example_tableau.solution(verbose=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "A9AV61IMOgp6"
   },
   "source": [
    "We plot the feasible region and our initial solution using:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 436
    },
    "id": "iR-D9joP6NXb",
    "outputId": "bc371114-3b54-477e-aadc-66e1b2ded3fb"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def Tableau_plot_path_so_far(self, the_path, legend=True):\n",
    "    if self.A_i_j.shape[1] != 2:\n",
    "        print('Can\\'t plot the solution in 2D, the number of primal variables differs from two.')\n",
    "        return()\n",
    "\n",
    "    x1max = min(x for x in self.b_i / self.A_i_j[:,0] if x >= 0)\n",
    "    x2max = min(x for x in self.b_i / self.A_i_j[:,1] if x >= 0)\n",
    "    x1, x2 = np.meshgrid(np.linspace(-.2*x1max, 1.4*x1max, 400), np.linspace(-.2*x2max, 1.4*x2max, 400))\n",
    "    feasible_region = (x1 >= 0) & (x2 >= 0)\n",
    "    for i in range(len(self.b_i)) :\n",
    "        feasible_region = feasible_region & (self.A_i_j[i,0] * x1 + self.A_i_j[i,1] * x2 <= self.b_i[i])\n",
    "    fig, ax = plt.subplots(figsize=(5, 5))\n",
    "    plt.contourf(x1, x2, np.where(feasible_region, self.c_j[0]*x1+self.c_j[1]*x2, np.nan), 50, alpha = 0.5, cmap='gray_r', levels=30)\n",
    "    for i in range(len(self.b_i)):\n",
    "        if not self.A_i_j[i,1] == 0:\n",
    "            ax.plot(x1[0, :], self.b_i[i]/self.A_i_j[i,1] - self.A_i_j[i,0]/self.A_i_j[i,1]*x1[0, :], label='z'+str(i+1)+' = 0')\n",
    "        else:\n",
    "            ax.axvline(self.b_i[i]/self.A_i_j[i,0], label='z'+str(i+1)+' = 0')\n",
    "    ax.plot([a for (a,_) in the_path], [b for (_,b) in the_path], 'r--', label='Algorithm path')\n",
    "    ax.scatter([a for (a,_) in the_path], [b for (_,b) in the_path], color='red')\n",
    "    ax.set_xlim(-.2*x1max, 1.4*x1max), ax.set_ylim(-.2*x2max, 1.4*x2max)\n",
    "    ax.set_xlabel('x1'), ax.set_ylabel('x2')\n",
    "    ax.spines[ 'left' ].set_position('zero'), ax.spines['bottom'].set_position('zero')\n",
    "    ax.spines['right'].set_color('none'), ax.spines['top'].set_color('none')\n",
    "    if legend: ax.legend(loc='upper right')\n",
    "    plt.show()\n",
    "\n",
    "Tableau.plot_path_so_far = Tableau_plot_path_so_far\n",
    "\n",
    "the_path_so_far = [(current_solution[symbols('x_1')], current_solution[symbols('x_2')])]\n",
    "example_tableau.plot_path_so_far(the_path_so_far)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "in7Rbjge88k7"
   },
   "source": [
    "#### **Step 2: Entering variable.**\n",
    "We want to select a nonbasic variable in order to increase our objective. This variable is called *entering variable*. Any nonbasic variable whose coefficient in the objective is therefore a potential entering variable.\n",
    "\n",
    "There are several ways to choose the entering variable. One possibility is to choose the variable that has the highest coefficient in the objective.\n",
    "\n",
    "Another method is to follow *Bland's rule*, i.e. to select the first variable (in the alphabetical order) which has a positive coefficient in the objective. This method is the safest as it prevents the algorithm from cycling in some pathological cases, and therefore we will implement it here.\n",
    "\n",
    "Recall that the objective in our example is $x_1 + x_2$, and therefore Bland's rule selects $x_1$ as the entering variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 38
    },
    "id": "0r30XChw1OaL",
    "outputId": "c8f56e1f-5717-4431-d663-9530f97d7a1a"
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x_{1}$"
      ],
      "text/plain": [
       "x_1"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def Tableau_determine_entering(self):\n",
    "    self.nonbasic.sort(key=str) # Bland's rule\n",
    "    for entering_var in self.nonbasic:\n",
    "        if diff(self.base[Symbol('obj')],entering_var)>0 :\n",
    "            return entering_var\n",
    "    return None # If no entering variable found, None returned\n",
    "\n",
    "Tableau.determine_entering = Tableau_determine_entering\n",
    "\n",
    "entering_var = example_tableau.determine_entering()\n",
    "entering_var"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "INYg4--r1I3j"
   },
   "source": [
    "#### **Step 3: Departing variable.**\n",
    "When $x_1$ enters, we will increase $x_1$ until we hit one of the constraints $z_i \\geq 0$. Recall:\n",
    "\n",
    "\\begin{align*}\n",
    "z_1 &= 2 - 2 x_1 - x_2 \\\\\n",
    "z_2 &= 2 - x_1 - 2 x_2.\n",
    "\\end{align*}\n",
    "\n",
    "Note that we keep $x_2=0$ along the way. Here it is the constraint $z_1 \\geq 0$ which will hit first (for $x_1 = 1$). Therefore we choose $z_1$ as our *departing variable*.\n",
    "\n",
    "In general, if $j^\\star$ is the entering variable, the formula for determining the departing variable is\n",
    "\n",
    "$i^\\star = \\arg\\min_{\\, i} \\left\\{ \\frac {b_i} {A_{i \\, j^\\star}} : A_{i \\, j^\\star} > 0  \\right\\}$.\n",
    "\n",
    "We code this into:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 38
    },
    "id": "g2oygb0o6JEd",
    "outputId": "da98dd74-5c22-40c0-9699-c26cda27de27"
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle z_{1}$"
      ],
      "text/plain": [
       "z_1"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def Tableau_determine_departing(self,entering_var):\n",
    "  runmin = float('inf')\n",
    "  departing_var = None\n",
    "  for var in self.base.keys() - {Symbol('obj')}:\n",
    "        the_expr_list = solve(self.base[var] - var,entering_var)\n",
    "        if the_expr_list: # if one can invert the previous expression\n",
    "            the_expr = the_expr_list[0] # express entering variable as a function of the other ones:\n",
    "            val_entering_var = the_expr.subs([ (variable,0) for variable in [var]+self.nonbasic])\n",
    "            if (val_entering_var >= 0) & (val_entering_var < runmin) :\n",
    "              runmin,departing_var = val_entering_var, var\n",
    "  return departing_var # if no variable is found, None returned\n",
    "\n",
    "Tableau.determine_departing = Tableau_determine_departing\n",
    "\n",
    "departing_var = example_tableau.determine_departing(entering_var)\n",
    "departing_var"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3ZmiyS9e6KgT"
   },
   "source": [
    "#### **Step 4: Updating.**\n",
    "We reformulate our problem with our new basis $(x_1, z_2)$. We use the constraint associated with our departing variable $z_1$ as a pivot to eliminate the entering variable $x_1$ from the other equalities:\n",
    "\n",
    "\\begin{matrix}\n",
    "&\\tfrac{1}{2}z_1  &       &~+ x_1 &+~ \\tfrac{1}{2} x_2 &= 1 \\\\\n",
    "&-\\tfrac{1}{2}z_1 &+~ z_2 &       &+~ \\tfrac{3}{2} x_2 &= 1\n",
    "\\end{matrix}\n",
    "\n",
    "and we rewrite the objective as a function of the new nonbasic variables:\n",
    "\n",
    "\\begin{align*}\n",
    "x_1 + x_2\n",
    "&= \\left(1 - \\tfrac{1}{2}z_1 - \\tfrac{1}{2}x_2\\right) + x_2 \\\\\n",
    "&= 1 + \\tfrac{1}{2}x_2 - \\tfrac{1}{2}z_1.\n",
    "\\end{align*}\n",
    "\n",
    "In general, once the entering variable $j^\\star$ and the departing variable $i^\\star$ have been determined, we need to update our set of nonbasic variables by removing $i^\\star$ from it and adding $j^\\star$. We also need to update our dictionary with the expression of our entering variable,\n",
    "\n",
    "$x_{j^\\star}\n",
    "= \\frac {b_{i^\\star}} {A_{i^\\star j^\\star}}\n",
    "- \\sum_{j \\neq j^\\star} \\frac {A_{i^\\star j}} {A_{i^\\star j^\\star}} x_j\n",
    "- \\frac {z_{i^\\star}} {A_{i^\\star j^\\star}}$\n",
    "\n",
    "and substituting out this expression in\n",
    "\n",
    "$z_i = b_i - \\sum_j A_{ij} x_j, \\quad i \\neq i^\\star$\n",
    "\n",
    "yields the expression of the new basic variables as a function of the new nonbasic variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "S6p_H4Vg8j8c",
    "outputId": "9529dd65-5592-43d8-bbb1-73d0c15d0f55"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Entering = x_1; departing = z_1\n",
      "x_1 = -0.5*x_2 - 0.5*z_1 + 1\n",
      "-------------------------- \n",
      "Objective and constraints:\n",
      "obj  =  0.5*x_2 - 0.5*z_1 + 1\n",
      "z_2  =  -1.5*x_2 + 0.5*z_1 + 1\n",
      "x_1  =  -0.5*x_2 - 0.5*z_1 + 1\n"
     ]
    }
   ],
   "source": [
    "def Tableau_pivot(self,entering_var,departing_var, verbose = 0):\n",
    "    expr_entering = solve(self.base[departing_var] - departing_var,entering_var)[0]\n",
    "    for var in self.base:\n",
    "        self.base[var] = self.base[var].subs([(entering_var, expr_entering)])\n",
    "    self.base[entering_var] = expr_entering\n",
    "    del self.base[departing_var]\n",
    "    self.nonbasic.remove(entering_var)\n",
    "    self.nonbasic.append(departing_var)\n",
    "    if verbose > 0:\n",
    "        print('Entering = ' + str( entering_var)+'; departing = '+ str( departing_var))\n",
    "    if verbose > 1:\n",
    "        print(str( entering_var)+' = '+str(round_expr(expr_entering,2)))\n",
    "    return expr_entering\n",
    "\n",
    "Tableau.pivot = Tableau_pivot\n",
    "\n",
    "expr_entering_var = example_tableau.pivot(entering_var,departing_var,verbose = 2)\n",
    "\n",
    "example_tableau.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-iyU4tinYg75"
   },
   "source": [
    "This completes one iteration of the algorithm."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XjDwx93pq43z"
   },
   "source": [
    "### Iterating\n",
    "\n",
    "The transformed program is now:\n",
    "\n",
    "\\begin{align*}\n",
    "\\max_{x_1, x_2, z_1, z_2 \\geq 0}  & ~ 1 + \\tfrac{1}{2}x_2 - \\tfrac{1}{2}z_1 \\\\\n",
    "\\text{s.t.} & ~ x_1 = 1 - \\tfrac{1}{2} x_2 - \\tfrac{1}{2} z_1 \\\\\n",
    "            & ~ z_2 = 1 - \\tfrac{3}{2} x_2 + \\tfrac{1}{2}z_1 .\n",
    "\\end{align*}\n",
    "\n",
    "Our new basic feasible solution is $x_2 = z_1 = 0$ (nonbasic variables) and $x_1 = 1$, $z_2 = 1$ (basic variables). The value of the objective is $1$.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AqFmiHtWDxBW"
   },
   "source": [
    "\n",
    "Let's look at the path that the algorithm took using the graph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 521
    },
    "id": "DbPvkDxRYq8G",
    "outputId": "5ae203b0-6a00-43e2-aecb-eab90747804e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "obj = 1.0\n",
      "z_2 = 1.0\n",
      "x_1 = 1.0\n",
      "x_2 = 0.0\n",
      "z_1 = 0.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "current_solution = example_tableau.solution(verbose=2)\n",
    "the_path_so_far.append((current_solution[symbols('x_1')], current_solution[symbols('x_2')]))\n",
    "example_tableau.plot_path_so_far(the_path_so_far)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IYLPRwSB9dx0"
   },
   "source": [
    "We can now repeat the process on the new program. Since the coefficient of $x_2$ in our new objective is positive, we now choose $x_2$ as an entering variable. In that case, the constraint associated with the basic variable $z_2$ will hit first, so $z_2$ will be our departing variable.\n",
    "\n",
    "The pivot operation yields\n",
    "\n",
    "\\begin{matrix}\n",
    "&\\tfrac{2}{3}z_1  &-~ \\tfrac{1}{3} z_2       &~+ x_1 & &= \\tfrac{2}{3} \\\\\n",
    "&-\\tfrac{1}{3}z_1 &+~ \\tfrac{2}{3} z_2 &       &+~ x_2 &= \\tfrac{2}{3}\n",
    "\\end{matrix}\n",
    "\n",
    "and the new objective is\n",
    "\n",
    "\\begin{align*}\n",
    "1 + \\tfrac{1}{2}x_2 - \\tfrac{1}{2}z_1\n",
    "&= 1 + \\tfrac{1}{2}\\left(\\tfrac{2}{3} + \\tfrac{1}{3}z_1 - \\tfrac{2}{3}z_2\\right) - \\tfrac{1}{2}z_1 \\\\\n",
    "&= \\tfrac{4}{3} - \\tfrac{1}{3}z_1 - \\tfrac{1}{3}z_2.\n",
    "\\end{align*}\n",
    "\n",
    "We encode this second iteration as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 555
    },
    "id": "-RwTfmmlhcFh",
    "outputId": "369478bb-d1e9-4a32-a583-fbbab26426cc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Entering = x_2; departing = z_2\n",
      "x_2 = 0.33*z_1 - 0.67*z_2 + 0.67\n",
      "obj = 1.3333333333333333\n",
      "x_1 = 0.6666666666666666\n",
      "x_2 = 0.6666666666666666\n",
      "z_1 = 0.0\n",
      "z_2 = 0.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "entering_var = example_tableau.determine_entering()\n",
    "departing_var = example_tableau.determine_departing(entering_var)\n",
    "example_tableau.pivot(entering_var, departing_var, verbose=2)\n",
    "\n",
    "current_solution = example_tableau.solution(verbose=2)\n",
    "the_path_so_far.append((current_solution[symbols('x_1')], current_solution[symbols('x_2')]))\n",
    "example_tableau.plot_path_so_far(the_path_so_far)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "q_5eppZSiMXF"
   },
   "source": [
    "Our new basic feasible solution is $z_1 = z_2 = 0$ (nonbasic variables) and $x_1 = \\tfrac{2}{3}$, $x_2 = \\tfrac{2}{3}$ (basic variables). But because the coefficients of the nonbasic variables in the objective are negative, we cannot increase it anymore: the algorithm stops.\n",
    "\n",
    "We verify this with our code, as there is no entering variable anymore."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "yNS_h09LiFj5",
    "outputId": "084442c3-4bbc-4abb-e3ec-1569ee819931"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "print(example_tableau.determine_entering())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ON3ZsdVrlASD"
   },
   "source": [
    "The value of the initial problem is thus $\\tfrac{4}{3}$, and the optimal solution is\n",
    "\n",
    "\\begin{equation}\n",
    "  x_1^* = x_2^* = \\tfrac{2}{3}.\n",
    "\\end{equation}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "od8jJs_t9-Pl"
   },
   "source": [
    "### Geometric interpretation\n",
    "\n",
    "The simplex algorithm has a simple geometric interpretation.\n",
    "\n",
    "The feasible set of the linear programming problem, delimited by its constraints, forms a polygon in $\\mathbb R^2$ (a polyhedron in $\\mathbb R^3$, etc.).\n",
    "\n",
    "We start from one of the corners of this polygon. At each iteration of the algorithm, we move along the edge of the polygon to a neighboring corner, always moving in the direction that most increases the value of the objective function. When it reaches the corner with the highest possible value of the objective function, the algorithm stops, and we have our solution.\n",
    "\n",
    "The simplex algorithm must stop eventually since there are a limited number of corners. Furthermore, it can be shown that if a corner isn't a maximum, then there must be an adjoining edge leading to a higher value of the objective function. This guarantees that the end point of the algorithm is indeed an optimal solution."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "RQiP_qF-Btrb"
   },
   "source": [
    "## Second example\n",
    "\n",
    "Consider a slightly more complex example:\n",
    "\n",
    "\\begin{align*}\n",
    "\\max_{x_1, x_2 \\geq 0}  & ~ 3 x_1 + 2 x_2 \\\\\n",
    "\\text{s.t.} & ~ \\cos\\left(\\tfrac{k}{K}\\tfrac{\\pi}{2}\\right) x_1 + \\sin\\left(\\tfrac{k}{K}\\tfrac{\\pi}{2}\\right) x_2 \\leq 1, \\quad k = 0, \\dots, K.\n",
    "\\end{align*}\n",
    "\n",
    "The constraints actually correspond to $K+1$ tangents to the circle of equation $x_1^2 + x_2^2 = 1$. Therefore, it is as if we were approximating the nonlinear constraint $x_1^2 + x_2^2 \\leq 1$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 895
    },
    "id": "KgQK6cAhBver",
    "outputId": "b10be6b8-ab4e-4f02-c86b-fb090db70e85"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Entering = x_1; departing = z_0\n",
      "Entering = x_2; departing = z_1\n",
      "Entering = z_0; departing = z_2\n",
      "Entering = z_1; departing = z_3\n",
      "Entering = z_2; departing = z_4\n",
      "Optimal solution found.\n",
      "=======================\n",
      "obj = 3.614058558900192\n",
      "z_5 = 0.02462331880972555\n",
      "z_6 = 0.07326364859996945\n",
      "z_7 = 0.14472330302329706\n",
      "z_8 = 0.23724270822681015\n",
      "z_9 = 0.3485437294000968\n",
      "z_10 = 0.47588576601495897\n",
      "x_1 = 0.8552766969767034\n",
      "x_2 = 0.5241142339850411\n",
      "z_0 = 0.14472330302329667\n",
      "z_1 = 0.07326364859996902\n",
      "z_2 = 0.0246233188097251\n",
      "z_3 = 0.0\n",
      "z_4 = 0.0\n",
      "\n",
      "Value = 3.61405855890019\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\alfre\\AppData\\Local\\Temp\\ipykernel_18356\\3480862293.py:6: RuntimeWarning: divide by zero encountered in true_divide\n",
      "  x1max = min(x for x in self.b_i / self.A_i_j[:,0] if x >= 0)\n",
      "C:\\Users\\alfre\\AppData\\Local\\Temp\\ipykernel_18356\\3480862293.py:7: RuntimeWarning: divide by zero encountered in true_divide\n",
      "  x2max = min(x for x in self.b_i / self.A_i_j[:,1] if x >= 0)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "K = 10\n",
    "\n",
    "example_tableau2 = Tableau(names_basic = ['z_'+str(k) for k in range(0,K+1)],\n",
    "                           names_nonbasic = ['x_1', 'x_2'],\n",
    "                           A_i_j = np.array([(float(cos(k/K*pi/2)), float(sin(k/K*pi/2))) for k in range(0, K+1)]),\n",
    "                           b_i = np.ones(K+1),\n",
    "                           c_j = np.array([3,2]))\n",
    "\n",
    "def simplex_loop(self):\n",
    "    entering_var = self.determine_entering()\n",
    "    if entering_var is None:\n",
    "        print('Optimal solution found.\\n=======================')\n",
    "        self.solution(verbose=2)\n",
    "    else:\n",
    "        departing_var = self.determine_departing(entering_var)\n",
    "        if departing_var is None:\n",
    "            print('Unbounded solution.')\n",
    "        else:\n",
    "            expr_entering_var = self.pivot(entering_var,departing_var, verbose=1)\n",
    "            return False # not finished\n",
    "    return True # finished\n",
    "\n",
    "finished = False\n",
    "the_path_so_far = [(example_tableau2.solution()[symbols('x_1')], example_tableau2.solution()[symbols('x_2')])]\n",
    "while not finished:\n",
    "  finished = simplex_loop(example_tableau2)\n",
    "  the_path_so_far.append((example_tableau2.solution()[symbols('x_1')], example_tableau2.solution()[symbols('x_2')]))\n",
    "\n",
    "print('\\nValue = '+str(example_tableau2.base[Symbol('obj')].subs([ (variable,0) for variable in example_tableau2.nonbasic])))\n",
    "\n",
    "example_tableau2.plot_path_so_far(the_path_so_far, legend=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "F82rdD4vCgU9"
   },
   "source": [
    "Our algorithm still works! However you can check that it becomes quite slow for higher values of $K$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dEg6YXOkNb7N"
   },
   "source": [
    "\n",
    "## Application to the diet problem\n",
    "\n",
    "Recall the diet problem:\n",
    "\n",
    "* Assume there are nutrients $i \\in \\{1,\\dots,I\\}$ (calories, protein, calcium, iron, etc.) that matter for a person's health, in such way that the minimum daily intake of nutrient $i$ should be $d_{i}$.\n",
    "\n",
    "* Nutrients do not come as standalone elements, but are combined into various foods. One dollar worth of food $j \\in \\{1,\\dots,J\\}$ yields a quantity $N_{ij}$ of nutrient $i \\in \\{1,\\dots,I\\}$.\n",
    "\n",
    "The problem is to find the diet that achieves the minimal intake of each nutrient for the cheapest price. If $q\\in\\mathbb{R}^{J}$ is a vector such that $q_{j}\\geq0$ is the quantity of food $j$ purchased, the quantity of nutrient $i$ ingested is $\\sum_{j=1}^{J}N_{ij}q_{j}$, and the cost of the diet is $\\sum_{j=1}^{J}q_{j}$. Letting $c_j = 1$ for all $j \\in \\{1,\\dots,n\\}$, the optimal diet is therefore given by\n",
    "\n",
    "\\begin{align*}\n",
    "\\min_{q\\geq 0} & ~ c^{\\top}q \\\\\n",
    "\\text{s.t.} & ~ Nq \\geq d\n",
    "\\end{align*}\n",
    "\n",
    "which has dual\n",
    "\n",
    "\\begin{align*}\n",
    "\\max_{\\pi\\geq0} & ~ d^{\\top}\\pi \\\\\n",
    "\\text{s.t.} & ~ N^{\\top}\\pi \\leq c.\n",
    "\\end{align*}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hyCMGHTnNb7O"
   },
   "source": [
    "We load the data using:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "id": "CDcxAkpDNb7O"
   },
   "outputs": [],
   "source": [
    "thepath = 'https://raw.githubusercontent.com/math-econ-code/mec_optim_2021-01/master/data_mec_optim/lp_stigler-diet/'\n",
    "filename = 'StiglerData1939.txt'\n",
    "thedata = pd.read_csv(thepath + filename, sep='\\t')\n",
    "thedata = thedata.dropna(how = 'all')\n",
    "commodities = (thedata['Commodity'].values)[:-1]\n",
    "allowance = thedata.iloc[-1, 4:].fillna(0).transpose()\n",
    "N_i_j = thedata.iloc[:-1, 4:].fillna(0).transpose().values\n",
    "N_i_j = N_i_j[:5,:7]\n",
    "nbi, nbj = N_i_j.shape\n",
    "c_j = np.ones(nbj)\n",
    "d_i = np.array(allowance)[:nbi]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2thQPwobNb7P"
   },
   "source": [
    "We shall introduce slack variables $s_j \\geq 0$ and rewrite the dual problem in the standard form as:\n",
    "\n",
    "\\begin{align*}\n",
    "\\max_{s_j \\geq 0, \\pi_i \\geq 0} & ~ \\sum_{i} d_{i} \\pi_i \\\\\n",
    "\\text{s.t.} & ~ s_j  + \\sum_{i} N_{ij}\\pi_i= c_j .\n",
    "\\end{align*}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cFzjtEF9Nb7P"
   },
   "source": [
    "We start from the *basic feasible solution*, $\\pi_i = 0$ and $s_j = c_j$. The $J$ variables $s_1,\\dots,s_J$ are the basic variables. The $I$ nonbasic variables, $\\pi_1,\\dots,\\pi_I$, are set to zero.\n",
    "One can express the basic variables as a function of the nonbasic variables as follows:\n",
    "\n",
    "$s_j  = c_j - \\sum_{i} N_{ij}\\pi_i.$\n",
    "\n",
    "The dual objective is also expressed as a function of the nonbasic variables:\n",
    "\n",
    "$\\text{obj}_D = \\sum_{i} d_{i}\\pi_i.$\n",
    "\n",
    "These equalities constitute our *primal dictionary*.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5zpveeeyNb7S"
   },
   "source": [
    "We code this up as a tableau. First, we define the basic dual variables (the $s_j$), and the nonbasic dual variables (the $\\pi_i$) ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "XZbRB6MUNb7S",
    "outputId": "cf924032-a11d-40f4-8bc6-993b3b899714"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[s_0, s_1, s_2, s_3, s_4, s_5, s_6, pi_0, pi_1, pi_2, pi_3, pi_4]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dual_tableau = Tableau(['s_' + str(j) for j in range(nbj)],\n",
    "                      ['pi_' + str(i) for i in range(nbi)],\n",
    "                      N_i_j.T, c_j , d_i)\n",
    "dual_tableau.variables()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gZVxRUPpNb7S"
   },
   "source": [
    "Something similar takes place for the primal problem. We introduce $t_i$ the slack variable associated with the constraint $\\sum_{j} N_{ij}q_j \\geq d_i$, and we obtain the following *primal dictionary*:\n",
    "\n",
    "$t_i  = -d_i + \\sum_{j} N_{ij}q_j.$\n",
    "\n",
    "The primal objective is also expressed as a function of the nonbasic variables:\n",
    "\n",
    "$\\text{obj}_P = \\sum_{j} c_{j}q_j.$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "3Awi3_xTNb7T",
    "outputId": "f3a6aaf3-0b55-45f6-b5e6-ecea2b5c92d4"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[t_0, t_1, t_2, t_3, t_4, q_0, q_1, q_2, q_3, q_4, q_5, q_6]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "primal_tableau = Tableau(['t_' + str(i) for i in range(nbi)],\n",
    "                      ['q_' + str(j) for j in range(nbj)],\n",
    "                      N_i_j, d_i , c_j)\n",
    "primal_tableau.variables()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_DoBzHC0Nb7T"
   },
   "source": [
    "We see that there is a natural correspondence between $\\pi_i$ and $t_i$ on the one hand, and $s_j$ and $q_j$ on the other, which we encode into:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 38
    },
    "id": "4G2a29MNNb7T",
    "outputId": "8f400653-2cc5-4702-eaee-aea592209210"
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle t_{0}$"
      ],
      "text/plain": [
       "t_0"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "primals = {dual:Symbol(str(dual).replace('pi','t').replace('s','q')) for dual in dual_tableau.variables()}\n",
    "primals[Symbol('pi_0')]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cCgdiHdtNb7U"
   },
   "source": [
    "We also see that the nonbasic dual variables correspond to basic primal variables, and basic dual variables to nonbasic primal ones. The basis will change but we shall maintain that property, called *complementary slackness*, throughout."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1-_HMtj_Nb7U"
   },
   "source": [
    "We now look for our entering variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 38
    },
    "id": "kHQixRpeNb7U",
    "outputId": "e17ac2c8-01ee-480d-8a6c-6d9e0af9d7ad"
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\pi_{0}$"
      ],
      "text/plain": [
       "pi_0"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "entering_var = dual_tableau.determine_entering()\n",
    "entering_var"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Gsn17CIVzf11"
   },
   "source": [
    "On this example, variable $\\pi_0$ will enter.\n",
    "\n",
    "Next, we determine our departing variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 38
    },
    "id": "UJ6ohtNMNb7V",
    "outputId": "6b57e152-1cfd-4c98-e8ad-a3c940ea6f6c"
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle s_{0}$"
      ],
      "text/plain": [
       "s_0"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "departing_var = dual_tableau.determine_departing(entering_var)\n",
    "departing_var"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "I4MPMmPNNb7V"
   },
   "source": [
    "After having determined our entering and leaving variables, we update our dual dictionary with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "MeylSSeENb7V",
    "outputId": "766719bb-ba3b-4417-a40f-b7da1c640295"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Entering = pi_0; departing = s_0\n",
      "pi_0 = -31.57*pi_1 - 0.04*pi_2 - 8.17*pi_3 - 0.02*s_0 + 0.02\n"
     ]
    }
   ],
   "source": [
    "expr_entering_var = dual_tableau.pivot(entering_var,departing_var,verbose = 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2JpE1PCFNb7W"
   },
   "source": [
    "We perform similar operations in the primal dictionary. In the dual dictionary, we have just determined that $\\pi_{i^\\star}$ entered the dual basis and $s_{j^\\star}$ departed. As a result, in the primal dictionary, we will let $t_{i^\\star}$ depart the primal basis and $y_{j^\\star}$ enter.\n",
    "\n",
    "This is coded into:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 38
    },
    "id": "sUuGMz_qNb7W",
    "outputId": "eb1915f6-7bad-4e48-bb88-fbe7bb4a6348"
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - 0.26 q_{1} - 0.26 q_{2} - 0.26 q_{3} - 0.81 q_{4} - 0.64 q_{5} - 0.47 q_{6} - 0.02 t_{0} + 0.07$"
      ],
      "text/plain": [
       "-0.26*q_1 - 0.26*q_2 - 0.26*q_3 - 0.81*q_4 - 0.64*q_5 - 0.47*q_6 - 0.02*t_0 + 0.07"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round_expr(primal_tableau.pivot(primals[departing_var],primals[entering_var]),2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "m0LroUXLNb7W"
   },
   "source": [
    "We have completed one simplex step. Let's take a look at our dual dictionary after that step:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "YmqUNcfZNb7W",
    "outputId": "05ebd4e1-d278-41d6-ca7a-27e1807a54d6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------- \n",
      "Objective and constraints:\n",
      "obj  =  -24.7*pi_1 + 0.67*pi_2 - 12.5*pi_3 + 5.0*pi_4 - 0.07*s_0 + 0.07\n",
      "s_1  =  -51.83*pi_1 - 0.18*pi_2 + 40.72*pi_3 + 0.26*s_0 + 0.74\n",
      "s_2  =  -4.52*pi_1 - 13.87*pi_2 - 78.65*pi_3 + 0.26*s_0 + 0.74\n",
      "s_3  =  107.85*pi_1 + 0.41*pi_2 + 37.09*pi_3 + 0.26*s_0 + 0.74\n",
      "s_4  =  239.38*pi_1 - 0.09*pi_2 + 194.96*pi_3 - 30.9*pi_4 + 0.81*s_0 + 0.19\n",
      "s_5  =  222.79*pi_1 + 0.48*pi_2 + 153.53*pi_3 + 0.64*s_0 + 0.36\n",
      "s_6  =  209.2*pi_1 + 0.35*pi_2 + 132.11*pi_3 + 0.47*s_0 + 0.53\n",
      "pi_0  =  -31.57*pi_1 - 0.04*pi_2 - 8.17*pi_3 - 0.02*s_0 + 0.02\n"
     ]
    }
   ],
   "source": [
    "dual_tableau.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "evFCbGs2Nb7X"
   },
   "source": [
    "Now let's summarize all we've done above by writing a simplex step into a function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "id": "YS4Qb10gNb7X"
   },
   "outputs": [],
   "source": [
    "def simplex_loop_dualprimal(dual_tableau,primal_tableau,primals):\n",
    "    entering_var = dual_tableau.determine_entering()\n",
    "    if entering_var is None:\n",
    "        print('Optimal solution found.\\n=======================')\n",
    "        print('Basic primal variables:')\n",
    "        primal_tableau.solution(verbose=1)\n",
    "        print('Basic dual variables:')\n",
    "        dual_tableau.solution(verbose=1)\n",
    "    else:\n",
    "        departing_var = dual_tableau.determine_departing(entering_var)\n",
    "        if departing_var is None:\n",
    "            print('Unbounded solution.')\n",
    "        else:\n",
    "            expr_entering_var = dual_tableau.pivot(entering_var,departing_var, verbose=1)\n",
    "            _ = primal_tableau.pivot(primals[departing_var],primals[entering_var])\n",
    "            return False # not finished\n",
    "    return True # finished"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DlfXglQFNb7Y"
   },
   "source": [
    "We can then code the simplex into:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "YSg6HExxNb7Y",
    "outputId": "ccb6797a-f5b5-457b-b2e7-64c0c36f056d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Entering = pi_2; departing = s_2\n",
      "Entering = pi_4; departing = s_4\n",
      "Entering = pi_1; departing = pi_0\n",
      "Entering = pi_3; departing = pi_1\n",
      "Entering = s_0; departing = pi_3\n",
      "Optimal solution found.\n",
      "=======================\n",
      "Basic primal variables:\n",
      "obj = 0.19826501258540102\n",
      "q_2 = 0.03645271485077321\n",
      "q_4 = 0.16181229773462782\n",
      "t_0 = -3.2553847536857248\n",
      "t_1 = -88.8883045667026\n",
      "t_3 = -10.39864257461351\n",
      "Basic dual variables:\n",
      "obj = 0.1982650125854008\n",
      "s_1 = 0.9513888888888881\n",
      "s_3 = 0.9930555555555547\n",
      "s_5 = 0.9444444444444426\n",
      "s_6 = 0.9583333333333319\n",
      "pi_2 = 0.06944444444444457\n",
      "pi_4 = 0.028541891405968987\n",
      "s_0 = 0.8611111111111079\n",
      "\n",
      "Value = 0.198265012585401\n"
     ]
    }
   ],
   "source": [
    "finished = False\n",
    "while not finished:\n",
    "  finished = simplex_loop_dualprimal(dual_tableau,primal_tableau,primals)\n",
    "print('\\nValue = '+str(dual_tableau.base[Symbol('obj')].subs([ (variable,0) for variable in dual_tableau.nonbasic])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4_sTHq4ONb7Z"
   },
   "source": [
    "Compare with Gurobi:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "cOG2sq1FNb7Z",
    "outputId": "34e5ce12-6ea2-48ad-cbc9-c67132bcdaeb"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set parameter Username\n",
      "Academic license - for non-commercial use only - expires 2024-01-12\n",
      "\n",
      "Value = 0.19826501258540097\n"
     ]
    }
   ],
   "source": [
    "dietmodel = grb.Model()\n",
    "varq_j = dietmodel.addMVar(nbj)\n",
    "dietmodel.Params.OutputFlag = 0\n",
    "dietmodel.setObjective(varq_j.sum(), grb.GRB.MINIMIZE)\n",
    "c = dietmodel.addConstr(N_i_j @ varq_j >= d_i)\n",
    "dietmodel.optimize()\n",
    "q_j , π_i, val = dietmodel.getAttr('X') , dietmodel.getAttr('pi'), dietmodel.getAttr('objVal')\n",
    "print('\\nValue =',val)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dUbcFd4uq6Zo"
   },
   "source": [
    "Gurobi finds the same solution as our simplex algorithm coding — although significantly faster."
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": [],
   "toc_visible": true
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}