Optimization_LP.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem\n",
    "\n",
    "___Suppose you are a well-established dietician and are responsible to advise one of your customers on the best possible food plan he should follow in order to attain \"optimum nutrition\". However, there are some restrictions in terms of the budget and the variety of food that needs to be included in the diet plan. The data set used can be downloaded from here and the jupyter notebook could be downloaded from my Github repository.___\n",
    "\n",
    "## Intuition\n",
    "\n",
    "__Minimize the cost of the best food plan(inclusive of food items), given some constraints (on total calories but also on each of the nutritional components e.g. fat, vitamin C, iron, etc.)__\n",
    "\n",
    "__The Cost function is the total cost of the food items which we are trying to minimize. Why? Because the cost should be minimal, at the same time, the nutritional value derived from the combination of different food items should be maximum, considering the maximum and minimum constraints given in the data. The inequality constraints are given by the minimum and maximum bounds on each of the nutritional components.__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import everything from the PuLP library and other libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pulp import *\n",
    "import numpy as np, pandas as pd\n",
    "import warnings\n",
    "warnings.filterwarnings('always')\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pulp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Formulate the Optimization Problem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "prob = LpProblem('Diet_Problem', LpMinimize)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reading the data set and creating some dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Foods</th>\n",
       "      <th>Price/Serving</th>\n",
       "      <th>Serving Size</th>\n",
       "      <th>Calories</th>\n",
       "      <th>Cholesterol (mg)</th>\n",
       "      <th>Total_Fat (g)</th>\n",
       "      <th>Sodium (mg)</th>\n",
       "      <th>Carbohydrates (g)</th>\n",
       "      <th>Dietary_Fiber (g)</th>\n",
       "      <th>Protein (g)</th>\n",
       "      <th>Vit_A (IU)</th>\n",
       "      <th>Vit_C (IU)</th>\n",
       "      <th>Calcium (mg)</th>\n",
       "      <th>Iron (mg)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Frozen Broccoli</td>\n",
       "      <td>0.48</td>\n",
       "      <td>10 Oz Pkg</td>\n",
       "      <td>73.8</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.8</td>\n",
       "      <td>68.2</td>\n",
       "      <td>13.6</td>\n",
       "      <td>8.5</td>\n",
       "      <td>8.0</td>\n",
       "      <td>5867.4</td>\n",
       "      <td>160.2</td>\n",
       "      <td>159.0</td>\n",
       "      <td>2.3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Frozen Corn</td>\n",
       "      <td>0.54</td>\n",
       "      <td>1/2 Cup</td>\n",
       "      <td>72.2</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.6</td>\n",
       "      <td>2.5</td>\n",
       "      <td>17.1</td>\n",
       "      <td>2.0</td>\n",
       "      <td>2.5</td>\n",
       "      <td>106.6</td>\n",
       "      <td>5.2</td>\n",
       "      <td>3.3</td>\n",
       "      <td>0.3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Raw Lettuce Iceberg</td>\n",
       "      <td>0.06</td>\n",
       "      <td>1 Leaf</td>\n",
       "      <td>2.6</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.8</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.3</td>\n",
       "      <td>0.2</td>\n",
       "      <td>66.0</td>\n",
       "      <td>0.8</td>\n",
       "      <td>3.8</td>\n",
       "      <td>0.1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Baked Potatoes</td>\n",
       "      <td>0.18</td>\n",
       "      <td>1/2 Cup</td>\n",
       "      <td>171.5</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.2</td>\n",
       "      <td>15.2</td>\n",
       "      <td>39.9</td>\n",
       "      <td>3.2</td>\n",
       "      <td>3.7</td>\n",
       "      <td>0.0</td>\n",
       "      <td>15.6</td>\n",
       "      <td>22.7</td>\n",
       "      <td>4.3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Tofu</td>\n",
       "      <td>0.93</td>\n",
       "      <td>1/4 block</td>\n",
       "      <td>88.2</td>\n",
       "      <td>0.0</td>\n",
       "      <td>5.5</td>\n",
       "      <td>8.1</td>\n",
       "      <td>2.2</td>\n",
       "      <td>1.4</td>\n",
       "      <td>9.4</td>\n",
       "      <td>98.6</td>\n",
       "      <td>0.1</td>\n",
       "      <td>121.8</td>\n",
       "      <td>6.2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                 Foods  Price/Serving Serving Size  Calories  \\\n",
       "0      Frozen Broccoli           0.48    10 Oz Pkg      73.8   \n",
       "1          Frozen Corn           0.54      1/2 Cup      72.2   \n",
       "2  Raw Lettuce Iceberg           0.06       1 Leaf       2.6   \n",
       "3       Baked Potatoes           0.18      1/2 Cup     171.5   \n",
       "4                 Tofu           0.93    1/4 block      88.2   \n",
       "\n",
       "   Cholesterol (mg)  Total_Fat (g)  Sodium (mg)  Carbohydrates (g)  \\\n",
       "0               0.0            0.8         68.2               13.6   \n",
       "1               0.0            0.6          2.5               17.1   \n",
       "2               0.0            0.0          1.8                0.4   \n",
       "3               0.0            0.2         15.2               39.9   \n",
       "4               0.0            5.5          8.1                2.2   \n",
       "\n",
       "   Dietary_Fiber (g)  Protein (g)  Vit_A (IU)  Vit_C (IU)  Calcium (mg)  \\\n",
       "0                8.5          8.0      5867.4       160.2         159.0   \n",
       "1                2.0          2.5       106.6         5.2           3.3   \n",
       "2                0.3          0.2        66.0         0.8           3.8   \n",
       "3                3.2          3.7         0.0        15.6          22.7   \n",
       "4                1.4          9.4        98.6         0.1         121.8   \n",
       "\n",
       "   Iron (mg)  \n",
       "0        2.3  \n",
       "1        0.3  \n",
       "2        0.1  \n",
       "3        4.3  \n",
       "4        6.2  "
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Now create some dictionaries in order to extract information from the diet table.\n",
    "\n",
    "#Reading the data\n",
    "df = pd.read_excel('diet.xls',nrows=17)\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of different food items is here follows: -\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>S.No</th>\n",
       "      <th>Food Items</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>Frozen Broccoli</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>Frozen Corn</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>Raw Lettuce Iceberg</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>Baked Potatoes</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>Tofu</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>6</td>\n",
       "      <td>Roasted Chicken</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>7</td>\n",
       "      <td>Spaghetti W/ Sauce</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>8</td>\n",
       "      <td>Raw Apple</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>9</td>\n",
       "      <td>Banana</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>10</td>\n",
       "      <td>Wheat Bread</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>11</td>\n",
       "      <td>White Bread</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>12</td>\n",
       "      <td>Oatmeal Cookies</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>13</td>\n",
       "      <td>Apple Pie</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>14</td>\n",
       "      <td>Scrambled Eggs</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>15</td>\n",
       "      <td>Turkey Bologna</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>16</td>\n",
       "      <td>Beef Frankfurter</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>17</td>\n",
       "      <td>Chocolate Chip Cookies</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    S.No              Food Items\n",
       "0      1         Frozen Broccoli\n",
       "1      2             Frozen Corn\n",
       "2      3     Raw Lettuce Iceberg\n",
       "3      4          Baked Potatoes\n",
       "4      5                    Tofu\n",
       "5      6         Roasted Chicken\n",
       "6      7      Spaghetti W/ Sauce\n",
       "7      8               Raw Apple\n",
       "8      9                  Banana\n",
       "9     10             Wheat Bread\n",
       "10    11             White Bread\n",
       "11    12         Oatmeal Cookies\n",
       "12    13               Apple Pie\n",
       "13    14          Scrambled Eggs\n",
       "14    15          Turkey Bologna\n",
       "15    16        Beef Frankfurter\n",
       "16    17  Chocolate Chip Cookies"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#List of food items\n",
    "food = list(df.Foods)\n",
    "\n",
    "#The list of items\n",
    "count=pd.Series(range(1,len(food)+1))\n",
    "print('List of different food items is here follows: -')\n",
    "food_s = pd.Series(food)\n",
    "\n",
    "#Convert to data frame\n",
    "f_frame = pd.concat([count,food_s],axis=1,keys=['S.No','Food Items'])\n",
    "f_frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a dictinary of costs for all food items\n",
    "costs = dict(zip(food,df['Price/Serving']))\n",
    "\n",
    "#Create a dictionary of calories for all items of food\n",
    "calories = dict(zip(food,df['Calories']))\n",
    "\n",
    "#Create a dictionary of cholesterol for all items of food\n",
    "chol = dict(zip(food,df['Cholesterol (mg)']))\n",
    "\n",
    "#Create a dictionary of total fat for all items of food\n",
    "fat = dict(zip(food,df['Total_Fat (g)']))\n",
    "\n",
    "#Create a dictionary of sodium for all items of food\n",
    "sodium = dict(zip(food,df['Sodium (mg)']))\n",
    "\n",
    "#Create a dictionary of carbohydrates for all items of food\n",
    "carbs = dict(zip(food,df['Carbohydrates (g)']))\n",
    "\n",
    "#Create a dictionary of dietary fiber for all items of food\n",
    "fiber = dict(zip(food,df['Dietary_Fiber (g)']))\n",
    "\n",
    "#Create a dictionary of protein for all food items\n",
    "protein = dict(zip(food,df['Protein (g)']))\n",
    "\n",
    "#Create a dictionary of vitamin A for all food items\n",
    "vit_A = dict(zip(food,df['Vit_A (IU)']))\n",
    "\n",
    "#Create a dictionary of vitamin C for all food items\n",
    "vit_C = dict(zip(food,df['Vit_C (IU)']))\n",
    "\n",
    "#Create a dictionary of calcium for all food items\n",
    "calcium = dict(zip(food,df['Calcium (mg)']))\n",
    "\n",
    "#Create a dictionary of iron for all food items\n",
    "iron = dict(zip(food,df['Iron (mg)']))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Frozen Broccoli': 2.3,\n",
       " 'Frozen Corn': 0.3,\n",
       " 'Raw Lettuce Iceberg': 0.1,\n",
       " ' Baked Potatoes': 4.3,\n",
       " 'Tofu': 6.2,\n",
       " 'Roasted Chicken': 1.8,\n",
       " 'Spaghetti W/ Sauce': 2.3,\n",
       " 'Raw Apple': 0.2,\n",
       " 'Banana': 0.4,\n",
       " 'Wheat Bread': 0.7,\n",
       " 'White Bread': 0.8,\n",
       " 'Oatmeal Cookies': 0.5,\n",
       " 'Apple Pie': 0.1,\n",
       " 'Scrambled Eggs': 0.7,\n",
       " 'Turkey Bologna': 0.4,\n",
       " 'Beef Frankfurter': 0.6,\n",
       " 'Chocolate Chip Cookies': 0.4}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#We just run one of the dictionaries to see how these look like\n",
    "iron"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__We now create a dictionary of all the food items' variables keeping the following things in mind: -__\n",
    "\n",
    "* The lower bound is equal to zero\n",
    "* The category should be continuous ie the decision variables could take continuous values.\n",
    "\n",
    "__Such adjustment is necessary to enable the non-negative conditions as anyway negative quantities of food is not possible right? Imagine -1 block of tofu - would not make any sense at all! It also ensures that the values are real valued__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A dictionary called 'food_vars' is created to contain the referenced Variables\n",
    "food_vars = LpVariable.dicts(\"Food\",food,lowBound=0,cat='Continuous')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Frozen Broccoli': Food_Frozen_Broccoli,\n",
       " 'Frozen Corn': Food_Frozen_Corn,\n",
       " 'Raw Lettuce Iceberg': Food_Raw_Lettuce_Iceberg,\n",
       " ' Baked Potatoes': Food__Baked_Potatoes,\n",
       " 'Tofu': Food_Tofu,\n",
       " 'Roasted Chicken': Food_Roasted_Chicken,\n",
       " 'Spaghetti W/ Sauce': Food_Spaghetti_W__Sauce,\n",
       " 'Raw Apple': Food_Raw_Apple,\n",
       " 'Banana': Food_Banana,\n",
       " 'Wheat Bread': Food_Wheat_Bread,\n",
       " 'White Bread': Food_White_Bread,\n",
       " 'Oatmeal Cookies': Food_Oatmeal_Cookies,\n",
       " 'Apple Pie': Food_Apple_Pie,\n",
       " 'Scrambled Eggs': Food_Scrambled_Eggs,\n",
       " 'Turkey Bologna': Food_Turkey_Bologna,\n",
       " 'Beef Frankfurter': Food_Beef_Frankfurter,\n",
       " 'Chocolate Chip Cookies': Food_Chocolate_Chip_Cookies}"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "food_vars"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Addition of Objective fucntion to the LPP. Note the use of the `lpSum method.`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Diet_Problem:\n",
       "MINIMIZE\n",
       "0.48*Food_Apple_Pie + 0.44999999999999996*Food_Banana + 0.81*Food_Beef_Frankfurter + 0.09*Food_Chocolate_Chip_Cookies + 0.48*Food_Frozen_Broccoli + 0.54*Food_Frozen_Corn + 0.27*Food_Oatmeal_Cookies + 0.72*Food_Raw_Apple + 0.06*Food_Raw_Lettuce_Iceberg + 2.52*Food_Roasted_Chicken + 0.33*Food_Scrambled_Eggs + 2.34*Food_Spaghetti_W__Sauce + 0.9299999999999999*Food_Tofu + 0.44999999999999996*Food_Turkey_Bologna + 0.15000000000000002*Food_Wheat_Bread + 0.18*Food_White_Bread + 0.18*Food__Baked_Potatoes + 0.0\n",
       "VARIABLES\n",
       "Food_Apple_Pie Continuous\n",
       "Food_Banana Continuous\n",
       "Food_Beef_Frankfurter Continuous\n",
       "Food_Chocolate_Chip_Cookies Continuous\n",
       "Food_Frozen_Broccoli Continuous\n",
       "Food_Frozen_Corn Continuous\n",
       "Food_Oatmeal_Cookies Continuous\n",
       "Food_Raw_Apple Continuous\n",
       "Food_Raw_Lettuce_Iceberg Continuous\n",
       "Food_Roasted_Chicken Continuous\n",
       "Food_Scrambled_Eggs Continuous\n",
       "Food_Spaghetti_W__Sauce Continuous\n",
       "Food_Tofu Continuous\n",
       "Food_Turkey_Bologna Continuous\n",
       "Food_Wheat_Bread Continuous\n",
       "Food_White_Bread Continuous\n",
       "Food__Baked_Potatoes Continuous"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prob += lpSum([costs[i]*food_vars[i] for i in food])\n",
    "prob"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Addition of the Constraints"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Note that we further put our constraints now based upon the maximum and the minimum intake of the nutritional components in our data set. Do not forget the motive, we intend to minimize the cost considering these constraints on the components or the decision variables.\n",
    "\n",
    "##### For the sake of simplicity, and in order to maintain brevity, I am planning to define only five constraints.\n",
    "##### Now the lpSum method helps in calculating the sum of the linear expressions, so we will use it to define the constraint of Calories in the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "67.2*Food_Apple_Pie + 104.9*Food_Banana + 141.8*Food_Beef_Frankfurter + 78.1*Food_Chocolate_Chip_Cookies + 73.8*Food_Frozen_Broccoli + 72.2*Food_Frozen_Corn + 81.0*Food_Oatmeal_Cookies + 81.4*Food_Raw_Apple + 2.6*Food_Raw_Lettuce_Iceberg + 277.4*Food_Roasted_Chicken + 99.6*Food_Scrambled_Eggs + 358.2*Food_Spaghetti_W__Sauce + 88.2*Food_Tofu + 56.4*Food_Turkey_Bologna + 65.0*Food_Wheat_Bread + 65.0*Food_White_Bread + 171.5*Food__Baked_Potatoes + 0.0"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lpSum([food_vars[i]*calories[i] for i in food])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Foods</th>\n",
       "      <th>Calories</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Frozen Broccoli</td>\n",
       "      <td>73.8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Frozen Corn</td>\n",
       "      <td>72.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Raw Lettuce Iceberg</td>\n",
       "      <td>2.6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Baked Potatoes</td>\n",
       "      <td>171.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Tofu</td>\n",
       "      <td>88.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Roasted Chicken</td>\n",
       "      <td>277.4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Spaghetti W/ Sauce</td>\n",
       "      <td>358.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>Raw Apple</td>\n",
       "      <td>81.4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>Banana</td>\n",
       "      <td>104.9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>Wheat Bread</td>\n",
       "      <td>65.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>White Bread</td>\n",
       "      <td>65.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>Oatmeal Cookies</td>\n",
       "      <td>81.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>Apple Pie</td>\n",
       "      <td>67.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>Scrambled Eggs</td>\n",
       "      <td>99.6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>Turkey Bologna</td>\n",
       "      <td>56.4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>Beef Frankfurter</td>\n",
       "      <td>141.8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>Chocolate Chip Cookies</td>\n",
       "      <td>78.1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     Foods  Calories\n",
       "0          Frozen Broccoli      73.8\n",
       "1              Frozen Corn      72.2\n",
       "2      Raw Lettuce Iceberg       2.6\n",
       "3           Baked Potatoes     171.5\n",
       "4                     Tofu      88.2\n",
       "5          Roasted Chicken     277.4\n",
       "6       Spaghetti W/ Sauce     358.2\n",
       "7                Raw Apple      81.4\n",
       "8                   Banana     104.9\n",
       "9              Wheat Bread      65.0\n",
       "10             White Bread      65.0\n",
       "11         Oatmeal Cookies      81.0\n",
       "12               Apple Pie      67.2\n",
       "13          Scrambled Eggs      99.6\n",
       "14          Turkey Bologna      56.4\n",
       "15        Beef Frankfurter     141.8\n",
       "16  Chocolate Chip Cookies      78.1"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[['Foods','Calories']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Hence in the two output images above, we could compare that lpSum helps in taking the sumproduct of the food items with their respective size of the nutritional component taken under consideration (Calories in this case)\n",
    "\n",
    "#### Note that we still have not defined the constraints. We define it by adding the same to our problem statement (Recall the objective function and the constraints are the part of the LPP)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "prob += lpSum([food_vars[x]*calories[x] for x in food]) >= 800, \"CaloriesMinimum\"\n",
    "prob += lpSum([food_vars[x]*calories[x] for x in food]) <= 1300, \"CaloriesMaximum\"\n",
    "# prob"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Diet_Problem:\n",
       "MINIMIZE\n",
       "0.48*Food_Apple_Pie + 0.44999999999999996*Food_Banana + 0.81*Food_Beef_Frankfurter + 0.09*Food_Chocolate_Chip_Cookies + 0.48*Food_Frozen_Broccoli + 0.54*Food_Frozen_Corn + 0.27*Food_Oatmeal_Cookies + 0.72*Food_Raw_Apple + 0.06*Food_Raw_Lettuce_Iceberg + 2.52*Food_Roasted_Chicken + 0.33*Food_Scrambled_Eggs + 2.34*Food_Spaghetti_W__Sauce + 0.9299999999999999*Food_Tofu + 0.44999999999999996*Food_Turkey_Bologna + 0.15000000000000002*Food_Wheat_Bread + 0.18*Food_White_Bread + 0.18*Food__Baked_Potatoes + 0.0\n",
       "SUBJECT TO\n",
       "CaloriesMinimum: 67.2 Food_Apple_Pie + 104.9 Food_Banana\n",
       " + 141.8 Food_Beef_Frankfurter + 78.1 Food_Chocolate_Chip_Cookies\n",
       " + 73.8 Food_Frozen_Broccoli + 72.2 Food_Frozen_Corn + 81 Food_Oatmeal_Cookies\n",
       " + 81.4 Food_Raw_Apple + 2.6 Food_Raw_Lettuce_Iceberg\n",
       " + 277.4 Food_Roasted_Chicken + 99.6 Food_Scrambled_Eggs\n",
       " + 358.2 Food_Spaghetti_W__Sauce + 88.2 Food_Tofu + 56.4 Food_Turkey_Bologna\n",
       " + 65 Food_Wheat_Bread + 65 Food_White_Bread + 171.5 Food__Baked_Potatoes\n",
       " >= 800\n",
       "\n",
       "CaloriesMaximum: 67.2 Food_Apple_Pie + 104.9 Food_Banana\n",
       " + 141.8 Food_Beef_Frankfurter + 78.1 Food_Chocolate_Chip_Cookies\n",
       " + 73.8 Food_Frozen_Broccoli + 72.2 Food_Frozen_Corn + 81 Food_Oatmeal_Cookies\n",
       " + 81.4 Food_Raw_Apple + 2.6 Food_Raw_Lettuce_Iceberg\n",
       " + 277.4 Food_Roasted_Chicken + 99.6 Food_Scrambled_Eggs\n",
       " + 358.2 Food_Spaghetti_W__Sauce + 88.2 Food_Tofu + 56.4 Food_Turkey_Bologna\n",
       " + 65 Food_Wheat_Bread + 65 Food_White_Bread + 171.5 Food__Baked_Potatoes\n",
       " <= 1300\n",
       "\n",
       "VARIABLES\n",
       "Food_Apple_Pie Continuous\n",
       "Food_Banana Continuous\n",
       "Food_Beef_Frankfurter Continuous\n",
       "Food_Chocolate_Chip_Cookies Continuous\n",
       "Food_Frozen_Broccoli Continuous\n",
       "Food_Frozen_Corn Continuous\n",
       "Food_Oatmeal_Cookies Continuous\n",
       "Food_Raw_Apple Continuous\n",
       "Food_Raw_Lettuce_Iceberg Continuous\n",
       "Food_Roasted_Chicken Continuous\n",
       "Food_Scrambled_Eggs Continuous\n",
       "Food_Spaghetti_W__Sauce Continuous\n",
       "Food_Tofu Continuous\n",
       "Food_Turkey_Bologna Continuous\n",
       "Food_Wheat_Bread Continuous\n",
       "Food_White_Bread Continuous\n",
       "Food__Baked_Potatoes Continuous"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prob"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Hence, the output shows how beautifully the function works. We have the objective function  which are subject to the \"Calories\" constraint as defined in the code above. Now since one of the five nutritional components has been duly defined, let us go ahead and define the remaining four components as well in order to formulate the problem outrightly.__\n",
    "\n",
    "#### The five nutritional components that I have chosen are `Carbohydrates, Fat, Protein, Vitamin A & Calcium.` ####"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Carbohydrates' constraint\n",
    "prob += lpSum([food_vars[x]*carbs[x] for x in food]) >= 130, \"CarbsMinimum\"\n",
    "prob += lpSum([food_vars[x]*carbs[x] for x in food]) <= 200, \"CarbsMaximum\"\n",
    "\n",
    "#Fat's constraint\n",
    "prob += lpSum([food_vars[x]*fat[x] for x in food]) >= 20, \"FatsMinimum\"\n",
    "prob += lpSum([food_vars[x]*fat[x] for x in food]) <= 50, \"FatsMaximum\"\n",
    "\n",
    "#Protein's constraint\n",
    "prob += lpSum([food_vars[x]*protein[x] for x in food]) >= 100, \"ProteinsMinimum\"\n",
    "prob += lpSum([food_vars[x]*protein[x] for x in food]) <= 150, \"ProteinsMaximum\"\n",
    "\n",
    "#Vit_A constraint\n",
    "prob += lpSum([food_vars[x]*vit_A[x] for x in food]) >= 1000, \"Vit_A_Minimum\"\n",
    "prob += lpSum([food_vars[x]*vit_A[x] for x in food]) <= 10000, \"Vit_A_Maximum\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Running the Solver Algorithm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Finally, we have our problem ready and now we shall run the Solver algorithm. Kindly note that we could pass our own parameters while running the solver n terms of the algorithm which could be used, but in this case, I shall run the solver without any parameters and let it decide the best algorithm to run according to the structure of the problem. Yes, this library is quite optimized to do so!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prob.solve()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<pulp.apis.coin_api.PULP_CBC_CMD at 0x1f222473d90>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prob.solver"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Now we print the status of the problem. Note that if the problem is not formulated well then it might have an \"infeasible\" soltuin or if it does not provide sufficient information then it might be \"Unbounded\". But our solution is \"optimal\" which means that the solution is optimized."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Optimal'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LpStatus[prob.status]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Printing of the variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Variable name: Food_Apple_Pie , Variable value : 0.0\n",
      "\n",
      "Variable name: Food_Banana , Variable value : 0.0\n",
      "\n",
      "Variable name: Food_Beef_Frankfurter , Variable value : 0.0\n",
      "\n",
      "Variable name: Food_Chocolate_Chip_Cookies , Variable value : 0.0\n",
      "\n",
      "Variable name: Food_Frozen_Broccoli , Variable value : 1.4079473\n",
      "\n",
      "Variable name: Food_Frozen_Corn , Variable value : 0.0\n",
      "\n",
      "Variable name: Food_Oatmeal_Cookies , Variable value : 0.0\n",
      "\n",
      "Variable name: Food_Raw_Apple , Variable value : 0.0\n",
      "\n",
      "Variable name: Food_Raw_Lettuce_Iceberg , Variable value : 0.0\n",
      "\n",
      "Variable name: Food_Roasted_Chicken , Variable value : 1.2329408\n",
      "\n",
      "Variable name: Food_Scrambled_Eggs , Variable value : 4.0165704\n",
      "\n",
      "Variable name: Food_Spaghetti_W__Sauce , Variable value : 0.0\n",
      "\n",
      "Variable name: Food_Tofu , Variable value : 0.0\n",
      "\n",
      "Variable name: Food_Turkey_Bologna , Variable value : 0.0\n",
      "\n",
      "Variable name: Food_Wheat_Bread , Variable value : 0.0\n",
      "\n",
      "Variable name: Food_White_Bread , Variable value : 0.0\n",
      "\n",
      "Variable name: Food__Baked_Potatoes , Variable value : 2.6473778\n",
      "\n",
      "\n",
      "\n",
      "****************************************************************************************************\n",
      "\n",
      "\n",
      "constraint name:CaloriesMinimum, constraint value:499.9999932\n",
      "\n",
      "constraint name:CaloriesMaximum, constraint value:-6.800000107887172e-06\n",
      "\n",
      "constraint name:CarbsMinimum, constraint value:-9.799999975967921e-07\n",
      "\n",
      "constraint name:CarbsMaximum, constraint value:-70.00000097999998\n",
      "\n",
      "constraint name:FatsMinimum, constraint value:24.292557960000003\n",
      "\n",
      "constraint name:FatsMaximum, constraint value:-5.70744204\n",
      "\n",
      "constraint name:ProteinsMinimum, constraint value:-2.999999928476882e-07\n",
      "\n",
      "constraint name:ProteinsMaximum, constraint value:-50.00000029999998\n",
      "\n",
      "constraint name:Vit_A_Minimum, constraint value:9000.000213619998\n",
      "\n",
      "constraint name:Vit_A_Maximum, constraint value:0.00021361999915825436\n",
      "\n",
      "****************************************************************************************************\n",
      "\n",
      "\n",
      "OBJECTIVE VALUE IS: 5.58\n"
     ]
    }
   ],
   "source": [
    "# prob.variables()[1].varValue()\n",
    "\n",
    "for var in prob.variables():\n",
    "    print(f'Variable name: {var.name} , Variable value : {var.value()}\\n')\n",
    "\n",
    "print('\\n')\n",
    "print('*'*100)\n",
    "print('\\n')\n",
    "\n",
    "#We can also see the slack variables of the constraints\n",
    "for name, con in prob.constraints.items():\n",
    "    print(f'constraint name:{name}, constraint value:{con.value()}\\n')\n",
    "\n",
    "print('*'*100)\n",
    "print('\\n')\n",
    "\n",
    "## OBJECTIVE VALUE\n",
    "print(f'OBJECTIVE VALUE IS: {round(prob.objective.value(),2)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The optimal value of the objective function is $5.58. \n",
    "\n",
    "#### The interpretation of the result would be the following: -\n",
    "\n",
    "* 2.64 servings of baked potatoes\n",
    "\n",
    "* 4.02 servings of  scrambled eggs\n",
    "\n",
    "* 1.23 servings of Roasted chicken \n",
    "\n",
    "* 1.41 servings of Frozen broccoli\n",
    "\n",
    "___The following diet plan would give the minimum cost and the maximum nutritional value to the customer. Hence, we have charted out the best food plan while also minimizing the cost.___"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Since we did not mention any parameter hence the PuLP uses the default solver CBC for the resolution. We could have used a different solver for our own solution. "
   ]
  }
 ],
 "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}