Gurobi_python.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "hindu-bangkok",
   "metadata": {},
   "outputs": [],
   "source": [
    "import gurobipy as gp\n",
    "from gurobipy import GRB"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "automatic-flesh",
   "metadata": {},
   "source": [
    "# Problem 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "explicit-cooler",
   "metadata": {},
   "source": [
    "Contois Carpets is a small manufacturer of carpeting for home and office installations. Production\n",
    "capacity, estimated demand, production cost and inventory holding cost are shown in table 1. Contois\n",
    "wants to determine how many square meters of carpeting to produce each quarter to minimize the\n",
    "total production and inventory cost for the four-quarter period.\n",
    "Contois has control over the production quantity, and therefore also the estimated inventory,\n",
    "each quarter. We can model the problem by using both the production and inventory quantities\n",
    "as decision variables, and linking them through constraints. The decision variables x_i describe\n",
    "production quantities and s_i the inventory quantities each quarter.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "paperback-edition",
   "metadata": {},
   "source": [
    "<img src=\"problem1.png\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "absent-interstate",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Academic license - for non-commercial use only - expires 2021-05-07\n",
      "Using license file C:\\Users\\User\\gurobi.lic\n",
      "Gurobi Optimizer version 9.1.1 build v9.1.1rc0 (win64)\n",
      "Thread count: 6 physical cores, 12 logical processors, using up to 12 threads\n",
      "Optimize a model with 8 rows, 8 columns and 15 nonzeros\n",
      "Model fingerprint: 0x9d73936f\n",
      "Coefficient statistics:\n",
      "  Matrix range     [1e+00, 1e+00]\n",
      "  Objective range  [3e-01, 5e+00]\n",
      "  Bounds range     [0e+00, 0e+00]\n",
      "  RHS range        [3e+02, 6e+02]\n",
      "Presolve removed 8 rows and 8 columns\n",
      "Presolve time: 0.01s\n",
      "Presolve: All rows and columns removed\n",
      "Iteration    Objective       Primal Inf.    Dual Inf.      Time\n",
      "       0    5.1500000e+03   0.000000e+00   0.000000e+00      0s\n",
      "\n",
      "Solved in 0 iterations and 0.02 seconds\n",
      "Optimal objective  5.150000000e+03\n",
      "x1 600\n",
      "x2 300\n",
      "x3 400\n",
      "x4 400\n",
      "s1 200\n",
      "s2 0\n",
      "s3 0\n",
      "s4 0\n",
      "Obj: 5150\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    m = gp.Model(\"exercise1\") # Setting up the model\n",
    "    \n",
    "    # x = Amount of carpet produced in quarter\n",
    "    x1 = m.addVar(vtype=GRB.CONTINUOUS, name=\"x1\")\n",
    "    x2 = m.addVar(vtype=GRB.CONTINUOUS, name=\"x2\")\n",
    "    x3 = m.addVar(vtype=GRB.CONTINUOUS, name=\"x3\")\n",
    "    x4 = m.addVar(vtype=GRB.CONTINUOUS, name=\"x4\")\n",
    "    \n",
    "    # s = Amount of carpet in inventory in quarter\n",
    "    s1 = m.addVar(vtype=GRB.CONTINUOUS, name=\"s1\")\n",
    "    s2 = m.addVar(vtype=GRB.CONTINUOUS, name=\"s2\")\n",
    "    s3 = m.addVar(vtype=GRB.CONTINUOUS, name=\"s3\")\n",
    "    s4 = m.addVar(vtype=GRB.CONTINUOUS, name=\"s4\")\n",
    "    \n",
    "    # Objective function\n",
    "    m.setObjective(2*x1 + 5*x2 + 3*x3 + 3*x4 + 0.25*(s1 + s2 + s3 + s4), GRB.MINIMIZE)\n",
    "    \n",
    "    # Defining the constraints\n",
    "    m.addConstr(x1 <= 600, \"c0\" )\n",
    "    m.addConstr(x2 <= 300, \"c1\" )\n",
    "    m.addConstr(x3 <= 500, \"c2\" )\n",
    "    m.addConstr(x4 <= 400, \"c3\" )\n",
    "    \n",
    "    m.addConstr(x1 - s1 == 400, \"c4\" )\n",
    "    m.addConstr(x2 + s1 - s2 == 500, \"c5\" )\n",
    "    m.addConstr(x3 + s2 - s3 == 400, \"c6\" )\n",
    "    m.addConstr(x4 + s3 - s4 == 400, \"c7\" )\n",
    "    \n",
    "    m.optimize() # Optimizing the model\n",
    "\n",
    "    # Printing the results\n",
    "    for v in m.getVars():\n",
    "        print('%s %g' % (v.varName, v.x))\n",
    "\n",
    "    print('Obj: %g' % m.objVal)\n",
    "\n",
    "\n",
    "except gp.GurobiError as e:\n",
    "    print('Error code ' + str(e.errno) + ': ' + str(e))\n",
    "\n",
    "except AttributeError:\n",
    "    print('Encountered an attribute error')   \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "administrative-legislation",
   "metadata": {},
   "source": [
    "# Problem 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "regulated-egyptian",
   "metadata": {},
   "source": [
    "Assume that there are two projects (A and B). The decision maker (DM) can invest in both of\n",
    "these projects in two phases: initial investment of 1M for A, $2M for B in period 0 and additional\n",
    "investment of 3M and 2M, respectively, in period 1. The initial budget for all investments is 9M.\n",
    "Additionally, surplus cash can be deposited with risk-free interest rate of 8%.\n",
    "The resulting cash flows from the projects depend on which of two possible scenarios realize in\n",
    "each period, and the three decisions: z_0_p? : initial investment in project p (1 variable per project) and\n",
    "z_1_p: continue project ? in scenario 8 (2 variables per project).\n",
    "If in period 1 scenario i realizes, the in period two the scenarios can be either s_i_1 or s_i_2.\n",
    "The outcomes of investments in different scenarios are depicted in figure 1. Note that the DM knows\n",
    "the outcome of scenario in period 1 when making the second investment (continue or not) decision.\n",
    "If the project is not continued, then the it will produce no income."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "secondary-curve",
   "metadata": {},
   "source": [
    "<img src=\"problem2.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "parliamentary-camera",
   "metadata": {},
   "source": [
    "<img src=\"problem2_equation.png\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "varying-gnome",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gurobi Optimizer version 9.1.1 build v9.1.1rc0 (win64)\n",
      "Thread count: 6 physical cores, 12 logical processors, using up to 12 threads\n",
      "Optimize a model with 11 rows, 13 columns and 34 nonzeros\n",
      "Model fingerprint: 0xf6c65373\n",
      "Variable types: 7 continuous, 6 integer (6 binary)\n",
      "Coefficient statistics:\n",
      "  Matrix range     [1e+00, 3e+01]\n",
      "  Objective range  [1e-01, 3e-01]\n",
      "  Bounds range     [1e+00, 1e+00]\n",
      "  RHS range        [9e+00, 9e+00]\n",
      "Presolve removed 11 rows and 13 columns\n",
      "Presolve time: 0.00s\n",
      "Presolve: All rows and columns removed\n",
      "\n",
      "Explored 0 nodes (0 simplex iterations) in 0.01 seconds\n",
      "Thread count was 1 (of 12 available processors)\n",
      "\n",
      "Solution count 1: 18.7984 \n",
      "\n",
      "Optimal solution found (tolerance 1.00e-04)\n",
      "Best objective 1.879840000000e+01, best bound 1.879840000000e+01, gap 0.0000%\n",
      "r0 6\n",
      "r1 3.48\n",
      "r2 4.48\n",
      "r11 23.7584\n",
      "r12 13.7584\n",
      "r22 14.8384\n",
      "r21 29.8384\n",
      "z0A 1\n",
      "z1A 1\n",
      "z2A 0\n",
      "z0B 1\n",
      "z1B 0\n",
      "z2B 1\n",
      "Obj: 18.7984\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    m = gp.Model(\"exercise2\") # Setting up the model\n",
    "    \n",
    "    # Cash flow\n",
    "    r0 = m.addVar(vtype=GRB.CONTINUOUS, name=\"r0\")\n",
    "    r1 = m.addVar(vtype=GRB.CONTINUOUS, name=\"r1\")\n",
    "    r2 = m.addVar(vtype=GRB.CONTINUOUS, name=\"r2\")\n",
    "    r11 = m.addVar(vtype=GRB.CONTINUOUS, name=\"r11\")\n",
    "    r12 = m.addVar(vtype=GRB.CONTINUOUS, name=\"r12\")\n",
    "    r22 = m.addVar(vtype=GRB.CONTINUOUS, name=\"r22\")\n",
    "    r21 = m.addVar(vtype=GRB.CONTINUOUS, name=\"r21\")\n",
    "    \n",
    "    # Binary decision\n",
    "    z0A = m.addVar(vtype=GRB.BINARY, name=\"z0A\")\n",
    "    z1A = m.addVar(vtype=GRB.BINARY, name=\"z1A\")\n",
    "    z2A = m.addVar(vtype=GRB.BINARY, name=\"z2A\")\n",
    "    z0B = m.addVar(vtype=GRB.BINARY, name=\"z0B\")\n",
    "    z1B = m.addVar(vtype=GRB.BINARY, name=\"z1B\")\n",
    "    z2B = m.addVar(vtype=GRB.BINARY, name=\"z2B\")\n",
    "    \n",
    "    # Given probabilities\n",
    "    p11 = 0.5 * 0.3\n",
    "    p21 = 0.5 * 0.4\n",
    "    p12 = 0.5 * 0.7\n",
    "    p22 = 0.5 * 0.6\n",
    "    \n",
    "    # Objective function\n",
    "    m.setObjective(p11*r11 + p21*r21 + p12*r12 + p22*r22, GRB.MAXIMIZE)\n",
    "    \n",
    "    ## Defining the constraints\n",
    "    # Time = 0\n",
    "    m.addConstr(9 - z0A - 2*z0B == r0, \"c0\" ) \n",
    "    \n",
    "    # Time = 1\n",
    "    m.addConstr(1.08*r0 - 3*z1A - 2*z1B == r1, \"c1\" )\n",
    "    m.addConstr(1.08*r0 - 3*z2A - 2*z2B == r2, \"c2\" )\n",
    "    \n",
    "    # Time = 2\n",
    "    m.addConstr(1.08*r1 + 20*z1A + 2.5*z1B == r11, \"c3\" )\n",
    "    m.addConstr(1.08*r1 + 10*z1A + z1B == r12, \"c4\" )\n",
    "    m.addConstr(1.08*r2 + 5*z2A + 25*z2B == r21, \"c5\" )\n",
    "    m.addConstr(1.08*r2 + 10*z2B == r22, \"c6\" )\n",
    "\n",
    "    # Decision constraints\n",
    "    m.addConstr(z0A >= z1A, \"c7\" )\n",
    "    m.addConstr(z0A >= z2A, \"c8\" )\n",
    "    m.addConstr(z0B >= z1B, \"c9\" )\n",
    "    m.addConstr(z0B >= z2B, \"c10\" )\n",
    "\n",
    "    \n",
    "    m.optimize() # Optimizing the model\n",
    "\n",
    "    # Printing the results\n",
    "    for v in m.getVars():\n",
    "        print('%s %g' % (v.varName, v.x))\n",
    "\n",
    "    print('Obj: %g' % m.objVal)\n",
    "\n",
    "\n",
    "except gp.GurobiError as e:\n",
    "    print('Error code ' + str(e.errno) + ': ' + str(e))\n",
    "\n",
    "except AttributeError:\n",
    "    print('Encountered an attribute error')   "
   ]
  }
 ],
 "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.9.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}