optimization/supply_chain_optimization_datacamp.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Supply Chain Analytics in Python\n",
    "- Linear programming is a tool for optimization\n",
    "- Optimization methods use a mathematical model whose requirements are linar relationships\n",
    "- 3 components to linear programming\n",
    "    - decision variables (you control)\n",
    "    - objective function (math expression that uses variables to express goal)\n",
    "    - constraints (math expression that describes the limits of solutions)\n",
    "- PuLP is a library for linear and integer programming problems written in Python\n",
    "    - It interfaces with solvers e.g. CPLEX, COIN, Gurobi\n",
    "    \n",
    "### Simple resource scheduling exercise\n",
    "In this exercise you are planning the production at a glass manufacturer. This manufacturer only produces wine and beer glasses:\n",
    "\n",
    "- there is a maximum production capacity of 60 hours\n",
    "- each batch of wine and beer glasses takes 6 and 5 hours respectively\n",
    "- the warehouse has a maximum capacity of 150 rack spaces\n",
    "- each batch of the wine and beer glasses takes 10 and 20 spaces respectively\n",
    "- the production equipment can only make full batches, no partial batches\n",
    "- Also, we only have orders for 6 batches of wine glasses. Therefore, we do not want to produce more than this. Each batch of the wine glasses earns a profit of \\\\$5 and the beer \\\\$4.5.\n",
    "- The objective is to maximize the profit for the manufacturer.\n",
    "- puLP has already been imported for you."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pulp import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Produce 6.0 batches of wine glasses\n"
     ]
    }
   ],
   "source": [
    "# Initialize Class\n",
    "model = LpProblem(\"Maximize Glass Co. Profits\", LpMaximize)\n",
    "\n",
    "# Define Decision Variables\n",
    "wine = LpVariable('Wine', lowBound=0, upBound=None, cat='Integer')\n",
    "beer = LpVariable('Beer', lowBound=0, upBound=None, cat='Integer')\n",
    "\n",
    "# Define Objective Function\n",
    "model += 5 * wine + 4.5 * beer\n",
    "\n",
    "# Define Constraints\n",
    "model += 6 * wine + 5 * beer <= 60\n",
    "model += 10 * wine + 20 * beer <= 150\n",
    "model += wine <= 6\n",
    "\n",
    "# Solve Model\n",
    "model.solve()\n",
    "print(\"Produce {} batches of wine glasses\".format(wine.varValue))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Trying to optimise calories burned\n",
    "- 0.2 minutes per pushup = 3 calories per pushup\n",
    "- 10 minutes per mile = 130 calories\n",
    "- 10 mins to exercise\n",
    "\n",
    "- decision variables: num pushups and miles run\n",
    "- Objective function that uses variables to express goal: max (3 * num pushups + 130 * num miles)\n",
    "- constraints - limits of solution: \n",
    "- 0.2 * num pushups + 10 * num miles ≤ 10\n",
    "- num pushups ≥ 0\n",
    "- num miles ≥ 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimal 150.0\n",
      "pushups = 50.0\n",
      "running = 0.0\n"
     ]
    }
   ],
   "source": [
    "model = LpProblem(\"Maximize Calories Burned\", LpMaximize)\n",
    "\n",
    "# Define Decision Variables\n",
    "pushups = LpVariable('pushups', lowBound=0, upBound=None, cat='Continuous')\n",
    "running = LpVariable('running', lowBound=0, upBound=None, cat='Continuous')\n",
    "\n",
    "# Define Objective Function\n",
    "model += 3 * pushups + 130 * running\n",
    "\n",
    "# Define Constraints\n",
    "model += 0.2 * pushups + 10 * running <= 10\n",
    "model += pushups >= 0\n",
    "model += running >= 0\n",
    "\n",
    "model.solve()\n",
    "\n",
    "status =  LpStatus[model.status]\n",
    "\n",
    "print(status, model.objective.value())\n",
    "\n",
    "for v in model.variables():\n",
    "    print(v.name,\"=\", v.value())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Trying out lpSum\n",
    "- Enables you to define objective function via a list rather than having to explicitly write out all the sums\n",
    "- In this exercise you are making two types (premium and budget) of ice cream, using heavy cream, whole milk, and sugar. One version is a premium version containing more cream than your budget version. You are looking to find the mixture of ingredients that minimizes the total costs of ingredients.\n",
    "- Two Python lists called prod_type and ingredient have been created for you, along with a dictionary var_dict containing the decision variables of the model. You can explore them in the console.\n",
    "- Define the objective function using lpSum() with list comprehension and the information in the table above. Iterate over the product types and multiply the dictionary variable by the correct ingredient cost.\n",
    "\n",
    "- Prices\n",
    "    - Cream: \\$1.5 \n",
    "    - Milk: \\$0.125 \n",
    "    - Sugar: \\$0.10 \n",
    "    \n",
    "```\n",
    "prod_type=['premium', 'budget']\n",
    "ingredient=['cream', 'milk', 'sugar']\n",
    "var_dict=\n",
    " {('budget', 'cream'): cb,\n",
    " ('budget', 'milk'): mb,\n",
    " ('budget', 'sugar'): sb,\n",
    " ('premium', 'cream'): cp,\n",
    " ('premium', 'milk'): mp,\n",
    " ('premium', 'sugar'): sp}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define Objective Function\n",
    "model += lpSum([1.5 * var_dict[(i, 'cream')] \n",
    "                + 0.125 * var_dict[(i, 'milk')] \n",
    "                + 0.1 * var_dict[(i, 'sugar')]\n",
    "                \n",
    "                # Iterate over product types\n",
    "                for i in prod_type])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Logistics planning problem\n",
    "You are consulting for kitchen oven manufacturer helping to plan their logistics for next month. There are two warehouse locations (New York, and Atlanta), and four regional customer locations (East, South, Midwest, West). The expected demand next month for East it is 1,800, for South it is 1,200, for the Midwest it is 1,100, and for West it is 1000. The cost for shipping each of the warehouse locations to the regional customer's is listed in the table below. Your goal is to fulfill the regional demand at the lowest price.\n",
    "\n",
    "| Customer  | New York  | Atlanta  |\n",
    "|---|---|---|\n",
    "| East  |  \\$211 | \\$232  |\n",
    "| South  | \\$232  | \\$212  |\n",
    "| Midwest  | \\$240  | \\$230  |\n",
    "| West  | \\$300  | \\$280  |\n",
    "\n",
    "Two Python dictionaries costs and var_dict have been created for you containing the costs and decision variables of the model. You can explore them in the console.\n",
    "\n",
    "```\n",
    "costs = {('Atlanta', 'East'): 232,\n",
    " ('Atlanta', 'Midwest'): 230,\n",
    " ('Atlanta', 'South'): 212,\n",
    " ('Atlanta', 'West'): 280,\n",
    " ('New York', 'East'): 211,\n",
    " ('New York', 'Midwest'): 240,\n",
    " ('New York', 'South'): 232,\n",
    " ('New York', 'West'): 300}\n",
    " \n",
    "var_dict = {('Atlanta', 'East'): atle,\n",
    " ('Atlanta', 'Midwest'): atlm,\n",
    " ('Atlanta', 'South'): atls,\n",
    " ('Atlanta', 'West'): atlw,\n",
    " ('New York', 'East'): ne,\n",
    " ('New York', 'Midwest'): nm,\n",
    " ('New York', 'South'): ns,\n",
    " ('New York', 'West'): nw}\n",
    "```\n",
    "\n",
    "Our decision variables in this exercise are the number of shipments for each warehouse and customer combination. You want to minimize the total cost of shipping. The total cost of shipping is the shipping costs along a route multiplied by the number of shipments along that route."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pulp import *\n",
    "\n",
    "# Initialize Model\n",
    "model = LpProblem(\"Minimize Transportation Costs\", LpMinimize)\n",
    "\n",
    "# Build the lists and the demand dictionary\n",
    "warehouse = ['New York', 'Atlanta']\n",
    "customers = ['East', 'South', 'Midwest', 'West']\n",
    "regional_demand = [1800, 1200, 1100, 1000]\n",
    "demand = dict(zip(customers, regional_demand))\n",
    "\n",
    "# Define Objective\n",
    "model += lpSum([costs[(w, c)] * var_dict[(w, c)] \n",
    "                for c in customers for w in warehouse])\n",
    "\n",
    "# For each customer, sum warehouse shipments and set equal to customer demand\n",
    "for c in customers:\n",
    "    model += lpSum([var_dict[(w, c)] for w in warehouse]) == demand[c]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Logistics planning problem 2\n",
    "You are again consulting for kitchen oven manufacturer helping to plan their logistics. This time you are attempting to put together a plan for the next six months (Jan.-Jun.). There are still two warehouse locations (New York, and Atlanta), and four regional customer locations (East, South, Midwest, West). The cost for shipping for each of the warehouse locations to the regional customer's is listed in the table below. Your goal is to determine the number of shipments from each warehouse to customers that provides the lowest costs.\n",
    "\n",
    "A Python dictionary named, costs containing the costs of the model, and three lists months, warehouse, and customers have been created for you. costs has been printed for you, you can explore the lists in the console as well. Additionally, the model has been initialized for you.\n",
    "\n",
    "\n",
    "\n",
    "| Customer  | New York  | Atlanta  |\n",
    "|---|---|---|\n",
    "| East  |  \\$211 | \\$232  |\n",
    "| South  | \\$232  | \\$212  |\n",
    "| Midwest  | \\$240  | \\$230  |\n",
    "| West  | \\$300  | \\$280  |\n",
    "\n",
    "```\n",
    "months=['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun']\n",
    "warehouse=['New York', 'Atlanta']\n",
    "customers=['East', 'South', 'Midwest', 'West']\n",
    "costs = {('Atlanta', 'East'): 232,\n",
    " ('Atlanta', 'Midwest'): 230,\n",
    " ('Atlanta', 'South'): 212,\n",
    " ('Atlanta', 'West'): 280,\n",
    " ('New York', 'East'): 211,\n",
    " ('New York', 'Midwest'): 240,\n",
    " ('New York', 'South'): 232,\n",
    " ('New York', 'West'): 300}\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define decision variables\n",
    "key = [(m, w, c) for m in months for w in warehouse for c in customers]\n",
    "var_dict = LpVariable.dicts('num_of_shipments', \n",
    "                            key, \n",
    "                            lowBound=0, cat='Integer')\n",
    "\n",
    "# Use the LpVariable dictionary variable to define objective\n",
    "model += lpSum([costs[(w, c)] * var_dict[(m, w, c)] \n",
    "                for m in months for w in warehouse for c in customers])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Traveling salesman problem (TSP)\n",
    "The Traveling Salesman Problem (TSP) is a popular problem and has applications is logistics. In the TSP a salesman is given a list of cities, and the distance between each pair. He is looking for the shortest route going from the origin through all points before going back to the origin city again. This is a computationally difficult problem to solve but Miller-Tucker-Zemlin (MTZ) showed it can be completed using Integer Linear Programing. In this exercise you are going to define the objective and some constraints for of the TSP for a small dataset with 15 cities (see the image below). Your goal is to try out using LpVariable.dicts with list comprehension.\n",
    "\n",
    "Three Python variables n, cities, and dist have been created for you 1. The n variable is the number of cities, cities is a list of the cities numbered and dist is a pandas DataFrame with the pairwise distance between each city. You can explore them in the console. Additionally, the model has been initialized for you.\n",
    "\n",
    "```\n",
    "n=15\n",
    "cities=range(0, 15)\n",
    "```\n",
    "\n",
    "Use LpVariable.dicts to create a dictionary x holding binary variables for each city to city pair, and to create a dictionary u holding an integer LpVariable for each city.\n",
    "\n",
    "Define the objective function by summing together, the distance between each pair of cities multiplied by the binary decision variable x that you created earlier.\n",
    "\n",
    "Use the x binary variable to define a set of constraints to requires that each city be arrived at from exactly one other city, and a second set of constraints that requires that from each city there is a departure to exactly one other city. In the first set of constraints if we loop through the list of destination cities we should sum over the departure cities and ensure they sum to 1. In the second set of constraints if we loop through the list of arrival cities we should sum over the departure cities and ensure they sum to 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define Decision Variables\n",
    "x = LpVariable.dicts('X', [(c1, c2) for c1 in cities for c2 in cities], \n",
    "                     cat='Binary')\n",
    "u = LpVariable.dicts('U', [c1 for c1 in cities], \n",
    "                     lowBound=0, upBound=(n-1), cat='Integer')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define Decision Variables\n",
    "x = LpVariable.dicts('X', [(c1, c2) for c1 in cities for c2 in cities], \n",
    "                     cat='Binary')\n",
    "u = LpVariable.dicts('U', [c1 for c1 in cities], \n",
    "                     lowBound=0, upBound=(n-1), cat='Integer')\n",
    "\n",
    "# Define Objective\n",
    "model += lpSum([dist.iloc[c1, c2] * x[(c1, c2)] \n",
    "                for c1 in cities for c2 in cities])\n",
    "\n",
    "# Define Constraints\n",
    "for c2 in cities:\n",
    "    model += lpSum([x[(c1, c2)] for c1 in cities]) == 1\n",
    "for c1 in cities:\n",
    "    model += lpSum([x[(c1, c2)] for c2 in cities]) == 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scheduling workers problem\n",
    "You are looking to hire workers to work in a warehouse. Each worker is expected to work 5 consecutive days and then have two days off. The chart below has the estimated number of workers you will need each day. You are looking to hire the minimum number of workers to handle the workload for each day.\n",
    "\n",
    "|  Day of Week |  Employees Needed |\n",
    "|---|---|\n",
    "| 0 = Monday  | 31  |\n",
    "| 1 = Tuesday  | 45  |\n",
    "| 2 = Wednesday  | 40  |\n",
    "| 3 = Thursday  | 40  |\n",
    "| 4 = Friday  | 48  |\n",
    "| 5 = Saturday  | 30  |\n",
    "| 6 = Sunday  | 25  |\n",
    "\n",
    "The pulp module has been imported and the model has been initialized for you. Also, the variable days has been defined for you as a list of number from 0-6."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The class has been initialize, and x, days, objective function defined\n",
    "model = LpProblem(\"Minimize Staffing\", LpMinimize)\n",
    "days = list(range(7))\n",
    "x = LpVariable.dicts('staff_', days, lowBound=0, cat='Integer')\n",
    "model += lpSum([x[i] for i in days])\n",
    "\n",
    "# Define Constraints\n",
    "model += x[0] + x[3] + x[4] + x[5] + x[6] >= 31\n",
    "model += x[0] + x[1] + x[4] + x[5] + x[6] >= 45\n",
    "model += x[0] + x[1] + x[2] + x[5] + x[6] >= 40\n",
    "model += x[0] + x[1] + x[2] + x[3] + x[6] >= 40\n",
    "model += x[0] + x[1] + x[2] + x[3] + x[4] >= 48\n",
    "model += x[1] + x[2] + x[3] + x[4] + x[5] >= 30\n",
    "model += x[2] + x[3] + x[4] + x[5] + x[6] >= 25\n",
    "\n",
    "model.solve()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Preventative maintenance scheduling\n",
    "\n",
    "At a quarry they use diamond saws to cut slabs of marble. For preventative maintenance the saws are only allowed to run for 4 consecutive hours, afterwards a 1 hour inspection is completed before they are allowed to go back into service. The quarry operates 10-hour shifts. At the end of the shift if the saw blades have not been used for 4 consecutive hours the remaining time will be used at the start of the next shift. The expected number of saw blades needed for each hour is listed below. Our goal is to determine the minimum number of saw blades are needed for the shift.\n",
    "\n",
    "Expected Workload - (Note that the chart at hour 0)\t\n",
    "    \n",
    "| Hour  | Saws Needed  |\n",
    "|---|---|\n",
    "| 0  | 7  |\n",
    "| 1  | 7  |\n",
    "| 2  | 7  |\n",
    "| 3  | 6  |\n",
    "| 4  | 5  |\n",
    "| 5 |  6 |\n",
    "| 6  | 6  |\n",
    "| 7  | 7  |\n",
    "| 8  | 7  |\n",
    "| 9  | 6  |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The class has been initialize, and x, hours and objective fuction defined\n",
    "model = LpProblem(\"Minimize Staffing\", LpMinimize)\n",
    "hours = list(range(10))\n",
    "x = LpVariable.dicts('saws_', hours, lowBound=0, cat='Integer')\n",
    "model += lpSum([x[i] for i in hours])\n",
    "\n",
    "# Define Constraints\n",
    "model += x[0] + x[2] + x[3] + x[4] + x[5] + x[7] + x[8] + x[9] >= 7\n",
    "model += x[0] + x[1] + x[3] + x[4] + x[5] + x[6] + x[8] + x[9] >= 7\n",
    "model += x[0] + x[1] + x[2] + x[4] + x[5] + x[6] + x[7] + x[9] >= 7\n",
    "model += x[0] + x[1] + x[2] + x[3] + x[5] + x[6] + x[7] + x[8] >= 6\n",
    "model += x[1] + x[2] + x[3] + x[4] + x[6] + x[7] + x[8] + x[9] >= 5\n",
    "model += x[0] + x[2] + x[3] + x[4] + x[5] + x[7] + x[8] + x[9] >= 6\n",
    "model += x[0] + x[1] + x[3] + x[4] + x[5] + x[6] + x[8] + x[9] >= 6\n",
    "model += x[0] + x[1] + x[2] + x[4] + x[5] + x[6] + x[7] + x[9] >= 7\n",
    "model += x[0] + x[1] + x[2] + x[3] + x[5] + x[6] + x[7] + x[8] >= 7\n",
    "model += x[1] + x[2] + x[3] + x[4] + x[6] + x[7] + x[8] + x[9] >= 6\n",
    "\n",
    "model.solve()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Decision variables of case study\n",
    "\n",
    "Continue the case study of the Capacitated Plant Location model of a car manufacture. You are given four Pandas data frames demand, var_cost, fix_cost, and cap containing the regional demand (thous. of cars), variable production costs (thous. $US), fixed production costs (thous. $US), and production capacity (thous. of cars). All these variables have been printed to the console for your viewing.\n",
    "\n",
    "Continue the case study of the Capacitated Plant Location model of a car manufacture. You are given four Pandas data frames demand, var_cost, fix_cost, and cap containing the regional demand (thous. of cars), variable production costs (thous. $US), fixed production costs (thous. $US), and production capacity (thous. of cars). Two python lists loc, and size have also been created, containing the different locations, and the two types of plant capacities. All these variables have been printed to the console for your viewing. The code to initialize, and defined the decision variables has been completed for you."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize, and Define Decision Vars.\n",
    "model = LpProblem(\"Capacitated Plant Location Model\", LpMinimize)\n",
    "loc = ['USA', 'Germany', 'Japan', 'Brazil', 'India']\n",
    "size = ['Low_Cap','High_Cap']\n",
    "x = LpVariable.dicts(\"production_\", [(i,j) for i in loc for j in loc],\n",
    "                     lowBound=0, upBound=None, cat='Continous')\n",
    "y = LpVariable.dicts(\"plant_\", \n",
    "                     [(i,s) for s in size for i in loc], cat='Binary')\n",
    "\n",
    "# Define objective function\n",
    "model += (lpSum([fix_cost.loc[i,s] * y[(i,s)] \n",
    "                 for s in size for i in loc])\n",
    "          + lpSum([var_cost.loc[i,j] * x[(i,j)] \n",
    "                   for i in loc for j in loc]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Logical constraint exercise\n",
    "Your customer has ordered six products to be delivered over the next month. You will need to ship multiple truck loads to deliver all of the products. There is a weight limit on your trucks of 25,000 lbs. For cash flow reasons you desire to ship the most profitable combination of products that can fit on your truck.\n",
    "\n",
    "| Product  | Weight (lbs)  | Profitability ($US)  |\n",
    "|---|---|---|\n",
    "| A  | 12,583  | 102,564  |\n",
    "| B  | 9,204  | 130,043  |\n",
    "| C  | 12,611  | 127,648  |\n",
    "| D  | 12,131  | 155,058  |\n",
    "| E  | 12,889  | 238,846  |\n",
    "| F  | 11,529  | 197,030  |\n",
    "\n",
    "Two Python dictionaries weight, and prof, and a list prod have been created for you containing the weight, profitability, and name of each product. You can explore them in the console.\n",
    "\n",
    "```\n",
    "weight={'A': 12583, 'B': 9204, 'C': 12611, 'D': 12131, 'E': 12889, 'F': 11529}\n",
    "prof={'A': 102564, 'B': 130043, 'C': 127648, 'D': 155058, 'E': 238846, 'F': 197030}\n",
    "prod=['A', 'B', 'C', 'D', 'E', 'F']\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialized model, defined decision variables and objective\n",
    "model = LpProblem(\"Loading Truck Problem\", LpMaximize)\n",
    "x = LpVariable.dicts('ship_', prod, cat='Binary')\n",
    "model += lpSum([prof[i] * x[i] for i in prod])\n",
    "\n",
    "# Define Constraint\n",
    "model += lpSum([weight[i] * x[i] for i in prod]) <= 25000\n",
    "model += x['D'] + x['E'] + x['F'] <= 1\n",
    "\n",
    "model.solve()\n",
    "for i in prod:\n",
    "    print(\"{} status {}\".format(i, x[i].varValue))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Logical constraints exercise 2\n",
    "You work at a trucking distribution center and you need to decide which of 6 customer locations you will send a truck to. Your goal is to minimize the distance a truck travels.\n",
    "\n",
    "| Location  | Distance  |\n",
    "|---|---|\n",
    "| A  | 86  |\n",
    "| B  | 95  |\n",
    "| C  | 205  |\n",
    "| D  | 229  |\n",
    "| E  | 101  |\n",
    "| F  | 209  |\n",
    "\n",
    "A dictionary dist, and a list cust have been created for you containing the distance, and name of each customer location. These inputs have been printed in console for you.\n",
    "\n",
    "```\n",
    "dist={'A': 86, 'B': 95, 'C': 205, 'D': 229, 'E': 101, 'F': 209}\n",
    "cust=['A', 'B', 'C', 'D', 'E', 'F']\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = LpProblem(\"Loading Truck Problem\", LpMinimize)\n",
    "x = LpVariable.dicts('ship_', cust, cat='Binary')\n",
    "model += lpSum([dist[i]*x[i] for i in cust])\n",
    "\n",
    "# Define Constraint\n",
    "model += x['A'] + x['B'] + x['C'] + x['D'] + x['E'] + x['F'] >= 1\n",
    "model += x['A'] - x['D'] <= 0\n",
    "model += x['B'] - x['E'] <= 0\n",
    "\n",
    "model.solve()\n",
    "for i in cust:\n",
    "    print(\"{} status {}\".format(i, x[i].varValue))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dependent demand constraint exercise\n",
    "You are developing a production plan for 5 products (A through E). One unit of product E comprises 2 units of A, and 1 unit of C. Product C is also sold directly to customers. Your planning horizon is 3 months. You are looking to determine how much of each product to produce by month that meets the customer's demand and minimizes the total costs.\n",
    "\n",
    "A Pandas DataFrame named demand is printed in the console and contains the monthly customer demand for each product. Additionally, the code of the PuLP model to initialize, define decision variables, objective function, and constraint so production is greater than or equal to demand has been given to you."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize, Define Decision Vars., Objective Function, and Constraints\n",
    "model = LpProblem(\"Aggregate Production Planning\", LpMinimize)\n",
    "time = [0, 1, 2]\n",
    "prod = ['A', 'B', 'C', 'D', 'E']\n",
    "X = LpVariable.dicts(\"prod\", [(t, p) for p in prod for t in time], \n",
    "                     lowBound=0, cat=\"Integer\")\n",
    "model += lpSum([costs.loc[t, p]*X[(t, p)] for p in prod for t in time])\n",
    "for p in prod:\n",
    "    for t in time:\n",
    "        model += X[(t, p)] >= demand.loc[t, p]\n",
    "        \n",
    "# Define Dependent Demand Constraints\n",
    "for t in time:\n",
    "    model += 2 * X[(t, 'E')] <= X[(t, 'A')]\n",
    "    model += 1 * X[(t, 'E')] + demand.loc[t, 'C'] <= X[(t, 'C')]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Constraint combination exercise\n",
    "You are working on a distribution plan for a warehouse network. The network has two warehouses (W1, and W2) and each can ship three different types of products (A, B, and C). W1 is small and can either ship 10 products A per a week or 15 products B per a week or 20 products C per a week. You are looking to minimize the total costs.\n",
    "\n",
    "A Pandas DataFrame named demand is printed in the console and contains the monthly demand for each product. Additionally, the code of the PuLP model to initialize, define decision variables, objective function, and constraint so total shipment of each product equals its demand."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize, Define Decision Vars., Objective Function, and Constraints\n",
    "model = LpProblem(\"Distribution Planning\", LpMinimize)\n",
    "wh = ['W1','W2']\n",
    "prod = ['A', 'B', 'C']\n",
    "X = LpVariable.dicts(\"ship\", [(w, p, c) for c in cust for p in prod for w in wh], \n",
    "                     lowBound=0, cat=\"Integer\")\n",
    "model += lpSum([X[(w, p, c)]*costs.loc[(w, p), c]  for c in cust for p in prod for w in wh])\n",
    "for c in cust:\n",
    "    for p in prod:\n",
    "        model += lpSum([X[(w, p, c)] for w in wh]) == demand.loc[p, c]\n",
    "\n",
    "# Define Dependent Demand Constraints\n",
    "model += ((1/10) * lpSum([X[('W1', 'A', c)] for c in cust]) \n",
    "          + (1/15) * lpSum([X[('W1', 'B', c)] for c in cust])\n",
    "          + (1/20) * lpSum([X[('W1', 'C', c)] for c in cust])) <= 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "Exercise\n",
    "Constraints of case study exercise\n",
    "Continue the case study of the Capacitated Plant Location model of a car manufacture. You are given four Pandas data frames demand, var_cost, fix_cost, and cap containing the regional demand (thous. of cars), variable production costs (thous. $ US), fixed production costs (thous. $ US), and production capacity (thous. of cars). Two python lists loc, and size have also been created, containing the different locations, and the two types of plant capacities. All these variables have been printed to the console for your viewing. The code to initialize the decision variables, define them and create the objective function has been completed for you."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize, Define Decision Vars., and Objective Function\n",
    "model = LpProblem(\"Capacitated Plant Location Model\", LpMinimize)\n",
    "loc = ['USA', 'Germany', 'Japan', 'Brazil', 'India']\n",
    "size = ['Low_Cap','High_Cap']\n",
    "x = LpVariable.dicts(\"production_\", [(i,j) for i in loc for j in loc],\n",
    "                     lowBound=0, upBound=None, cat='Continuous')\n",
    "y = LpVariable.dicts(\"plant_\", \n",
    "                     [(i,s) for s in size for i in loc], cat='Binary')\n",
    "model += (lpSum([fix_cost.loc[i,s] * y[(i,s)] for s in size for i in loc])\n",
    "          + lpSum([var_cost.loc[i,j] * x[(i,j)] for i in loc for j in loc]))\n",
    "\n",
    "# Define the constraints\n",
    "for j in loc:\n",
    "    model += lpSum([x[(i, j)] for i in loc]) == demand.loc[j,'Dmd']\n",
    "for i in loc:\n",
    "    model += lpSum([x[(i, j)] for j in loc]) <= lpSum([cap.loc[i,s] * y[(i,s)] \n",
    "                                                       for s in size])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding logical constraint in case study exercise\n",
    "Continue the case study of the Capacitated Plant Location model of a car manufacture. You are given four Pandas data frames demand, var_cost, fix_cost, and cap containing the regional demand (thous. of cars), variable production costs (thous. $US), fixed production costs (thous. $US), and production capacity (thous. of cars). Two python lists loc, and size have also been created, containing the different locations, and the two types of plant capacities. All these variables have been printed to the console for your viewing. The code to initialize, defined the decision variables, create the objective function, and constraints has been completed for you."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize, Define Decision Vars., Object. Fun., and Constraints\n",
    "model = LpProblem(\"Capacitated Plant Location Model\", LpMinimize)\n",
    "loc = ['USA', 'Germany', 'Japan', 'Brazil', 'India']\n",
    "size = ['Low_Cap','High_Cap']\n",
    "x = LpVariable.dicts(\"production_\", [(i,j) for i in loc for j in loc],\n",
    "                     lowBound=0, upBound=None, cat='Integer')\n",
    "y = LpVariable.dicts(\"plant_\", \n",
    "                     [(i,s) for s in size for i in loc], cat='Binary')\n",
    "model += (lpSum([fix_cost.loc[i,s] * y[(i,s)] for s in size for i in loc])\n",
    "          + lpSum([var_cost.loc[i,j] * x[(i,j)] for i in loc for j in loc]))\n",
    "for j in loc:\n",
    "    model += lpSum([x[(i, j)] for i in loc]) == demand.loc[j,'Dmd']\n",
    "for i in loc:\n",
    "    model += lpSum([x[(i, j)] for j in loc]) <= lpSum([cap.loc[i,s]*y[(i,s)] \n",
    "                                                       for s in size])\n",
    "\n",
    "# Define logical constraint\n",
    "model += y[('USA','High_Cap')] - y[('Germany','Low_Cap')] <= 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solving production plan exercise\n",
    "In this exercise you are working on a production plan for manufacturing kitchen cabinets over the next four months. There are setup, production, and inventory storing costs. You are given the starting inventory, the production capacity and the demand for cabinets for each month. Your goal is to determine how many cabinets should be produced, and the ending inventory in each period that minimizes the overall costs over the four months.\n",
    "\n",
    "The PuLP model has been completed for you and stored in the variable model. The model’s decision variables include, x which equals the quantity of cabinets produced in a month, and s which shows the inventory at the end of a month. Additionally, a Python list of the different time periods named time has been created for you."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print status\n",
    "print(LpStatus[model.status])\n",
    "\n",
    "# Print Objective Fun. Value\n",
    "print(\"Total Cost = \", value(model.objective))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write model specifications to a file\n",
    "file_name = 'production_planning_lp.txt'\n",
    "model.writeLP(file_name)\n",
    "f = open(file_name)\n",
    "print(f.read())\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize, Define Decision Vars.\n",
    "model = LpProblem(\"Production Planning\", LpMinimize)\n",
    "time = [1, 2, 3, 4]\n",
    "s = LpVariable.dicts(\"stock\", [0, 1, 2, 3, 4], lowBound=0, cat=\"Integer\")\n",
    "x = LpVariable.dicts(\"prod\", time, lowBound=0, cat=\"Integer\")\n",
    "y = LpVariable.dicts(\"plant_on\", time, lowBound=0, cat=\"Binary\")\n",
    "\n",
    "# Define Objective to Include Fixed Costs\n",
    "model += lpSum([d.loc[t,\"unit_prod\"] * x[t] + d.loc[t,\"unit_inv\"]*s[t] \n",
    "                + d.loc[t,\"fixed\"] * y[t]\n",
    "                for t in time])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sensitivity analysis exercise\n",
    "You are doing the resource planning for a lawn furniture company. They manufacture decorative sets of legs for lawn chairs, benches, and tables from metal tubes using a two step process involving tube-bending, and welding. The profit the company receives from the sale of each product is $3 for a set of chair legs, $3 for a set of bench legs, and $5 for a set of table legs. You are trying to plan the production mix for the upcoming season. Unfortunately, due to a strike there is only 2000 lbs tubing available for production on-hand.\n",
    "\n",
    "The time and raw material requirements for each product are printed in the console. Also, the PuLP model has been completed for you and stored in the variable model. The constraints of the model are printed to the console."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solve Model, Print Status, Desision Var, and Obj. Value\n",
    "model.solve()\n",
    "print(\"Model Status: {}\".format(pulp.LpStatus[model.status]))\n",
    "for v in model.variables():\n",
    "    print(v.name, \"=\", v.varValue)\n",
    "print(\"Objective = \", value(model.objective))\n",
    "\n",
    "# Print Shadow Price and Slack\n",
    "o = [{'name': name, 'shadow price': c.pi, 'slack': c.slack} \n",
    "     for name, c in model.constraints.items()]\n",
    "print(pd.DataFrame(o))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Shadow price and slack exercise pt1\n",
    "You are planning what cupcakes a bakery should make. The bakery can make either:\n",
    "\n",
    "regular size cupcake: profit = $5\n",
    "a jumbo cupcake twice the regular size: profit = $10\n",
    "There are 2 constraints on oven hours (30) and worker hours (65). This scenario has been modeled in PuLP for you and a solution found. The model status, decision variables values, objective value (i.e. profit), the shadow prices and slack of the constraints have been printed in the shell.\n",
    "\n",
    "The sample script is a copy of that code. You will adjust the constraints to see how the optimal solution changes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Increase the 1st constraint to 31. Run the code and see the change in the objective \n",
    "# compared to the original solution.\n",
    "\n",
    "# Define Constraints, Solve, Print Status, Variables, Objective\n",
    "model = LpProblem(\"Maximize Bakery Profits\", LpMaximize)\n",
    "R = LpVariable('Regular_production', lowBound=0, cat='Continuous')\n",
    "J = LpVariable('Jumbo_production', lowBound=0, cat='Continuous')\n",
    "model += 5 * R + 10 * J, \"Profit\"\n",
    "\n",
    "# Adjust the constraint\n",
    "model += 0.5 * R + 1 * J <= 30\n",
    "model += 1 * R + 2.5 * J <= ____\n",
    "\n",
    "# Solve Model, Print Status, Variables, Objective, Shadow and Slack\n",
    "model.solve()\n",
    "print(\"Model Status: {}\".format(pulp.LpStatus[model.status]))\n",
    "for v in model.variables():\n",
    "    print(v.name, \"=\", v.varValue)\n",
    "print(\"Objective = $\", value(model.objective))\n",
    "o = [{'name':name, 'shadow price':c.pi, 'slack': c.slack} \n",
    "     for name, c in model.constraints.items()]\n",
    "print(pd.DataFrame(o))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Increase the 2nd constraint to 80. Run the code and see no change \n",
    "# in the objective compared to the original solution.\n",
    "\n",
    "# Define Constraints, Solve, Print Status, Variables, Objective\n",
    "model = LpProblem(\"Maximize Bakery Profits\", LpMaximize)\n",
    "R = LpVariable('Regular_production', lowBound=0, cat='Continuous')\n",
    "J = LpVariable('Jumbo_production', lowBound=0, cat='Continuous')\n",
    "model += 5 * R + 10 * J, \"Profit\"\n",
    "\n",
    "# Adjust the constraint\n",
    "model += 0.5 * R + 1 * J <= 30\n",
    "model += 1 * R + 2.5 * J <= 80\n",
    "\n",
    "# Solve Model, Print Status, Variables, Objective, Shadow and Slack\n",
    "model.solve()\n",
    "print(\"Model Status: {}\".format(pulp.LpStatus[model.status]))\n",
    "for v in model.variables():\n",
    "    print(v.name, \"=\", v.varValue)\n",
    "print(\"Objective = $\", value(model.objective))\n",
    "o = [{'name':name, 'shadow price':c.pi, 'slack': c.slack} \n",
    "     for name, c in model.constraints.items()]\n",
    "print(pd.DataFrame(o))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Decrease the 2nd constraint to 60. Run the code and see no \n",
    "# change in the objective compared to the original solution.\n",
    "\n",
    "# Define Constraints, Solve, Print Status, Variables, Objective\n",
    "model = LpProblem(\"Maximize Bakery Profits\", LpMaximize)\n",
    "R = LpVariable('Regular_production', lowBound=0, cat='Continuous')\n",
    "J = LpVariable('Jumbo_production', lowBound=0, cat='Continuous')\n",
    "model += 5 * R + 10 * J, \"Profit\"\n",
    "\n",
    "# Adjust the constraint\n",
    "model += 0.5 * R + 1 * J <= 30\n",
    "model += 1 * R + 2.5 * J <= 60\n",
    "\n",
    "# Solve Model, Print Status, Variables, Objective, Shadow and Slack\n",
    "model.solve()\n",
    "print(\"Model Status: {}\".format(pulp.LpStatus[model.status]))\n",
    "for v in model.variables():\n",
    "    print(v.name, \"=\", v.varValue)\n",
    "print(\"Objective = $\", value(model.objective))\n",
    "o = [{'name':name, 'shadow price':c.pi, 'slack': c.slack} \n",
    "     for name, c in model.constraints.items()]\n",
    "print(pd.DataFrame(o))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Decrease the 2nd constraint to 59. Run the code and see a \n",
    "# change in the objective compared to the original solution.\n",
    "\n",
    "# Define Constraints, Solve, Print Status, Variables, Objective\n",
    "model = LpProblem(\"Maximize Bakery Profits\", LpMaximize)\n",
    "R = LpVariable('Regular_production', lowBound=0, cat='Continuous')\n",
    "J = LpVariable('Jumbo_production', lowBound=0, cat='Continuous')\n",
    "model += 5 * R + 10 * J, \"Profit\"\n",
    "\n",
    "# Adjust the constraint\n",
    "model += 0.5 * R + 1 * J <= 30\n",
    "model += 1 * R + 2.5 * J <= 59\n",
    "\n",
    "# Solve Model, Print Status, Variables, Objective, Shadow and Slack\n",
    "model.solve()\n",
    "print(\"Model Status: {}\".format(pulp.LpStatus[model.status]))\n",
    "for v in model.variables():\n",
    "    print(v.name, \"=\", v.varValue)\n",
    "print(\"Objective = $\", value(model.objective))\n",
    "o = [{'name':name, 'shadow price':c.pi, 'slack': c.slack} \n",
    "     for name, c in model.constraints.items()]\n",
    "print(pd.DataFrame(o))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Step 1, You notice that changing the right-hand-side of a constraint by 1 increases the objective value by the amount of the shadow price. In Step 2, you should have noticed that increasing the right-hand-side of a non-binding constraint will not change the optimal solution. In Step 3, you should have noticed that decreasing the right-hand-side of a non-binding constraint equal to slack will not change the optimal solution but make it a binding constraint. In Step 4, you should have noticed that increasing the right-hand-side by more than the slack with change the optimal solution."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Shadow price and slack exercise pt2\n",
    "In this exercise you are working on the production plan for a company over the next 4 months. Your goal is to determine how much should be produced to minimize the production (fixed + variable), and storage costs while meeting the customers demand. The are constraints on the production capacity and demand each month.\n",
    "\n",
    "Complete the code, near the bottom of the sample code, to create a Pandas DataFrame that shows the slack of the constraints.\n",
    "\n",
    "You need to loop through the model constraints and call the constraint slack attribute to create the list of Python dictionaries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = LpProblem(\"Production Planning\", LpMinimize)\n",
    "time = [1, 2, 3, 4]\n",
    "s = LpVariable.dicts(\"stock_in\", [0, 1, 2, 3, 4], lowBound=0, cat=\"Integer\")\n",
    "x = LpVariable.dicts(\"prod_in\", time, lowBound=0, cat=\"Integer\")\n",
    "y = LpVariable.dicts(\"plant_on_\", time, lowBound=0, cat=\"Binary\")\n",
    "model += lpSum([d.loc[t,\"unit_prod\"]*x[t] + d.loc[t,\"unit_inv\"]*s[t] \n",
    "                + d.loc[t,\"fixed_setup\"]*y[t] for t in time])\n",
    "s[0] = 100\n",
    "for t in time:\n",
    "    model += s[t-1] + x[t] == d.loc[t,\"demand\"] + s[t]\n",
    "    model += x[t] <= d.loc[t,\"prod_cap\"]*y[t]\n",
    "model.solve()\n",
    "\n",
    "# Print the Constraint Slack\n",
    "o = [{'name':name, 'slack':c.slack} \n",
    "     for name, c in model.constraints.items()]\n",
    "print(pd.DataFrame(o))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solving the model case study exercise\n",
    "Continue the case study of the Capacitated Plant Location model of a car manufacture. The PuLP model has been completed and solved for you. It is stored in the variable model.\n",
    "\n",
    "The decision variables x and y respectively represent the production quantities of the different regions, and if a production plant is opened. Additionally, two python lists loc and size have also been created, containing the different locations, and the two types of plant capacities. Finally, the input data for the model has been printed to the console for reference.\n",
    "\n",
    "- Print the values of how much is produced and shipped from one region to another.\n",
    "- Next, print the status value of the different regional plants of low and high capacity.\n",
    "- Finally, print the objective value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print the Production Quantities\n",
    "o = [{'prod':'{} to {}'.format(i,j), 'quantity':x[(i,j)].varValue} \n",
    "     for i in loc for j in loc]\n",
    "print(pd.DataFrame(o))\n",
    "\n",
    "# Print the Plant Values of the different regions\n",
    "o = [{'lowCap':y[(i,size[0])].varValue, 'highCap':y[(i,size[1])].varValue}\n",
    "     for i in loc]\n",
    "print(pd.DataFrame(o, index=loc))\n",
    "\n",
    "# Print the Objective Value\n",
    "print('Objective = ', value(model.objective))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simulation testing solution exercise\n",
    "You are working to minimize the transportation costs of shipping products from warehouses in New York, and Atlanta, to customers in the East, South, Midwest, and West regions of the US. The input data of transportation costs and demand for each region is given to you in the variable d which is printed in the console.\n",
    "\n",
    "A function named run_pulp_model() has been created for you to solve and return results of the PuLP model using the random objective from step 1. Complete the code to call the function 100 times, saving the results in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add noise to the objective function\n",
    "model += lpSum([(X[(c, w)] + (d.loc[c, w] + random.normalvariate(0, 5)))\n",
    "                for w in wh for c in cust])\n",
    "\n",
    "# Call the function 100 times and append results to list\n",
    "output = []\n",
    "for i in range(100):\n",
    "    output.append(run_pulp_model(d))\n",
    "df = pd.DataFrame(output)\n",
    "\n",
    "# Print the value count df series Midwest from Atlanta\n",
    "print(df['Midwest from Atlanta'].value_counts())\n",
    "\n",
    "# Print the value count df series East from Atlanta\n",
    "print(df['East from Atlanta'].value_counts())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simulation testing capacitated model\n",
    "Continue the case study of the Capacitated Plant Location model of a car manufacture. The PuLP model has been completed and solved for you. It is stored in the variable model. The decision variables x, and y respectively represent the production quantities of the different regions, and if a production plant is opened. Additionally, two python lists loc, and size have also been created, containing the different locations, and the two types of plant capacities. Finally, the input data for the model has been printed to the console for you for reference.\n",
    "\n",
    "Complete the code of the objective function that uses the random.normalvariate() method to add noise to the variable costs estimates, centered at 0 (thousands of \\\\$US dollars) with a standard deviation of 5 (thousands of \\\\$US dollars).\n",
    "\n",
    "Add noise to the regional demand estimates. Set the parameters of the random.normalvariate() method where the mean=0 and the standard deviation is 5% of the demand estimate.\n",
    "\n",
    "A function named run_pulp_model(fix_cost, var_cost, demand, cap) has been created for you to solve and return results of the PuLP model for simulation testing. Complete the code to call the function 100 times, saving the results in a list.\n",
    "\n",
    "A function named run_pulp_model(fix_cost, var_cost, demand, cap) has been created for you to solve and return results of the PuLP model for simulation testing. Complete the code to call the function 100 times, saving the results in a list.\n",
    "\n",
    "Plot the histogram of the production in Brazil (this could take a bit longer than usual to run)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define Objective\n",
    "model += (lpSum([fix_cost.loc[i,s] * y[(i,s)] for s in size for i in loc])\n",
    "          + lpSum([(var_cost.loc[i,j] + random.normalvariate(0, 5))*x[(i,j)] \n",
    "                   for i in loc for j in loc]))\n",
    "\n",
    "# Define the Constraints\n",
    "for j in loc:\n",
    "    rd = random.normalvariate(0, demand.loc[j,'Dmd'] * 0.05)\n",
    "    model += lpSum([x[(i, j)] for i in loc]) == (demand.loc[j,'Dmd'] + rd)\n",
    "    \n",
    "# Call the function 100 times and append results to list\n",
    "output = []\n",
    "for i in range(100):\n",
    "    output.append(run_pulp_model(fix_cost, var_cost, demand, cap))\n",
    "df = pd.DataFrame(output)\n",
    "\n",
    "# Import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Call the function 100 times and append results to list\n",
    "output = []\n",
    "for i in range(100):\n",
    "    output.append(run_pulp_model(fix_cost, var_cost, demand, cap))\n",
    "df = pd.DataFrame(output)\n",
    "\n",
    "# Plot histogram of Brazil Production\n",
    "plt.hist(df['Brazil'])\n",
    "plt.title('Histogram of Prod. In Brazil Region')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import matplotlib.pyplot\n",
    "import matplotlib.pyplot as plt\n",
    "plt.title('Histogram of Prod. At USA Region')\n",
    "\n",
    "# Histogram of USA production\n",
    "plt.hist(df['USA'])\n",
    "plt.show()\n",
    "plt.title('Histogram of Prod. At Japan Region')\n",
    "\n",
    "# Histogram of Japan production\n",
    "plt.hist(df['Japan'])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Converting new problem using what I've learned\n",
    "\n",
    "A factory manufactures doodads and whirligigs. It costs \\\\$2 and takes 3 hours to produce a doodad. It costs \\\\$4 and takes 2 hours to produce a whirligig. The factory has \\\\$220 and 150 hours this week to produce these products. If each doodad sells for \\\\$6 and each whirligig sells for \\\\$7, then how many of each product should be manufactured this week in order to maximize profit?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimal 435.0\n",
      "Doodad = 20.0\n",
      "Whirligig = 45.0\n"
     ]
    }
   ],
   "source": [
    "# way before\n",
    "# Initialize Class\n",
    "model = LpProblem(\"MaximizeFactoryDoodadprofits\", LpMaximize)\n",
    "\n",
    "# Define Decision Variables\n",
    "doodad = LpVariable('Doodad', lowBound=0, upBound=None, cat='Integer')\n",
    "whirligig = LpVariable('Whirligig', lowBound=0, upBound=None, cat='Integer')\n",
    "\n",
    "# Define Objective Function\n",
    "model += 6 * doodad + 7 * whirligig\n",
    "\n",
    "# Define Constraints\n",
    "model += 2 * doodad + 4 * whirligig <= 220\n",
    "model += 3 * doodad + 2 * whirligig <= 150\n",
    "model += doodad >= 0\n",
    "model += whirligig >= 0\n",
    "\n",
    "model.solve()\n",
    "\n",
    "status =  LpStatus[model.status]\n",
    "\n",
    "print(status, model.objective.value())\n",
    "\n",
    "for v in model.variables():\n",
    "    print(v.name,\"=\", v.value())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimal 435.0\n",
      "items_Doodad = 20.0\n",
      "items_Whirligig = 45.0\n"
     ]
    }
   ],
   "source": [
    "# new techniques\n",
    "\n",
    "items = ['Doodad', 'Whirligig']\n",
    "cost = {'Doodad': 2, 'Whirligig': 4}\n",
    "time = {'Doodad': 3, 'Whirligig': 2}\n",
    "value = {'Doodad': 6, 'Whirligig': 7}\n",
    "\n",
    "model = LpProblem(\"Maximize Factory Doodad profits\", LpMaximize)\n",
    "\n",
    "var_dict = LpVariable.dicts('items', items, lowBound=0, cat='Integer')\n",
    "\n",
    "# Use the LpVariable dictionary variable to define objective\n",
    "model += lpSum([value[i] * var_dict[i] for i in items])\n",
    "\n",
    "# Define Constraints\n",
    "model += lpSum([cost[i] * var_dict[i] for i in items]) <= 220\n",
    "model += lpSum([time[i] * var_dict[i] for i in items]) <= 150\n",
    "model += lpSum([var_dict[i] for i in items]) >= 0\n",
    "\n",
    "model.solve()\n",
    "\n",
    "status =  LpStatus[model.status]\n",
    "\n",
    "print(status, model.objective.value())\n",
    "\n",
    "for v in model.variables():\n",
    "    print(v.name,\"=\", v.value())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}