LS-U and LS-C.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gurobipy as gp\n",
    "from gurobipy import GRB"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Uncapacitated and Capacitated Lot-Sizing Problem (LS-U and LS-C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set parameter Username\n",
      "Academic license - for non-commercial use only - expires 2023-07-30\n"
     ]
    }
   ],
   "source": [
    "# Initialize model\n",
    "m = gp.Model(\"ls\")\n",
    "\n",
    "capacitated = False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Time (e.g. months)\n",
    "n = 8\n",
    "t = range(0, n)\n",
    "\n",
    "# Costs for production of the product for each month\n",
    "p = [100 for i in t]\n",
    "\n",
    "# Costs for storing a product for each month\n",
    "h = [5 for i in t]\n",
    "\n",
    "# Costs for armoring the machines for each month\n",
    "q = [5000 for i in t]\n",
    "\n",
    "# Demand of products for each month\n",
    "d = [400, 400, 800, 800, 1200, 1200, 1200, 1200]\n",
    "\n",
    "# Producttion Amount for each month\n",
    "x = m.addVars(n, name=\"x\", vtype=GRB.INTEGER)\n",
    "\n",
    "# Storage Amount for each month\n",
    "s = m.addVars(n + 1, name=\"s\", vtype=GRB.INTEGER)\n",
    "\n",
    "# Production Preparation neccessary for each month (0 or 1)\n",
    "y = m.addVars(n, name=\"y\", vtype=GRB.BINARY)\n",
    "\n",
    "# Production Capacity for each month (in this case unbounded -> LS-U)\n",
    "if capacitated:\n",
    "    M = [7000, 0, 0, 0, 0, 0, 0, 0]\n",
    "else:\n",
    "    M = m.addVars(n, name=\"M\", vtype=GRB.INTEGER)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define Objective Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Objective Function to minimize the overall costs\n",
    "m.setObjective(gp.quicksum(p[i] * x[i] + q[i] * y[i] + h[i] * s[i+1] for i in t), GRB.MINIMIZE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define Constraints"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Stored products from the previous month plus the amount of products produced in the current \n",
    "# month must fulfill the demand while the rest of the products must be stored for the next month\n",
    "m.addConstrs((s[i-1] + x[i-1] == d[i-1] + s[i] for i in range(1, n+1)), \"c1\")\n",
    "m.addConstr((s[0] + x[0] == d[0] + s[1]), \"c2\")\n",
    "\n",
    "# The amount of products stored in the first month must be equal to 200 (Initial stock)\n",
    "m.addConstr(s[0] == 200, \"c3\")\n",
    "# The amount of products stored in the last month must be equal to 0 (Final stock)\n",
    "m.addConstr(s[n] == 0, \"c4\")\n",
    "\n",
    "# If products are being produced in the current month the machines must be prepared\n",
    "m.addConstrs((x[i] <= M[i]*y[i] for i in t), \"c5\")\n",
    "\n",
    "# There cant be negative amount of products stored in the warehouse or produced\n",
    "m.addConstrs((x[i] >= 0 for i in t), \"c6\")\n",
    "m.addConstrs((s[i] >= 0 for i in t), \"c7\")\n",
    "m.addConstrs((M[i] >= 0 for i in t), \"c8\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Start Model Optimization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gurobi Optimizer version 9.5.2 build v9.5.2rc0 (mac64[rosetta2])\n",
      "Thread count: 10 physical cores, 10 logical processors, using up to 10 threads\n",
      "Optimize a model with 35 rows, 33 columns and 53 nonzeros\n",
      "Model fingerprint: 0xa7ef1cf7\n",
      "Model has 8 quadratic constraints\n",
      "Variable types: 0 continuous, 33 integer (8 binary)\n",
      "Coefficient statistics:\n",
      "  Matrix range     [1e+00, 1e+00]\n",
      "  QMatrix range    [1e+00, 1e+00]\n",
      "  QLMatrix range   [1e+00, 1e+00]\n",
      "  Objective range  [5e+00, 5e+03]\n",
      "  Bounds range     [1e+00, 1e+00]\n",
      "  RHS range        [2e+02, 1e+03]\n",
      "Presolve removed 29 rows and 4 columns\n",
      "Presolve time: 0.01s\n",
      "Presolved: 30 rows, 53 columns, 74 nonzeros\n",
      "Presolved model has 16 SOS constraint(s)\n",
      "Variable types: 0 continuous, 53 integer (16 binary)\n",
      "Found heuristic solution: objective 859000.00000\n",
      "Found heuristic solution: objective 830000.00000\n",
      "Found heuristic solution: objective 822000.00000\n",
      "\n",
      "Root relaxation: objective 7.170501e+05, 13 iterations, 0.00 seconds (0.00 work units)\n",
      "\n",
      "    Nodes    |    Current Node    |     Objective Bounds      |     Work\n",
      " Expl Unexpl |  Obj  Depth IntInf | Incumbent    BestBd   Gap | It/Node Time\n",
      "\n",
      "     0     0 717050.070    0    6 822000.000 717050.070  12.8%     -    0s\n",
      "H    0     0                    737000.00000 717050.070  2.71%     -    0s\n",
      "H    0     0                    736000.00000 727633.403  1.14%     -    0s\n",
      "     0     0 736000.000    0    5 736000.000 736000.000  0.00%     -    0s\n",
      "\n",
      "Cutting planes:\n",
      "  Implied bound: 7\n",
      "  Flow cover: 1\n",
      "\n",
      "Explored 1 nodes (20 simplex iterations) in 0.04 seconds (0.00 work units)\n",
      "Thread count was 10 (of 10 available processors)\n",
      "\n",
      "Solution count 5: 736000 737000 822000 ... 859000\n",
      "\n",
      "Optimal solution found (tolerance 1.00e-04)\n",
      "Best objective 7.360000000000e+05, best bound 7.360000000000e+05, gap 0.0000%\n"
     ]
    }
   ],
   "source": [
    "m.optimize()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Produce 600.0 products in month [0]\n",
      "Produce 0.0 products in month [1]\n",
      "Produce 1600.0 products in month [2]\n",
      "Produce 0.0 products in month [3]\n",
      "Produce 1200.0 products in month [4]\n",
      "Produce 1200.0 products in month [5]\n",
      "Produce 1200.0 products in month [6]\n",
      "Produce 1200.0 products in month [7]\n",
      "--------------------------------\n",
      "Total cost: 736000.0\n"
     ]
    }
   ],
   "source": [
    "for v in m.getVars():\n",
    "    if v.varName.startswith(\"x\"):\n",
    "        print(\"Produce {} products in month {}\".format(v.x, v.varName[1:]))\n",
    "\n",
    "print(\"--------------------------------\")\n",
    "print(\"Total cost: {}\".format(m.objVal))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.7 ('base')",
   "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.7"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "355e522699fffa0542b8913d9dae891016cfafc40537c93285e01abddecb9d11"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}