convex/linear/transportation.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Transportation"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Overview\n",
    "\n",
    "In this problem, consider a set of $I$ suppliers and a set of $J$ customers. Each supplier $i$ has a limited capacity $b_{i}$ and each customer $j$ has a certain demand $d_{j}$. The transportation costs from $i$ to $j$ are given by $c_{i, j}$."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\begin{align}\n",
    "    \\text{min} \\quad & \\sum_{i \\in I} \\sum_{j \\in J} c_{i, j} x_{i, j} \\\\\n",
    "    \\text{s.t.} \\quad & \\sum_{j \\in J} x_{i, j} \\leq b_{i} & \\forall \\; i \\in I \\\\\n",
    "    & \\sum_{i \\in I} x_{i, j} = d_{j} & \\forall \\; j \\in J \\\\\n",
    "    & x_{i, j} \\geq 0 & \\forall \\; i \\in I \\;\\forall \\; j \\in J \\\\\n",
    "\\end{align}\n",
    "$$"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example\n",
    "\n",
    "Consider the following example:\n",
    "\n",
    "Table 1: Customer demands\n",
    "| Customer | Demand (lb/day) |\n",
    "| --- | --- |\n",
    "| A | 5 |\n",
    "| B | 15 |\n",
    "| C | 13 |\n",
    "| D | 17 |\n",
    "\n",
    " \n",
    "Table 2: Supplier availablity\n",
    "| Supplier | Availability ($/lb) |\n",
    "| --- | --- |\n",
    "| 1 | 14 |\n",
    "| 2 | 26 |\n",
    "| 3 | 11 |\n",
    "\n",
    "\n",
    "Table 3: Costs\n",
    "| Supplier \\ Customer | A | B | C | D |\n",
    "| --- | --- | --- | --- | --- |\n",
    "| 1 | 10 | 5 | 20 | 12 |\n",
    "| 2 | 12 | 7 | 12 | 19 |\n",
    "| 3 | 6 | 12 | 16 | 17 |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import pyomo.environ as pyo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "costs = pd.DataFrame({\n",
    "    \"A\": [10, 12, 6],\n",
    "    \"B\": [5, 7, 12],\n",
    "    \"C\": [20, 12, 16],\n",
    "    \"D\": [12, 19, 17],\n",
    "}, index=[1, 2, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = pyo.ConcreteModel()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create sets\n",
    "model.I = pyo.Set(initialize=[1, 2, 3])\n",
    "model.J = pyo.Set(initialize=[\"A\", \"B\", \"C\", \"D\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create parameters\n",
    "availability = {1: 14, 2: 26, 3: 11}\n",
    "model.b = pyo.Param(model.I, initialize=availability)\n",
    "\n",
    "demands = {\"A\": 5, \"B\": 15, \"C\": 13, \"D\": 17}\n",
    "model.d = pyo.Param(model.J, initialize=demands)\n",
    "\n",
    "c = {(i, j): costs.loc[i, j] for i in costs.index for j in costs.columns}\n",
    "model.c = pyo.Param(model.I, model.J, initialize=c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Decision variables\n",
    "model.x = pyo.Var(model.I, model.J, within=pyo.NonNegativeReals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Constraints\n",
    "def availability_rule(model, i):\n",
    "    return sum(model.x[i, j] for j in model.J) <= model.b[i]\n",
    "\n",
    "model.availability_constr = pyo.Constraint(model.I, rule=availability_rule)\n",
    "\n",
    "def demand_rule(model, j):\n",
    "    return sum(model.x[i, j] for i in model.I) == model.d[j]\n",
    "\n",
    "model.demand_constr = pyo.Constraint(model.J, rule=demand_rule)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Objective\n",
    "model.obj = pyo.Objective(expr=sum(model.x[i, j] * model.c[i, j] for (i, j) in model.x), sense=pyo.minimize)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solve\n",
    "cbc = pyo.SolverFactory(\"cbc\")\n",
    "sol = cbc.solve(model, tee=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "results = pd.DataFrame(index=model.I, columns=model.J)\n",
    "for i, j in model.x:\n",
    "    results.loc[i, j] = model.x[i, j].value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "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>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>12.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.0</td>\n",
       "      <td>13.0</td>\n",
       "      <td>13.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>5.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     A     B     C     D\n",
       "1  0.0   2.0   0.0  12.0\n",
       "2  0.0  13.0  13.0   0.0\n",
       "3  5.0   0.0   0.0   5.0"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "venv",
   "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
 },
 "nbformat": 4,
 "nbformat_minor": 2
}