7 | 
8 | B전자는 최근 자사 제품의 수요가 급증하여 새로운 제품을 생산할 공장을 신축하기 위하여 3개의 공장 후보지를 선정하였다. B전자는 현재 각 공장에서 생산된 제품을 4개의 물류센터에 공급하고 있으므로 새로 신축할 공장에서 생산될 제품도 4개의 물류센터에 공급하려고 한다. 3개의 공장 후보지의 월 공급능력(개), 월 고정비(천원), 각 공장 후보지에서 4개의 물류센터까지의 수송단가(천원) 및 각 물류센터의 월 수요량(개)은 Table과 같다. B전자의 총비용을 최소로 하는 공장 후보지와 각 신축 공장에서 각 물류센터로의 최적 수송계획을 수립하기 위한 정수계획모형을 작성하고 최적해와 총비용을 구하라.
\n", 14 | "\n", 15 | "| 파출소 후보지역 | \n", 19 | "파출소 설치비용(천만원) | \n", 20 | "8분 이내 도착가능 후보지역 | \n", 21 | "
|---|---|---|
| 1 | \n", 24 | "6 | \n", 25 | "1, 2, 3, 4, 5 | \n", 26 | "
| 2 | \n", 29 | "7 | \n", 30 | "1, 2, 4, 5, 9 | \n", 31 | "
| 3 | \n", 34 | "5 | \n", 35 | "1, 3, 4, 5, 6, 7, 8 | \n", 36 | "
| 4 | \n", 39 | "7 | \n", 40 | "1, 2, 3, 4, 5, 6, 9 | \n", 41 | "
| 5 | \n", 44 | "9 | \n", 45 | "1, 2, 3, 4, 5, 9 | \n", 46 | "
| 6 | \n", 49 | "10 | \n", 50 | "3, 4, 6, 7, 8 | \n", 51 | "
| 7 | \n", 54 | "8 | \n", 55 | "3, 5, 7, 8, 9 | \n", 56 | "
| 8 | \n", 59 | "5 | \n", 60 | "3, 6, 7, 8, 9 | \n", 61 | "
| 9 | \n", 64 | "11 | \n", 65 | "2, 4, 5, 7, 8, 9 | \n", 66 | "
2 |
3 | # or-tutorial
4 |
5 |
6 |
7 |
8 |
9 |
차량 경로 문제(vehicle routing problem, VRP)는 Dantzig and Ramser (1959 )에 의해 제안되었으며 이후 다양한 연구가 진행되어 왔습니다. VRP의 기본 가정은 $n$개의 목적지에 $k$대 차량이 단일 물류 창고를 중심으로 최소비용 또는 최소거리로 운송할 수 있는 경로를 구하는 문제입니다.
\n", 10 | "\n", 11 | "## SOVLING A VEHICLE ROUTING PROBLEM\n", 12 | "\n", 13 | "### Mathematical Modeling\n", 14 | "\n", 15 | "\n", 16 | "\n", 17 | "$$x_{ij} = \n", 18 | "\\begin{cases}\n", 19 | " 1, \\; \\text{if $i$ is supplied before $j$ by vehicle $k$,}\\\\\n", 20 | " 0, \\; \\text{otherwise}\n", 21 | "\\end{cases}$$\n", 22 | "\n", 23 | "위의 의사결정변수와 파라미터를 이용하여 총 거리의 합을 최소화하는 정수 계획법의 목적함수는 식(1)과 같습니다.
\n", 24 | "\n", 25 | "$$\\begin{align*}\n", 26 | " & \\text{minimize } & & \\sum_{i=1}^{n} \\sum_{j=1}^{n} c_{ij}x_{ij} \\\\[1ex]\n", 27 | " & \\text{subject to } & \\, & \\sum_{i=1}^{n} x_{ij} = 1, & \\quad & \\forall j = 1, \\dots, n\\\\[1ex]\n", 28 | " & & \\, & \\sum_{j=1}^{n} x_{ij} = 1, & \\quad & \\forall j = 1, \\dots, n\\\\[1ex] \n", 29 | " & & \\, & \\sum_{i=1}^{n} x_{i0} = K, & \\quad \\\\[1ex] \n", 30 | " & & \\, & \\sum_{j=1}^{n} x_{0j} = K, & \\quad \\\\[1ex] \n", 31 | "\\end{align*}$$\n", 32 | "\n", 33 | "" 34 | ] 35 | }, 36 | { 37 | "cell_type": "code", 38 | "execution_count": 1, 39 | "metadata": {}, 40 | "outputs": [ 41 | { 42 | "data": { 43 | "text/plain": [ 44 | "array([[ 0, 42, 73, 87, 66, 46, 91, 35, 62, 55],\n", 45 | " [ 42, 0, 108, 99, 84, 85, 98, 13, 72, 64],\n", 46 | " [ 73, 108, 0, 60, 46, 29, 71, 96, 60, 61],\n", 47 | " [ 87, 99, 60, 0, 21, 71, 11, 86, 27, 35],\n", 48 | " [ 66, 84, 46, 21, 0, 50, 29, 70, 16, 21],\n", 49 | " [ 46, 85, 29, 71, 50, 0, 80, 74, 58, 56],\n", 50 | " [ 91, 98, 71, 11, 29, 80, 0, 86, 29, 36],\n", 51 | " [ 35, 13, 96, 86, 70, 74, 86, 0, 59, 51],\n", 52 | " [ 62, 72, 60, 27, 16, 58, 29, 59, 0, 8],\n", 53 | " [ 55, 64, 61, 35, 21, 56, 36, 51, 8, 0]], dtype=int32)" 54 | ] 55 | }, 56 | "execution_count": 1, 57 | "metadata": {}, 58 | "output_type": "execute_result" 59 | } 60 | ], 61 | "source": [ 62 | "from utils import GenerateCities\n", 63 | "\n", 64 | "coords, cities = GenerateCities(100, 100, 10, 42).generate()\n", 65 | "cities" 66 | ] 67 | }, 68 | { 69 | "cell_type": "markdown", 70 | "metadata": {}, 71 | "source": [ 72 | "### Mixed Integer Programming using PuLP\n", 73 | "\n", 74 | "이제 파이썬을 활용하여 외판원 문제의 최적해를 구해보겠습니다. 파이썬을 활용한 경영과학(MS/OR)은 추후 기초부터 포스팅을 할 예정입니다.
" 75 | ] 76 | }, 77 | { 78 | "cell_type": "code", 79 | "execution_count": 2, 80 | "metadata": {}, 81 | "outputs": [ 82 | { 83 | "name": "stdout", 84 | "output_type": "stream", 85 | "text": [ 86 | "296.0\n", 87 | "u_1 = 9.0\n", 88 | "u_2 = 1.0\n", 89 | "u_3 = 3.0\n", 90 | "u_4 = 2.0\n", 91 | "u_5 = 0.0\n", 92 | "u_6 = 4.0\n", 93 | "u_7 = 8.0\n", 94 | "u_8 = 6.0\n", 95 | "u_9 = 7.0\n", 96 | "x_(0,_5) = 1.0\n", 97 | "x_(1,_0) = 1.0\n", 98 | "x_(2,_4) = 1.0\n", 99 | "x_(3,_6) = 1.0\n", 100 | "x_(4,_3) = 1.0\n", 101 | "x_(5,_2) = 1.0\n", 102 | "x_(6,_8) = 1.0\n", 103 | "x_(7,_1) = 1.0\n", 104 | "x_(8,_9) = 1.0\n", 105 | "x_(9,_7) = 1.0\n" 106 | ] 107 | } 108 | ], 109 | "source": [ 110 | "from pulp import *\n", 111 | "\n", 112 | "# Initialize vehicle routing problem\n", 113 | "prob = LpProblem('Vehicle Routing', LpMinimize)\n", 114 | "\n", 115 | "K = 4\n", 116 | "n = len(cities)\n", 117 | "indices = [(i, j) for i in range(n) for j in range(n) if i != j]\n", 118 | "\n", 119 | "# Creating decision variables\n", 120 | "x = LpVariable.dicts('x', indices, cat='Binary')\n", 121 | "u = LpVariable.dicts('u', list(range(n)), lowBound=0, upBound=n-1, cat='Continuous')\n", 122 | "\n", 123 | "# Objective function\n", 124 | "prob += lpSum([cities[i][j] * x[(i,j)] for i, j in indices])\n", 125 | "\n", 126 | "# Constraints\n", 127 | "for i in range(n):\n", 128 | " if i != 0:\n", 129 | " prob += lpSum([x[(i,j)] for j in range(n) if i != j]) == 1\n", 130 | " \n", 131 | "for j in range(n):\n", 132 | " if j != 0:\n", 133 | " prob += lpSum([x[(i,j)] for i in range(n) if i != j]) == 1\n", 134 | " \n", 135 | "for i in range(1, n):\n", 136 | " for j in range(1, n):\n", 137 | " if i != j:\n", 138 | " prob += u[i] - u[j] + len(cities) * x[(i,j)] <= len(cities) - 1\n", 139 | "\n", 140 | "# Solve problem\n", 141 | "prob.solve()\n", 142 | "print(value(prob.objective))\n", 143 | "\n", 144 | "for i in prob.variables():\n", 145 | " if i.name[0] == 'u':\n", 146 | " print(i.name, '=', i.varValue)\n", 147 | " elif i.varValue != 0:\n", 148 | " print(i.name, '=', i.varValue)" 149 | ] 150 | }, 151 | { 152 | "cell_type": "markdown", 153 | "metadata": {}, 154 | "source": [ 155 | "## CONCLUSION\n", 156 | "\n", 157 | "차량 경로 문제는
\n", 158 | "\n", 159 | "해당 포스트는 지속적으로 업데이트 할 예정이니 오타, 틀린부분, 파이써닉(pythonic)하지 못한 코드가 있을 경우 지적해주시면 수정하도록 하겠습니다.
\n", 160 | "\n", 161 | "## REFERENCES\n", 162 | "\n", 163 | "1. 이강우 & 김정자 (2010). _경영과학_, 한경사.\n", 164 | "2. Rasmussen, R. (2011). TSP in Spreadsheets–a Guided Tour. _International Review of Economics Education_, 10(1), 94-116.\n", 165 | "3. Hillier, F. S. & Lieberman, G. J. (2013). _Introduction to Operations Research_. McGraw-Hill Science, Engineering & Mathematics.\n", 166 | "4. Bello, I., Pham, H., Le, Q. V., Norouzi, M., & Bengio, S. (2016). Neural Combinatorial Optimization with Reinforcement Learning. _arXiv preprint arXiv:1611.09940_." 167 | ] 168 | }, 169 | { 170 | "cell_type": "code", 171 | "execution_count": null, 172 | "metadata": {}, 173 | "outputs": [], 174 | "source": [] 175 | } 176 | ], 177 | "metadata": { 178 | "kernelspec": { 179 | "display_name": "Python 3", 180 | "language": "python", 181 | "name": "python3" 182 | }, 183 | "language_info": { 184 | "codemirror_mode": { 185 | "name": "ipython", 186 | "version": 3 187 | }, 188 | "file_extension": ".py", 189 | "mimetype": "text/x-python", 190 | "name": "python", 191 | "nbconvert_exporter": "python", 192 | "pygments_lexer": "ipython3", 193 | "version": "3.7.3" 194 | } 195 | }, 196 | "nbformat": 4, 197 | "nbformat_minor": 4 198 | } 199 | -------------------------------------------------------------------------------- /or-tutorial/linear-programming/product-mix.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Linear Programming\n", 8 | "\n", 9 | "### Product Mix Problem\n", 10 | "\n", 11 | "**이강우 & 김정자. (2012). _EXCEL 2010 경영과학_. 한경사, 32.**\n", 12 | "\n", 13 | "D기업은 두 종류의 원료와 한 종류의 기계를 사용하여 제품 A와 제품 B를 생산하여 판매하고 있다. 각 제품을 1단위 생산할 때 필요한 원료의 사용량과 기계사용시간은 다음 Table 1과 같다.
\n", 14 | "\n", 15 | "| 자원 | \n", 19 | "A | \n", 20 | "B | \n", 21 | "월 가용량 | \n", 22 | "
|---|---|---|---|
| 원료 1(kg) | \n", 25 | "10 | \n", 26 | "5 | \n", 27 | "300 | \n", 28 | "
| 원료 2(kg) | \n", 31 | "4 | \n", 32 | "4 | \n", 33 | "160 | \n", 34 | "
| 기계사용시간(시간) | \n", 37 | "2 | \n", 38 | "6 | \n", 39 | "180 | \n", 40 | "
| 단위당 이익(만원/개) | \n", 43 | "3 | \n", 44 | "2 | \n", 45 | "\n", 46 | " |
한편 D기업이 보유하고 있는 원료 1과 원료 2의 월 가용량은 각각 300kg, 160kg이고 기계사용시간의 월 가용시간은 180시간이며 생산된 제품 A와 제품 B를 판매하면 각각 단위당 3만원과 2만원의 이익이 발생한다고 한다. D기업에 주어진 한정된 자원을 사용하여 D기업의 월 이익을 최대로 하는 제품 A와 제품 B의 월 생산량을 구하기 위한 선형계획모형을 작성하라.
| Items | \n", 19 | "Weights (kg) | \n", 20 | "Values | \n", 21 | "Max weight (kg) | \n", 22 | "
|---|---|---|---|
| 1 | \n", 25 | "3 | \n", 26 | "6 | \n", 27 | "6 | \n", 28 | "
| 2 | \n", 31 | "4 | \n", 32 | "8 | \n", 33 | "|
| 3 | \n", 36 | "2 | \n", 37 | "3 | \n", 38 | "
단일품목 배낭문제의 최적 정수해를 구하기 위한 정수계획모형을 정식화하기 위하여 품목 1, 품목2, 품목 3을 각각 결정변수 $X_{1}$, $X_{2}$, $X_{3}$이라고 정의하고 다음과 같이 $0-1$변수로 정의하자.
\n", 42 | "\n", 43 | "$$X_{j} = \\begin{cases}1: \\text{if item $j$ is selected } (j=1,2,3)\\\\\n", 44 | "0: \\text{if item $j$ is not selected } (j=1,2,3)\n", 45 | "\\end{cases}$$\n", 46 | "\n", 47 | "위에서 정의한 결정변수를 이용하여 배낭에 넣어 갖고 갈 수 있는 품목의 효용을 최대화하는 목적함수와 배낭의 보관능력에 대한 제약식을 정식화하면 다음과 같다.
\n", 48 | "\n", 49 | "$$\\begin{align*}\n", 50 | " & \\text{maximize } & Z=7&X_{1} + 8X_{2} + 3X_{3} \\\\\n", 51 | " & \\text{subject to } & \\, 3&X_{1} + 4X_{2} + 2X_{3} \\le 6 \\\\\n", 52 | " & \\text{and} & \\, &X_{j} = 0 \\text{ or } 1 (j=1,2,3)\n", 53 | "\\end{align*}$$" 54 | ] 55 | }, 56 | { 57 | "cell_type": "code", 58 | "execution_count": 13, 59 | "metadata": {}, 60 | "outputs": [], 61 | "source": [ 62 | "import os\n", 63 | "import sys\n", 64 | "\n", 65 | "# Add the parent directory for importing custom library\n", 66 | "sys.path.insert(0, os.path.abspath(os.path.join(os.getcwd(), os.pardir)))" 67 | ] 68 | }, 69 | { 70 | "cell_type": "markdown", 71 | "metadata": {}, 72 | "source": [ 73 | "#### Optimization with PuLP" 74 | ] 75 | }, 76 | { 77 | "cell_type": "code", 78 | "execution_count": 14, 79 | "metadata": {}, 80 | "outputs": [ 81 | { 82 | "name": "stdout", 83 | "output_type": "stream", 84 | "text": [ 85 | "Status: Optimal\n", 86 | "Objective value: 11.0\n", 87 | "\n", 88 | "Variables Values\n", 89 | "----------- --------\n", 90 | "X1 0\n", 91 | "X2 1\n", 92 | "X3 1\n", 93 | "\n", 94 | "Statistics:\n", 95 | "- Number of variables: 3\n", 96 | "- Number of constraints: 1\n", 97 | "- Solve time: 0.006s\n" 98 | ] 99 | } 100 | ], 101 | "source": [ 102 | "from pulp import *\n", 103 | "from ortools.utils import output\n", 104 | "\n", 105 | "# Define problem\n", 106 | "prob = LpProblem('Knapsack Problem', LpMaximize)\n", 107 | "\n", 108 | "# Create decision variables and non-negative constraint\n", 109 | "x1 = LpVariable(name='X1', lowBound=0, cat='Binary')\n", 110 | "x2 = LpVariable(name='X2', lowBound=0, cat='Binary')\n", 111 | "x3 = LpVariable(name='X3', lowBound=0, cat='Binary')\n", 112 | "\n", 113 | "# Set objective function\n", 114 | "prob += 7*x1 + 8*x2 + 3*x3\n", 115 | "\n", 116 | "# Set constraints\n", 117 | "prob += 3*x1 + 4*x2 + 2*x3 <= 6\n", 118 | "\n", 119 | "# Solving problem\n", 120 | "prob.solve()\n", 121 | "output(prob)" 122 | ] 123 | }, 124 | { 125 | "cell_type": "code", 126 | "execution_count": 15, 127 | "metadata": {}, 128 | "outputs": [ 129 | { 130 | "name": "stdout", 131 | "output_type": "stream", 132 | "text": [ 133 | "Status: Optimal\n", 134 | "Objective value: 11.0\n", 135 | "\n", 136 | "Variables Values\n", 137 | "----------- --------\n", 138 | "x_0 0\n", 139 | "x_1 1\n", 140 | "x_2 1\n", 141 | "\n", 142 | "Statistics:\n", 143 | "- Number of variables: 3\n", 144 | "- Number of constraints: 1\n", 145 | "- Solve time: 0.006s\n" 146 | ] 147 | } 148 | ], 149 | "source": [ 150 | "from pulp import *\n", 151 | "from ortools.utils import output\n", 152 | "\n", 153 | "n_items = 3\n", 154 | "weights = [3, 4, 2]\n", 155 | "values = [7, 8, 3]\n", 156 | "max_weight = 6\n", 157 | "\n", 158 | "# Define problem\n", 159 | "prob = LpProblem('Knapsack Problem', LpMaximize)\n", 160 | "\n", 161 | "# Create decision variables\n", 162 | "x = LpVariable.dicts('x', [i for i in range(n_items)], lowBound=0, cat='Binary')\n", 163 | "\n", 164 | "# Set objective function\n", 165 | "prob += lpSum([values[i]*x[i] for i in range(n_items)])\n", 166 | "\n", 167 | "# Set constraints\n", 168 | "prob += lpSum([weights[i]*x[i] for i in range(n_items)]) <= max_weight\n", 169 | "\n", 170 | "# Solving problem\n", 171 | "prob.solve()\n", 172 | "output(prob)" 173 | ] 174 | }, 175 | { 176 | "cell_type": "markdown", 177 | "metadata": {}, 178 | "source": [ 179 | "#### Optimization with GUROBI" 180 | ] 181 | }, 182 | { 183 | "cell_type": "code", 184 | "execution_count": 16, 185 | "metadata": {}, 186 | "outputs": [ 187 | { 188 | "name": "stdout", 189 | "output_type": "stream", 190 | "text": [ 191 | "Status: Optimal\n", 192 | "Objective value: 11.0\n", 193 | "\n", 194 | "Variables Values\n", 195 | "----------- --------\n", 196 | "X0 0\n", 197 | "X1 1\n", 198 | "X2 1\n", 199 | "\n", 200 | "Statistics:\n", 201 | "- Number of variables: 3\n", 202 | "- Number of constraints: 1\n", 203 | "- Solve time: 0.000s\n" 204 | ] 205 | } 206 | ], 207 | "source": [ 208 | "from gurobipy import *\n", 209 | "from ortools.utils import set_gurobi, custom_callback, output\n", 210 | "\n", 211 | "n_items = 3\n", 212 | "weights = [3, 4, 2]\n", 213 | "values = [7, 8, 3]\n", 214 | "max_weight = 6\n", 215 | "\n", 216 | "# Define problem\n", 217 | "m = Model('Knapsack Problem')\n", 218 | "\n", 219 | "# Create decision variables\n", 220 | "x = [m.addVar(vtype=GRB.BINARY, name='X{}'.format(i)) for i in range(n_items)]\n", 221 | "m.update()\n", 222 | "\n", 223 | "# Set objective function\n", 224 | "m.setObjective(quicksum(values[i]*x[i] for i in range(n_items)), GRB.MAXIMIZE)\n", 225 | "\n", 226 | "# Set constraints\n", 227 | "m.addConstr(quicksum(weights[i]*x[i] for i in range(n_items)) <= max_weight)\n", 228 | "\n", 229 | "set_gurobi(m, verbose=False)\n", 230 | "\n", 231 | "# Optimize model\n", 232 | "m.optimize(custom_callback)\n", 233 | "output(m)" 234 | ] 235 | } 236 | ], 237 | "metadata": { 238 | "kernelspec": { 239 | "display_name": "Python 3", 240 | "language": "python", 241 | "name": "python3" 242 | }, 243 | "language_info": { 244 | "codemirror_mode": { 245 | "name": "ipython", 246 | "version": 3 247 | }, 248 | "file_extension": ".py", 249 | "mimetype": "text/x-python", 250 | "name": "python", 251 | "nbconvert_exporter": "python", 252 | "pygments_lexer": "ipython3", 253 | "version": "3.7.3" 254 | }, 255 | "latex_envs": { 256 | "LaTeX_envs_menu_present": true, 257 | "autocomplete": true, 258 | "bibliofile": "biblio.bib", 259 | "cite_by": "apalike", 260 | "current_citInitial": 1, 261 | "eqLabelWithNumbers": true, 262 | "eqNumInitial": 1, 263 | "hotkeys": { 264 | "equation": "Ctrl-E", 265 | "itemize": "Ctrl-I" 266 | }, 267 | "labels_anchors": false, 268 | "latex_user_defs": false, 269 | "report_style_numbering": false, 270 | "user_envs_cfg": false 271 | }, 272 | "varInspector": { 273 | "cols": { 274 | "lenName": 16, 275 | "lenType": 16, 276 | "lenVar": 40 277 | }, 278 | "kernels_config": { 279 | "python": { 280 | "delete_cmd_postfix": "", 281 | "delete_cmd_prefix": "del ", 282 | "library": "var_list.py", 283 | "varRefreshCmd": "print(var_dic_list())" 284 | }, 285 | "r": { 286 | "delete_cmd_postfix": ") ", 287 | "delete_cmd_prefix": "rm(", 288 | "library": "var_list.r", 289 | "varRefreshCmd": "cat(var_dic_list()) " 290 | } 291 | }, 292 | "types_to_exclude": [ 293 | "module", 294 | "function", 295 | "builtin_function_or_method", 296 | "instance", 297 | "_Feature" 298 | ], 299 | "window_display": false 300 | } 301 | }, 302 | "nbformat": 4, 303 | "nbformat_minor": 4 304 | } 305 | -------------------------------------------------------------------------------- /or-tutorial/integer-programming/set-covering.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Integer Programming\n", 8 | "\n", 9 | "### Set Covering Problem\n", 10 | "\n", 11 | "**이강우 & 김정자. (2012). EXCEL 2010 경영과학. 한경사, 405.**\n", 12 | "\n", 13 | "해운대구는 최근 신시가지 개발의 완료와 더불어 각종 범죄가 급속도로 지능화, 신속화, 흉악화 되어가고 있다. 따라서 부산시경에서는 수사의 신속성과 기동성을 확보함으로써 수사의 효율성을 제고하기 이ㅜ하여 해운대구에 파출소를 설치하기로 결정하고 해운대구에서 범죄 발생빈도가 높은 파출소의 후보지역을 조사한 결과 9개 지역으로 나타났다. 부산시경에서는 해운대구에서 조사된 범죄 발생빈도가 높은 9개 지역을 파출소의 설치대상 후보지역으로 선정하고 범죄가 발생할 때 최대로 8분 이내에 범죄 현장에 도착할 수 있도록 이 후보지역 중에서 특정 지역을 선정하여 파출소를 설치하려고 한다. Table은 각 후보지역의 파출소 설치비용과 각 후보지역을 기준으로 8분 이내에 범죄현장에 도착할 수 있는 후보지역을 조사한 결과이다.
\n", 14 | "\n", 15 | "| 파출소 후보지역 | \n", 19 | "파출소 설치비용(천만원) | \n", 20 | "8분 이내 도착가능 후보지역 | \n", 21 | "
|---|---|---|
| 1 | \n", 24 | "6 | \n", 25 | "1, 2, 3, 4, 5 | \n", 26 | "
| 2 | \n", 29 | "7 | \n", 30 | "1, 2, 4, 5, 9 | \n", 31 | "
| 3 | \n", 34 | "5 | \n", 35 | "1, 3, 4, 5, 6, 7, 8 | \n", 36 | "
| 4 | \n", 39 | "7 | \n", 40 | "1, 2, 3, 4, 5, 6, 9 | \n", 41 | "
| 5 | \n", 44 | "9 | \n", 45 | "1, 2, 3, 4, 5, 9 | \n", 46 | "
| 6 | \n", 49 | "10 | \n", 50 | "3, 4, 6, 7, 8 | \n", 51 | "
| 7 | \n", 54 | "8 | \n", 55 | "3, 5, 7, 8, 9 | \n", 56 | "
| 8 | \n", 59 | "5 | \n", 60 | "3, 6, 7, 8, 9 | \n", 61 | "
| 9 | \n", 64 | "11 | \n", 65 | "2, 4, 5, 7, 8, 9 | \n", 66 | "
D전자는 통신장비를 생산하여 판매하고 있는 회사이며 최근 개발한 신제품의 판매시장을 국내, 아시아지역, 유럽지역으로 확장하려고 한다. 이를 위하여 각 지역별 시장조사를 한 결과 수집된 자료는 표와 같다.
\n", 14 | "\n", 15 | "| 지역 | \n", 19 | "단위당 판매이익(만원) | \n", 20 | "단위당 광고비용(만원) | \n", 21 | "단위당 판매활동시간(시간) | \n", 22 | "
|---|---|---|---|
| 국내 | \n", 25 | "6 | \n", 26 | "1.0 | \n", 27 | "1.5 | \n", 28 | "
| 아시아 | \n", 31 | "4 | \n", 32 | "0.8 | \n", 33 | "2.0 | \n", 34 | "
| 유럽 | \n", 37 | "7 | \n", 38 | "1.5 | \n", 39 | "3.0 | \n", 40 | "
D전자의 신제품 생산능력은 1개월에 3,500개이고 1개월 동안 아시아 지역에 최소한 500개를 공급할 계획을 가지고 있다. 그리고 D전자의 판매원의 판매활동시간은 1개월에 총 5,000시간이며 1개월 광고비 예산은 3,000만원이다. 한편 D전자는 주문생산을 원칙으로 하고 있기 대문에 재고는 보유하지 않는다. D전자의 월 판매이익을 최대로 하는 지역별 신제품의 판매량을 구하기 위한 선형계획 모형을 작성하여 지역별 최적 판매계획을 수립하고 민감도분석을 수행하라.
" 44 | ] 45 | }, 46 | { 47 | "cell_type": "code", 48 | "execution_count": 1, 49 | "metadata": {}, 50 | "outputs": [], 51 | "source": [ 52 | "import os\n", 53 | "import sys\n", 54 | "\n", 55 | "# Add the parent directory for importing custom library\n", 56 | "sys.path.insert(0, os.path.abspath(os.path.join(os.getcwd(), os.pardir)))" 57 | ] 58 | }, 59 | { 60 | "cell_type": "markdown", 61 | "metadata": {}, 62 | "source": [ 63 | "#### Optimization with PuLP" 64 | ] 65 | }, 66 | { 67 | "cell_type": "code", 68 | "execution_count": 2, 69 | "metadata": {}, 70 | "outputs": [ 71 | { 72 | "name": "stdout", 73 | "output_type": "stream", 74 | "text": [ 75 | "Status: Optimal\n" 76 | ] 77 | } 78 | ], 79 | "source": [ 80 | "from pulp import *\n", 81 | "\n", 82 | "# Define problem\n", 83 | "prob = LpProblem(name='Marketing', sense=LpMaximize)\n", 84 | "\n", 85 | "# Create decision variables and non-negative constraint\n", 86 | "x1 = LpVariable(name='X1', lowBound=0, upBound=None, cat='Continuous')\n", 87 | "x2 = LpVariable(name='X2', lowBound=0, upBound=None, cat='Continuous')\n", 88 | "x3 = LpVariable(name='X3', lowBound=0, upBound=None, cat='Continuous')\n", 89 | "\n", 90 | "# Set objective function\n", 91 | "prob += 6*x1 + 4*x2 + 7*x3\n", 92 | "\n", 93 | "# Set constraints\n", 94 | "prob += 1.0*x1 + 0.8*x2 + 1.5*x3 <= 3000\n", 95 | "prob += 1.5*x1 + 2.0*x2 + 3.0*x3 <= 5000\n", 96 | "prob += x1 + x2 + x3 <= 3500\n", 97 | "prob += x2 >= 500\n", 98 | "\n", 99 | "# Solving problem\n", 100 | "prob.solve()\n", 101 | "print('Status: {}'.format(LpStatus[prob.status]))" 102 | ] 103 | }, 104 | { 105 | "cell_type": "code", 106 | "execution_count": 3, 107 | "metadata": {}, 108 | "outputs": [ 109 | { 110 | "name": "stdout", 111 | "output_type": "stream", 112 | "text": [ 113 | "Z = 17600.0\n", 114 | "X1 = 2600.0\tReduced cost 0.0\n", 115 | "X2 = 500.0\tReduced cost -8.8817842e-16\n", 116 | "X3 = 0.0\tReduced cost -2.0\n" 117 | ] 118 | } 119 | ], 120 | "source": [ 121 | "print('Z = {}'.format(value(prob.objective)))\n", 122 | "for v in prob.variables():\n", 123 | " print('{} = {}\\tReduced cost {}'.format(v.name, v.varValue, v.dj))" 124 | ] 125 | }, 126 | { 127 | "cell_type": "code", 128 | "execution_count": 4, 129 | "metadata": {}, 130 | "outputs": [ 131 | { 132 | "name": "stdout", 133 | "output_type": "stream", 134 | "text": [ 135 | "Sensitivity Analysis\n", 136 | "Constraint\tShadow Price\tSlack\n", 137 | "_C1: \t\t6.0\t\t-0.0\n", 138 | "_C2: \t\t-0.0\t\t100.0\n", 139 | "_C3: \t\t-0.0\t\t400.0\n", 140 | "_C4: \t\t-0.8\t\t-0.0\n" 141 | ] 142 | } 143 | ], 144 | "source": [ 145 | "print('Sensitivity Analysis\\nConstraint\\tShadow Price\\tSlack')\n", 146 | "for name, c in prob.constraints.items():\n", 147 | " print('{}: \\t\\t{}\\t\\t{}'.format(name, c.pi, c.slack))" 148 | ] 149 | }, 150 | { 151 | "cell_type": "markdown", 152 | "metadata": {}, 153 | "source": [ 154 | "#### Optimization with GUROBI" 155 | ] 156 | }, 157 | { 158 | "cell_type": "code", 159 | "execution_count": 5, 160 | "metadata": {}, 161 | "outputs": [ 162 | { 163 | "name": "stdout", 164 | "output_type": "stream", 165 | "text": [ 166 | "Status: Optimal\n" 167 | ] 168 | } 169 | ], 170 | "source": [ 171 | "from gurobipy import *\n", 172 | "from ortools.utils import set_gurobi, custom_callback\n", 173 | "\n", 174 | "# Create a new model\n", 175 | "m = Model(name='Marketing')\n", 176 | "\n", 177 | "# Create variables\n", 178 | "x1 = m.addVar(lb=0, ub=1e+100, vtype=GRB.CONTINUOUS, name='X1')\n", 179 | "x2 = m.addVar(lb=0, ub=1e+100, vtype=GRB.CONTINUOUS, name='X2')\n", 180 | "x3 = m.addVar(lb=0, ub=1e+100, vtype=GRB.CONTINUOUS, name='X3')\n", 181 | "\n", 182 | "# Set objective\n", 183 | "m.setObjective(6*x1 + 4*x2 + 7*x3, sense=GRB.MAXIMIZE)\n", 184 | "\n", 185 | "# Add constraint\n", 186 | "m.addConstr(1.0*x1 + 0.8*x2 + 1.5*x3 <= 3000)\n", 187 | "m.addConstr(1.5*x1 + 2.0*x2 + 3.0*x3 <= 5000)\n", 188 | "m.addConstr(x1 + x2 + x3 <= 3500)\n", 189 | "m.addConstr(x2 >= 500)\n", 190 | "\n", 191 | "set_gurobi(m, verbose=False)\n", 192 | "\n", 193 | "# Optimize model\n", 194 | "m.optimize(custom_callback)\n", 195 | "if m.status == GRB.Status.OPTIMAL:\n", 196 | " print('Status: Optimal')" 197 | ] 198 | }, 199 | { 200 | "cell_type": "code", 201 | "execution_count": 6, 202 | "metadata": {}, 203 | "outputs": [ 204 | { 205 | "name": "stdout", 206 | "output_type": "stream", 207 | "text": [ 208 | "Z = 17600.0\n", 209 | "X1 = 2600.0\tReduced cost 0.0\n", 210 | "X2 = 500.0\tReduced cost 0.0\n", 211 | "X3 = 0.0\tReduced cost -2.0\n" 212 | ] 213 | } 214 | ], 215 | "source": [ 216 | "print('Z = {}'.format(m.objVal))\n", 217 | "for v in m.getVars():\n", 218 | " print('{} = {}\\tReduced cost {}'.format(v.varName, v.x, v.RC))" 219 | ] 220 | }, 221 | { 222 | "cell_type": "code", 223 | "execution_count": 7, 224 | "metadata": {}, 225 | "outputs": [ 226 | { 227 | "name": "stdout", 228 | "output_type": "stream", 229 | "text": [ 230 | "Sensitivity Analysis\n", 231 | "Constraint\tShadow Price\tSlack\n", 232 | "R0: \t\t6.0\t\t0.0\n", 233 | "R1: \t\t0.0\t\t100.0\n", 234 | "R2: \t\t0.0\t\t400.0\n", 235 | "R3: \t\t-0.8000000000000007\t\t0.0\n" 236 | ] 237 | } 238 | ], 239 | "source": [ 240 | "print('Sensitivity Analysis\\nConstraint\\tShadow Price\\tSlack')\n", 241 | "for c in m.getConstrs():\n", 242 | " print('{}: \\t\\t{}\\t\\t{}'.format(c.ConstrName, c.Pi, c.Slack))" 243 | ] 244 | } 245 | ], 246 | "metadata": { 247 | "kernelspec": { 248 | "display_name": "Python 3", 249 | "language": "python", 250 | "name": "python3" 251 | }, 252 | "language_info": { 253 | "codemirror_mode": { 254 | "name": "ipython", 255 | "version": 3 256 | }, 257 | "file_extension": ".py", 258 | "mimetype": "text/x-python", 259 | "name": "python", 260 | "nbconvert_exporter": "python", 261 | "pygments_lexer": "ipython3", 262 | "version": "3.7.3" 263 | }, 264 | "latex_envs": { 265 | "LaTeX_envs_menu_present": true, 266 | "autocomplete": true, 267 | "bibliofile": "biblio.bib", 268 | "cite_by": "apalike", 269 | "current_citInitial": 1, 270 | "eqLabelWithNumbers": true, 271 | "eqNumInitial": 1, 272 | "hotkeys": { 273 | "equation": "Ctrl-E", 274 | "itemize": "Ctrl-I" 275 | }, 276 | "labels_anchors": false, 277 | "latex_user_defs": false, 278 | "report_style_numbering": false, 279 | "user_envs_cfg": false 280 | }, 281 | "varInspector": { 282 | "cols": { 283 | "lenName": 16, 284 | "lenType": 16, 285 | "lenVar": 40 286 | }, 287 | "kernels_config": { 288 | "python": { 289 | "delete_cmd_postfix": "", 290 | "delete_cmd_prefix": "del ", 291 | "library": "var_list.py", 292 | "varRefreshCmd": "print(var_dic_list())" 293 | }, 294 | "r": { 295 | "delete_cmd_postfix": ") ", 296 | "delete_cmd_prefix": "rm(", 297 | "library": "var_list.r", 298 | "varRefreshCmd": "cat(var_dic_list()) " 299 | } 300 | }, 301 | "types_to_exclude": [ 302 | "module", 303 | "function", 304 | "builtin_function_or_method", 305 | "instance", 306 | "_Feature" 307 | ], 308 | "window_display": false 309 | } 310 | }, 311 | "nbformat": 4, 312 | "nbformat_minor": 4 313 | } 314 | -------------------------------------------------------------------------------- /or-tutorial/linear-programming/unbalanced-transportation.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Linear Programmign Model\n", 8 | "\n", 9 | "### Unbalanced Transportation Problem\n", 10 | "\n", 11 | "**이강우 & 김정자. (2012). _EXCEL 2010 경영과학_. 한경사, 306.**\n", 12 | "\n", 13 | "현실의 수송문제는 총 공급량과 총 수요량이 일치하는 경우는 거의 없으며 이들이 서로 일치하지 않는 공급과잉이나 수요과잉이 발생하는 것이 일반적인 현상이다. 이와 같이 총 공급량과 총 수요량이 서로 일치하지 않는 수송문제를 불균형 수송문제라고 한다.
" 14 | ] 15 | }, 16 | { 17 | "cell_type": "code", 18 | "execution_count": 4, 19 | "metadata": {}, 20 | "outputs": [], 21 | "source": [ 22 | "import os\n", 23 | "import sys\n", 24 | "\n", 25 | "# Add the parent directory for importing custom library\n", 26 | "sys.path.insert(0, os.path.abspath(os.path.join(os.getcwd(), os.pardir)))" 27 | ] 28 | }, 29 | { 30 | "cell_type": "markdown", 31 | "metadata": {}, 32 | "source": [ 33 | "#### Optimization with PuLP" 34 | ] 35 | }, 36 | { 37 | "cell_type": "code", 38 | "execution_count": null, 39 | "metadata": {}, 40 | "outputs": [], 41 | "source": [ 42 | "from pulp import *\n", 43 | "\n", 44 | "prob = LpProblem('Unbalaced Transportation Problem', LpMinimize)\n", 45 | "\n", 46 | "n_suppliers = 3\n", 47 | "n_buyers = 4\n", 48 | "\n", 49 | "costs = [\n", 50 | " [4, 5, 6, 8],\n", 51 | " [4, 7, 9, 2], \n", 52 | " [5, 8, 7, 6]\n", 53 | "]\n", 54 | "\n", 55 | "supply = [120, 150, 200]\n", 56 | "demand = [150, 60, 130, 180]\n", 57 | "\n", 58 | "routes = [(i, j) for i in range(n_suppliers) for j in range(n_buyers)]\n", 59 | "\n", 60 | "x = LpVariable.dicts('X', routes, lowBound=0)\n", 61 | "\n", 62 | "prob += lpSum([x[i, j] * costs[i][j] for i in range(n_suppliers) for j in range(n_buyers)])\n", 63 | "\n", 64 | "for i in range(n_suppliers):\n", 65 | " prob += lpSum([x[i, j] for j in range(n_buyers)]) == supply[i]\n", 66 | " \n", 67 | "for j in range(n_buyers):\n", 68 | " prob += lpSum([x[i, j] for i in range(n_suppliers)]) <= demand[j]\n", 69 | " \n", 70 | "# Solving problem\n", 71 | "prob.solve()\n", 72 | "print('Status', LpStatus[prob.status])\n", 73 | "\n", 74 | "print('Z = {}'.format(value(prob.objective)))\n", 75 | "for v in prob.variables():\n", 76 | " print('{} = {}'.format(v.name, v.varValue))" 77 | ] 78 | }, 79 | { 80 | "cell_type": "code", 81 | "execution_count": null, 82 | "metadata": {}, 83 | "outputs": [], 84 | "source": [ 85 | "from gurobipy import *\n", 86 | "\n", 87 | "n_suppliers = 3\n", 88 | "n_buyers = 4\n", 89 | "\n", 90 | "costs = [\n", 91 | " [4, 5, 6, 8],\n", 92 | " [4, 7, 9, 2], \n", 93 | " [5, 8, 7, 6]\n", 94 | "]\n", 95 | "\n", 96 | "supply = [120, 150, 200]\n", 97 | "demand = [150, 60, 130, 180]\n", 98 | "\n", 99 | "routes = tuplelist([(i, j) for i in range(n_suppliers) for j in range(n_buyers)])\n", 100 | "\n", 101 | "m = Model('Unbalaced Transportation Problem')\n", 102 | "\n", 103 | "x = m.addVars(routes, lb=0, vtype=GRB.CONTINUOUS, name='X')\n", 104 | "\n", 105 | "m.update()\n", 106 | "\n", 107 | "m.setObjective(quicksum(x[i, j] * costs[i][j] for i in range(n_suppliers) for j in range(n_buyers)), GRB.MINIMIZE)\n", 108 | "\n", 109 | "for i in range(n_suppliers):\n", 110 | " m.addConstr(quicksum(x[i, j] for j in range(n_buyers)) == supply[i])\n", 111 | " \n", 112 | "for j in range(n_buyers):\n", 113 | " m.addConstr(quicksum(x[i, j] for i in range(n_suppliers)) <= demand[j])\n", 114 | "\n", 115 | "# Optimize model\n", 116 | "m.optimize()" 117 | ] 118 | }, 119 | { 120 | "cell_type": "code", 121 | "execution_count": null, 122 | "metadata": {}, 123 | "outputs": [], 124 | "source": [ 125 | "print('Z = {}'.format(m.objVal))\n", 126 | "for v in m.getVars():\n", 127 | " print('{} = {}'.format(v.varName, v.x))" 128 | ] 129 | }, 130 | { 131 | "cell_type": "markdown", 132 | "metadata": {}, 133 | "source": [ 134 | "## Transportation Problem with Prohibited Transport Routes" 135 | ] 136 | }, 137 | { 138 | "cell_type": "code", 139 | "execution_count": null, 140 | "metadata": {}, 141 | "outputs": [], 142 | "source": [ 143 | "import numpy as np\n", 144 | "from pulp import *\n", 145 | "\n", 146 | "prob = LpProblem('Transportation', LpMinimize)\n", 147 | "\n", 148 | "costs = [\n", 149 | " [4, 3, 2, 0],\n", 150 | " [4, 1, 1000, 6], \n", 151 | " [3, 0, 1, 2]\n", 152 | "]\n", 153 | "\n", 154 | "supply = [200, 300, 500]\n", 155 | "demand = [100, 60, 130, 300]\n", 156 | "\n", 157 | "n_suppliers = 3\n", 158 | "n_buyers = 4\n", 159 | "\n", 160 | "routes = [(i, j) for i in range(n_suppliers) for j in range(n_buyers)]\n", 161 | "\n", 162 | "x = LpVariable.dicts('x', routes, lowBound=0)\n", 163 | "\n", 164 | "prob += lpSum([x[i, j] * costs[i][j] for i in range(n_suppliers) for j in range(n_buyers)])\n", 165 | "\n", 166 | "for i in range(n_suppliers):\n", 167 | " prob += lpSum([x[i, j] for j in range(n_buyers)]) <= supply[i]\n", 168 | " \n", 169 | "for j in range(n_buyers):\n", 170 | " prob += lpSum([x[i, j] for i in range(n_suppliers)]) == demand[j]\n", 171 | " \n", 172 | "# Solving problem\n", 173 | "prob.solve()\n", 174 | "print('Status', LpStatus[prob.status])\n", 175 | "\n", 176 | "print('Z = {}'.format(value(prob.objective)))\n", 177 | "for v in prob.variables():\n", 178 | " print('{} = {}'.format(v.name, v.varValue))" 179 | ] 180 | }, 181 | { 182 | "cell_type": "code", 183 | "execution_count": null, 184 | "metadata": {}, 185 | "outputs": [], 186 | "source": [] 187 | }, 188 | { 189 | "cell_type": "markdown", 190 | "metadata": {}, 191 | "source": [ 192 | "## Transshipment Problem" 193 | ] 194 | }, 195 | { 196 | "cell_type": "code", 197 | "execution_count": null, 198 | "metadata": {}, 199 | "outputs": [], 200 | "source": [] 201 | }, 202 | { 203 | "cell_type": "code", 204 | "execution_count": null, 205 | "metadata": {}, 206 | "outputs": [], 207 | "source": [ 208 | "prob = LpProblem(\"Transportation\", LpMinimize)\n", 209 | "\n", 210 | "S = [\"A\", \"B\", \"C\"]\n", 211 | "D = [\"1\", \"2\", \"3\", \"4\"]\n", 212 | "costs = [[21, 12, 25, 11],\n", 213 | " [13, 10, 21, 17],\n", 214 | " [12, 14, 19, 12]]\n", 215 | "\n", 216 | "supply = dict(zip(S, [80, 60, 50]))\n", 217 | "demand = dict(zip(D, [50, 40, 70, 30]))\n", 218 | "demand\n", 219 | "\n", 220 | "opt_costs = makeDict([S, D], costs, 0)\n", 221 | "opt_costs\n", 222 | "\n", 223 | "x = LpVariable.dicts('Route', (S, D), lowBound=0)\n", 224 | "x\n", 225 | "\n", 226 | "routes = [(i, j) for i in S for j in D]\n", 227 | "routes\n", 228 | "\n", 229 | "prob += lpSum([x[s][d]*opt_costs[s][d] for (s, d) in routes]) # objective function\n", 230 | "\n", 231 | "# constraints\n", 232 | "for i in S:\n", 233 | " prob += lpSum([x[i][j] for j in D]) == supply[i]\n", 234 | "\n", 235 | "for j in D:\n", 236 | " prob += lpSum([x[i][j] for i in S]) == demand[j]\n", 237 | " \n", 238 | "prob.solve()\n", 239 | "\n", 240 | "for i in prob.variables():\n", 241 | " print(i.name, \"=\", i.varValue)\n", 242 | "print('Status', LpStatus[prob.status])\n", 243 | "print(pulp.value(prob.objective))" 244 | ] 245 | }, 246 | { 247 | "cell_type": "code", 248 | "execution_count": null, 249 | "metadata": {}, 250 | "outputs": [], 251 | "source": [] 252 | }, 253 | { 254 | "cell_type": "code", 255 | "execution_count": null, 256 | "metadata": {}, 257 | "outputs": [], 258 | "source": [] 259 | }, 260 | { 261 | "cell_type": "code", 262 | "execution_count": null, 263 | "metadata": {}, 264 | "outputs": [], 265 | "source": [ 266 | "prob = LpProblem(\"Unbalanced Transportation\", LpMinimize)\n", 267 | "\n", 268 | "S = [\"A\", \"B\", \"C\"]\n", 269 | "D = [\"1\", \"2\", \"3\", \"4\"]\n", 270 | "costs = [[21, 12, 25, 11],\n", 271 | " [13, 10, 21, 17],\n", 272 | " [12, 14, 19, 12]]\n", 273 | "\n", 274 | "supply = dict(zip(S, [80, 60, 50]))\n", 275 | "demand = dict(zip(D, [60, 50, 80, 40]))\n", 276 | "\n", 277 | "opt_costs = makeDict([S, D], costs, 0)\n", 278 | "\n", 279 | "x = LpVariable.dicts('Route', (S, D), lowBound=0)\n", 280 | "x\n", 281 | "\n", 282 | "routes = [(i, j) for i in S for j in D]\n", 283 | "\n", 284 | "prob += lpSum([x[s][d]*opt_costs[s][d] for (s, d) in routes]) # objective function\n", 285 | "\n", 286 | "# constraints\n", 287 | "for i in S:\n", 288 | " prob += lpSum([x[i][j] for j in D]) == supply[i]\n", 289 | "\n", 290 | "for j in D:\n", 291 | " prob += lpSum([x[i][j] for i in S]) <= demand[j]\n", 292 | " \n", 293 | "prob.solve()\n", 294 | "\n", 295 | "for i in prob.variables():\n", 296 | " print(i.name, \"=\", i.varValue)\n", 297 | "print('Status', LpStatus[prob.status])\n", 298 | "print(pulp.value(prob.objective))" 299 | ] 300 | }, 301 | { 302 | "cell_type": "code", 303 | "execution_count": null, 304 | "metadata": {}, 305 | "outputs": [], 306 | "source": [] 307 | } 308 | ], 309 | "metadata": { 310 | "kernelspec": { 311 | "display_name": "Python 3", 312 | "language": "python", 313 | "name": "python3" 314 | }, 315 | "language_info": { 316 | "codemirror_mode": { 317 | "name": "ipython", 318 | "version": 3 319 | }, 320 | "file_extension": ".py", 321 | "mimetype": "text/x-python", 322 | "name": "python", 323 | "nbconvert_exporter": "python", 324 | "pygments_lexer": "ipython3", 325 | "version": "3.7.3" 326 | }, 327 | "latex_envs": { 328 | "LaTeX_envs_menu_present": true, 329 | "autocomplete": true, 330 | "bibliofile": "biblio.bib", 331 | "cite_by": "apalike", 332 | "current_citInitial": 1, 333 | "eqLabelWithNumbers": true, 334 | "eqNumInitial": 1, 335 | "hotkeys": { 336 | "equation": "Ctrl-E", 337 | "itemize": "Ctrl-I" 338 | }, 339 | "labels_anchors": false, 340 | "latex_user_defs": false, 341 | "report_style_numbering": false, 342 | "user_envs_cfg": false 343 | }, 344 | "varInspector": { 345 | "cols": { 346 | "lenName": 16, 347 | "lenType": 16, 348 | "lenVar": 40 349 | }, 350 | "kernels_config": { 351 | "python": { 352 | "delete_cmd_postfix": "", 353 | "delete_cmd_prefix": "del ", 354 | "library": "var_list.py", 355 | "varRefreshCmd": "print(var_dic_list())" 356 | }, 357 | "r": { 358 | "delete_cmd_postfix": ") ", 359 | "delete_cmd_prefix": "rm(", 360 | "library": "var_list.r", 361 | "varRefreshCmd": "cat(var_dic_list()) " 362 | } 363 | }, 364 | "types_to_exclude": [ 365 | "module", 366 | "function", 367 | "builtin_function_or_method", 368 | "instance", 369 | "_Feature" 370 | ], 371 | "window_display": false 372 | } 373 | }, 374 | "nbformat": 4, 375 | "nbformat_minor": 4 376 | } 377 | -------------------------------------------------------------------------------- /or-tutorial/integer-programming/traveling-salesman.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Integer Programming\n", 8 | "\n", 9 | "### Travelling Salesman Problem\n", 10 | "\n", 11 | "외판원 문제(travelling salesman problem, TSP)에 대한 자세한 내용은 블로그에서 참고해보시기 바랍니다.
\n", 12 | "\n", 13 | "**이강우 & 김정자. (2012). EXCEL 2010 경영과학. 한경사, 390.**\n", 14 | "\n", 15 | "| \n", 19 | " | 1(Yard) | \n", 20 | "2(A) | \n", 21 | "3(B) | \n", 22 | "4(C) | \n", 23 | "5(D) | \n", 24 | "
|---|---|---|---|---|---|
| 1(Yard) | \n", 27 | "- | \n", 28 | "4.0 | \n", 29 | "4.0 | \n", 30 | "4.7 | \n", 31 | "5.0 | \n", 32 | "
| 2(A) | \n", 35 | "0.0 | \n", 36 | "- | \n", 37 | "1.3 | \n", 38 | "2.5 | \n", 39 | "1.7 | \n", 40 | "
| 3(B) | \n", 43 | "0.0 | \n", 44 | "1.3 | \n", 45 | "- | \n", 46 | "1.0 | \n", 47 | "2.0 | \n", 48 | "
| 4(C) | \n", 51 | "0.0 | \n", 52 | "2.5 | \n", 53 | "1.0 | \n", 54 | "- | \n", 55 | "2.0 | \n", 56 | "
| 5(D) | \n", 59 | "0.0 | \n", 60 | "1.7 | \n", 61 | "1.4 | \n", 62 | "2.0 | \n", 63 | "- | \n", 64 | "
외판원 문제를 정식화하면 $n$개의 도시가 있을 때 인덱스 $i$와 $j$는 $n$개 만큼있으며 파리미터는 거리 $c_{ij}$, 의사결정변수로 $x_{ij}$와 $u_{i}$가 있으며 Miller-Tucker-Zemlin (MTZ) 공식은 다음과 같습니다.
\n", 69 | "\n", 70 | "$$x_{ij} = \n", 71 | "\\begin{cases}\n", 72 | " 1, \\; \\text{if the edge $(i,j)$ is included in the Hamilton cycle}\\\\\n", 73 | " 0, \\; \\text{otherwise}\n", 74 | "\\end{cases}$$\n", 75 | "\n", 76 | "$$u_{i} = \\text{order city $i$ is visited}$$\n", 77 | "\n", 78 | "위의 의사결정변수와 파라미터를 이용하여 총 거리의 합을 최소화하는 정수 계획법은 다음과 같습니다.
\n", 79 | "\n", 80 | "$$\\begin{align*}\n", 81 | " & \\text{minimize } & & \\sum_{i=1}^{n} \\sum_{j=1}^{n} c_{ij}x_{ij} \\\\[1ex]\n", 82 | " & \\text{subject to } & \\, & \\sum_{i=1}^{n} x_{ij} = 1, & \\quad & \\forall j = 1, \\dots, n\\\\[1ex]\n", 83 | " & & \\, & \\sum_{j=1}^{n} x_{ij} = 1, & \\quad & \\forall j = 1, \\dots, n\\\\[1ex] \n", 84 | " & & \\, & u_{i} - u_{j} \\le N(1-x_{ij})-1 & \\quad & \\forall i = 2, \\dots, n, j=2, \\dots, n\\\\[1ex] \n", 85 | "\\end{align*}$$\n", 86 | "\n" 87 | ] 88 | }, 89 | { 90 | "cell_type": "code", 91 | "execution_count": 27, 92 | "metadata": {}, 93 | "outputs": [], 94 | "source": [ 95 | "import os\n", 96 | "import sys\n", 97 | "\n", 98 | "# Add the parent directory for importing custom library\n", 99 | "sys.path.append('../')" 100 | ] 101 | }, 102 | { 103 | "cell_type": "code", 104 | "execution_count": 28, 105 | "metadata": {}, 106 | "outputs": [ 107 | { 108 | "name": "stdout", 109 | "output_type": "stream", 110 | "text": [ 111 | "7.7\n", 112 | "x_(0,_1) = 1.0\n", 113 | "x_(1,_4) = 1.0\n", 114 | "x_(2,_3) = 1.0\n", 115 | "x_(3,_2) = 1.0\n", 116 | "x_(4,_0) = 1.0\n" 117 | ] 118 | } 119 | ], 120 | "source": [ 121 | "from pulp import *\n", 122 | "from ortools.utils import output\n", 123 | "\n", 124 | "n = 5\n", 125 | "\n", 126 | "costs = [\n", 127 | " [100, 4.0, 4.0, 4.7, 5.0],\n", 128 | " [0.0, 1000, 1.3, 2.5, 1.7],\n", 129 | " [0.0, 1.3, 100, 1.0, 1.4],\n", 130 | " [0.0, 2.5, 1.0, 100, 2.0],\n", 131 | " [0.0, 1.7, 1.4, 2.0, 100],\n", 132 | "]\n", 133 | "\n", 134 | "prob = LpProblem('Traveling Salesman Problem', LpMinimize)\n", 135 | "\n", 136 | "indexs = [(i, j) for i in range(n) for j in range(n)]\n", 137 | "\n", 138 | "x = LpVariable.dicts('x', indexs, lowBound=0, cat='Binary')\n", 139 | "\n", 140 | "prob += lpSum([costs[i][j]*x[i, j] for i, j in indexs])\n", 141 | "\n", 142 | "for j in range(n):\n", 143 | " prob += lpSum([x[i, j] for i in range(n)]) == 1\n", 144 | " \n", 145 | "for i in range(n):\n", 146 | " prob += lpSum([x[i, j] for j in range(n)]) == 1\n", 147 | " \n", 148 | "prob.solve()\n", 149 | "print(value(prob.objective))\n", 150 | "\n", 151 | "for i in prob.variables():\n", 152 | " if i.varValue == 1:\n", 153 | " print(i.name, '=', i.varValue)" 154 | ] 155 | }, 156 | { 157 | "cell_type": "code", 158 | "execution_count": null, 159 | "metadata": {}, 160 | "outputs": [], 161 | "source": [] 162 | }, 163 | { 164 | "cell_type": "code", 165 | "execution_count": null, 166 | "metadata": {}, 167 | "outputs": [], 168 | "source": [] 169 | }, 170 | { 171 | "cell_type": "code", 172 | "execution_count": null, 173 | "metadata": {}, 174 | "outputs": [], 175 | "source": [] 176 | }, 177 | { 178 | "cell_type": "code", 179 | "execution_count": 12, 180 | "metadata": {}, 181 | "outputs": [ 182 | { 183 | "ename": "NameError", 184 | "evalue": "name 'cities' is not defined", 185 | "output_type": "error", 186 | "traceback": [ 187 | "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", 188 | "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", 189 | "\u001b[0;32m위의 의사결정변수와 파라미터를 이용하여 총 거리의 합을 최소화하는 정수 계획법은 다음과 같습니다.
\n", 254 | "\n", 255 | "\n", 256 | "\n", 257 | "$$\\begin{align*}\n", 258 | " & \\text{minimize } & & \\sum_{i=1}^{n} \\sum_{j=1}^{n} c_{ij}x_{ij} \\\\[1ex]\n", 259 | " & \\text{subject to } & \\, & \\sum_{i=1}^{n} x_{ij} = 1, & \\quad & \\forall j = 1, \\dots, n\\\\[1ex]\n", 260 | " & & \\, & \\sum_{j=1}^{n} x_{ij} = 1, & \\quad & \\forall j = 1, \\dots, n\\\\[1ex] \n", 261 | " & & \\, & u_{i} - u_{j} \\le N(1-x_{ij})-1 & \\quad & \\forall i = 2, \\dots, n, j=2, \\dots, n\\\\[1ex] \n", 262 | "\\end{align*}$$\n", 263 | "\n", 264 | "목적함수는 식(1)과 같습니다. 제약식은 다음과 같습니다. 제약식(2)과 (3)은 각 도시 $j$로 들어오는 도시는 1개가 되어야만 하고 각 도시 $i$에서 출발하는 도시는 1개가 되어야 한다는 걸 나타냅니다. 제약식(3)은 부등식 제약조건(inequality constraints)으로 MTZ 공식입니다. $x_{ij}=1$일 때, $(i,j)$에 대한 두 도시 사이는 순서는 $u_{j} \\ge u_{i}$를 뜻합니다. 제약식(4)와 (5)는 의사결정변수 $x_{ij}$는 $0$과 $1$ 값만 가질 수 있는 이진변수이고, $u_{i}$는 $0$보다 크거나 같고 $n-1$보다 작거나 같은 값을 가질 수 있는 변수를 나타냅니다.
\n" 265 | ] 266 | } 267 | ], 268 | "metadata": { 269 | "kernelspec": { 270 | "display_name": "Python 3", 271 | "language": "python", 272 | "name": "python3" 273 | }, 274 | "language_info": { 275 | "codemirror_mode": { 276 | "name": "ipython", 277 | "version": 3 278 | }, 279 | "file_extension": ".py", 280 | "mimetype": "text/x-python", 281 | "name": "python", 282 | "nbconvert_exporter": "python", 283 | "pygments_lexer": "ipython3", 284 | "version": "3.7.3" 285 | } 286 | }, 287 | "nbformat": 4, 288 | "nbformat_minor": 4 289 | } 290 | -------------------------------------------------------------------------------- /or-tutorial/linear-programming/workforce-scheduling.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Linear Programming\n", 8 | "\n", 9 | "### Workforce Scheduling\n", 10 | "\n", 11 | "**이강우 & 김정자. (2012). _EXCEL 2010 경영과학_. 한경사, 233.**\n", 12 | "\n", 13 | "K항공에서는 최근 여행객의 증가로 인천국제공항에 기항하거나 출항하는 비행기를 증편시키려고 하며 이에 따라서 추가로 서비스 직원을 고용하려고 한다. Table 1은 새로 증편된 운항계획에 따라서 각 교대조별 근무시간, 시간대별 필요한 직원의 소요인원 및 교대조별 1명당 1일 노무비용을 조사한 결과이다. 한편 K항공의 서비스 직원은 1일 8시간 단위로 근무하며 각 교대조의 근무시간은 다음과 같다.
\n", 14 | "\n", 15 | "| 근무시간대 | \n", 19 | "교대조1 | \n", 20 | "교대조2 | \n", 21 | "교대조3 | \n", 22 | "교대조4 | \n", 23 | "교대조5 | \n", 24 | "소요인원(명) | \n", 25 | "
|---|---|---|---|---|---|---|
| 06:00 ~ 08:00 | \n", 28 | "○ | \n", 29 | "\n", 30 | " | \n", 31 | " | \n", 32 | " | \n", 33 | " | 48 | \n", 34 | "
| 08:00 ~ 10:00 | \n", 37 | "○ | \n", 38 | "○ | \n", 39 | "\n", 40 | " | \n", 41 | " | \n", 42 | " | 79 | \n", 43 | "
| 10:00 ~ 12:00 | \n", 46 | "○ | \n", 47 | "○ | \n", 48 | "\n", 49 | " | \n", 50 | " | \n", 51 | " | 65 | \n", 52 | "
| 12:00 ~ 14:00 | \n", 55 | "○ | \n", 56 | "○ | \n", 57 | "○ | \n", 58 | "\n", 59 | " | \n", 60 | " | 87 | \n", 61 | "
| 14:00 ~ 16:00 | \n", 64 | "\n", 65 | " | ○ | \n", 66 | "○ | \n", 67 | "\n", 68 | " | \n", 69 | " | 64 | \n", 70 | "
| 16:00 ~ 18:00 | \n", 73 | "\n", 74 | " | \n", 75 | " | ○ | \n", 76 | "○ | \n", 77 | "\n", 78 | " | 73 | \n", 79 | "
| 18:00 ~ 20:00 | \n", 82 | "\n", 83 | " | \n", 84 | " | ○ | \n", 85 | "○ | \n", 86 | "\n", 87 | " | 82 | \n", 88 | "
| 20:00 ~ 22:00 | \n", 91 | "\n", 92 | " | \n", 93 | " | \n", 94 | " | ○ | \n", 95 | "\n", 96 | " | 43 | \n", 97 | "
| 22:00 ~ 24:00 | \n", 100 | "\n", 101 | " | \n", 102 | " | \n", 103 | " | ○ | \n", 104 | "○ | \n", 105 | "52 | \n", 106 | "
| 24:00 ~ 06:00 | \n", 109 | "\n", 110 | " | \n", 111 | " | \n", 112 | " | \n", 113 | " | ○ | \n", 114 | "15 | \n", 115 | "
| 1인당 임금(만원) | \n", 118 | "7 | \n", 119 | "6 | \n", 120 | "7.5 | \n", 121 | "8 | \n", 122 | "9.5 | \n", 123 | "\n", 124 | " |
D부품회사는 자동차 부품을 생산하여 A자동차회사에 납품하고 있는 회사이다. A자동차회사는 분기별로 다음 분기에 사용할 부품 1과 부품 2를 D부품회사에 주문하고 있다. D부품회사는가 A자동차회사로부터 받은 이번 분기의 부품 1과 부품 2의 월별 주문수량은 Table 1과 같다.
\n", 14 | "\n", 15 | "| Parts | \n", 19 | "January | \n", 20 | "February | \n", 21 | "March | \n", 22 | "
|---|---|---|---|
| Part 1 | \n", 25 | "3000 | \n", 26 | "2500 | \n", 27 | "3000 | \n", 28 | "
| Part 2 | \n", 31 | "2500 | \n", 32 | "2000 | \n", 33 | "2000 | \n", 34 | "
현재 D부품회사에서 보유하고 있는 부품 1과 부품 2의 재고는 두 부품 모두 500개씩이고 D부품회사는 3월말에도 두 부품 모두 500개 이상의 재고를 보유하려고 한다. 한편 D부품회사의 재고보관능력은 부품의 종류에 상관없이 월 2,000개이다. 그리고 부품 1과 부품 2의 1단위 생산에 소요되는 기계가공시간과 노동시간은 Table 2와 같으며 생산자원인 기계가공시간과 노동시간의 월별 가용시간은 Table 3과 같다.
\n", 38 | "\n", 39 | "| Parts | \n", 43 | "Machining times per unit | \n", 44 | "Labor hours per unit | \n", 45 | "
|---|---|---|
| Part 1 | \n", 48 | "0.2 | \n", 49 | "0.05 | \n", 50 | "
| Part 2 | \n", 53 | "0.1 | \n", 54 | "0.04 | \n", 55 | "
| Month | \n", 62 | "Availability of machining times | \n", 63 | "Availability of labor hours | \n", 64 | "
|---|---|---|
| January | \n", 67 | "1000 | \n", 68 | "300 | \n", 69 | "
| February | \n", 72 | "1000 | \n", 73 | "300 | \n", 74 | "
| March | \n", 77 | "1000 | \n", 78 | "300 | \n", 79 | "
한편 부품 1과 부품 2의 총 생산비용은 생산비용, 재고유지비용, 생산량 변동에 따른 비용으로 구성되어 있으며 부품 1과 부품 2의 단위당 생산비용과 단위당 월간 재고유지비용은 Table 4와 같다.
\n", 83 | "\n", 84 | "| Costs by part | \n", 88 | "January | \n", 89 | "February | \n", 90 | "March | \n", 91 | "|
|---|---|---|---|---|
| Part 1 | \n", 94 | "Production cost per unit | \n", 95 | "30 | \n", 96 | "35 | \n", 97 | "30 | \n", 98 | "
| Inventory holding cost per unit | \n", 101 | "0.3 | \n", 102 | "0.3 | \n", 103 | "0.3 | \n", 104 | "|
| Part 2 | \n", 107 | "Production cost per unit | \n", 108 | "20 | \n", 109 | "25 | \n", 110 | "20 | \n", 111 | "
| Inventory holding cost per unit | \n", 114 | "0.15 | \n", 115 | "0.15 | \n", 116 | "0.15 | \n", 117 | "
또한 월별 총 생산량의 변동에 따른 비용은 부품 1과 부품 2의 월 생산량의 합이 직전 월의 생산량에 비해 1개 증가할 경우에는 500원, 1개 감소할 경우에는 200원의 비용이 발생한다고 한다. 전년도 12월에는 부품 1과 부품 2를 5,000개 생산하였다고 한다. D부품회사의 총 생산비용을 최소로 하는 1월, 2월 3월의 생산계획을 수립하라.
" 121 | ] 122 | }, 123 | { 124 | "cell_type": "code", 125 | "execution_count": 1, 126 | "metadata": {}, 127 | "outputs": [], 128 | "source": [ 129 | "import os\n", 130 | "import sys\n", 131 | "\n", 132 | "# Add the parent directory for importing custom library\n", 133 | "sys.path.insert(0, os.path.abspath(os.path.join(os.getcwd(), os.pardir)))" 134 | ] 135 | }, 136 | { 137 | "cell_type": "markdown", 138 | "metadata": {}, 139 | "source": [ 140 | "#### Optimization with PuLP\n", 141 | "\n", 142 | "각 의사결정변수 및 매개변수를 선언할 때, string과 dictionary를 사용하면 전체적인 분위기가 다음과 같아진다. 다음은 기말재고량을 구하는 공식을 표현한 것이다. 두 개의 코드를 보고 앞으로 수리적 모형을 파이썬으로 구현할 때 참고하도록 하자. 본인은 후자를 좋아한다.
P전자는 3개의 공장에서 생산된 제품을 4개의 수요지로 수송하고 있다. 공장 1, 2, 3의 공급량은 각각 120, 150, 200개이고 수요지 1, 2, 3, 4의 수요량은 각각 100, 60, 130, 180개이며 각 공장과 각 수요지 사이의 제품 단위당 수송비용은 표와 같다. 여기서 공장 $i(i=1,2,3)$에서 각 수요지로 수송되는 수송량의 합계는 공장 $i$의 공급량과 일치해야 하며 각 공장에서 수요지 $j(j=1,2,3,4)$로 수송되는 수송량은 수요지 $j$의 수요량과 일치해야 한다. P전자의 총 수송비용을 최소로 하는 각 공장에서 각 수요지로의 최적 수송량을 결정하는 문제를 선혱계획모형으로 정식화하고 Python을 이용하여 최적 수송량을 구하라.
\n", 20 | "\n", 21 | "| 구분 | \n", 25 | "1 | \n", 26 | "2 | \n", 27 | "3 | \n", 28 | "4 | \n", 29 | "공급량(개) | \n", 30 | "
|---|---|---|---|---|---|
| 1 | \n", 33 | "4 | \n", 34 | "5 | \n", 35 | "6 | \n", 36 | "8 | \n", 37 | "120 | \n", 38 | "
| 2 | \n", 41 | "4 | \n", 42 | "7 | \n", 43 | "9 | \n", 44 | "2 | \n", 45 | "150 | \n", 46 | "
| 3 | \n", 49 | "5 | \n", 50 | "8 | \n", 51 | "7 | \n", 52 | "6 | \n", 53 | "200 | \n", 54 | "
| 수요량(개) | \n", 57 | "100 | \n", 58 | "60 | \n", 59 | "130 | \n", 60 | "180 | \n", 61 | "\n", 62 | " |
$X_{ij}=\\text{공급지 $i$에서 수요지 $j$로의 수송량(개)}$
" 66 | ] 67 | }, 68 | { 69 | "cell_type": "code", 70 | "execution_count": 2, 71 | "metadata": {}, 72 | "outputs": [], 73 | "source": [ 74 | "import os\n", 75 | "import sys\n", 76 | "\n", 77 | "# Add the parent directory for importing custom library\n", 78 | "sys.path.insert(0, os.path.abspath(os.path.join(os.getcwd(), os.pardir)))" 79 | ] 80 | }, 81 | { 82 | "cell_type": "markdown", 83 | "metadata": {}, 84 | "source": [ 85 | "#### Optimization with PuLP" 86 | ] 87 | }, 88 | { 89 | "cell_type": "code", 90 | "execution_count": 3, 91 | "metadata": {}, 92 | "outputs": [ 93 | { 94 | "name": "stdout", 95 | "output_type": "stream", 96 | "text": [ 97 | "Status: Optimal\n", 98 | "Objective value: 2130.0\n", 99 | "\n", 100 | "Variables Values\n", 101 | "----------- --------\n", 102 | "X11 60\n", 103 | "X12 60\n", 104 | "X13 0\n", 105 | "X14 0\n", 106 | "X21 0\n", 107 | "X22 0\n", 108 | "X23 0\n", 109 | "X24 150\n", 110 | "X31 40\n", 111 | "X32 0\n", 112 | "X33 130\n", 113 | "X34 30\n", 114 | "\n", 115 | "Statistics:\n", 116 | "- Number of variables: 12\n", 117 | "- Number of constraints: 7\n", 118 | "- Solve time: 0.004s\n" 119 | ] 120 | } 121 | ], 122 | "source": [ 123 | "from pulp import *\n", 124 | "from ortools.utils import output\n", 125 | "\n", 126 | "prob = LpProblem('Transportation Problem', LpMinimize)\n", 127 | "\n", 128 | "x11 = LpVariable('X11', lowBound=0)\n", 129 | "x12 = LpVariable('X12', lowBound=0)\n", 130 | "x13 = LpVariable('X13', lowBound=0)\n", 131 | "x14 = LpVariable('X14', lowBound=0)\n", 132 | "x21 = LpVariable('X21', lowBound=0)\n", 133 | "x22 = LpVariable('X22', lowBound=0)\n", 134 | "x23 = LpVariable('X23', lowBound=0)\n", 135 | "x24 = LpVariable('X24', lowBound=0)\n", 136 | "x31 = LpVariable('X31', lowBound=0)\n", 137 | "x32 = LpVariable('X32', lowBound=0)\n", 138 | "x33 = LpVariable('X33', lowBound=0)\n", 139 | "x34 = LpVariable('X34', lowBound=0)\n", 140 | "\n", 141 | "prob += 4*x11 + 5*x12 + 6*x13 + 8*x14 + 4*x21 + 7*x22 + 9*x23 + 2*x24 + 5*x31 + 8*x32 + 7*x33 + 6*x34\n", 142 | "\n", 143 | "prob += x11 + x12 + x13 + x14 == 120\n", 144 | "prob += x21 + x22 + x23 + x24 == 150\n", 145 | "prob += x31 + x32 + x33 + x34 == 200\n", 146 | "\n", 147 | "prob += x11 + x21 + x31 == 100\n", 148 | "prob += x12 + x22 + x32 == 60\n", 149 | "prob += x13 + x23 + x33 == 130\n", 150 | "prob += x14 + x24 + x34 == 180\n", 151 | "\n", 152 | "# Solving problem\n", 153 | "prob.solve()\n", 154 | "output(prob)" 155 | ] 156 | }, 157 | { 158 | "cell_type": "code", 159 | "execution_count": 4, 160 | "metadata": {}, 161 | "outputs": [ 162 | { 163 | "name": "stdout", 164 | "output_type": "stream", 165 | "text": [ 166 | "Status: Optimal\n", 167 | "Objective value: 2130.0\n", 168 | "\n", 169 | "Variables Values\n", 170 | "----------- --------\n", 171 | "X_(0,_0) 60\n", 172 | "X_(0,_1) 60\n", 173 | "X_(0,_2) 0\n", 174 | "X_(0,_3) 0\n", 175 | "X_(1,_0) 0\n", 176 | "X_(1,_1) 0\n", 177 | "X_(1,_2) 0\n", 178 | "X_(1,_3) 150\n", 179 | "X_(2,_0) 40\n", 180 | "X_(2,_1) 0\n", 181 | "X_(2,_2) 130\n", 182 | "X_(2,_3) 30\n", 183 | "\n", 184 | "Statistics:\n", 185 | "- Number of variables: 12\n", 186 | "- Number of constraints: 7\n", 187 | "- Solve time: 0.006s\n" 188 | ] 189 | } 190 | ], 191 | "source": [ 192 | "from pulp import *\n", 193 | "from ortools.utils import output\n", 194 | "\n", 195 | "prob = LpProblem('Transportation Problem', LpMinimize)\n", 196 | "\n", 197 | "n_suppliers = 3\n", 198 | "n_buyers = 4\n", 199 | "\n", 200 | "costs = [\n", 201 | " [4, 5, 6, 8],\n", 202 | " [4, 7, 9, 2], \n", 203 | " [5, 8, 7, 6]\n", 204 | "]\n", 205 | "\n", 206 | "supply = [120, 150, 200]\n", 207 | "demand = [100, 60, 130, 180]\n", 208 | "\n", 209 | "routes = [(i, j) for i in range(n_suppliers) for j in range(n_buyers)]\n", 210 | "\n", 211 | "x = LpVariable.dicts('X', routes, lowBound=0)\n", 212 | "\n", 213 | "prob += lpSum([x[i, j] * costs[i][j] for i in range(n_suppliers) for j in range(n_buyers)])\n", 214 | "\n", 215 | "for i in range(n_suppliers):\n", 216 | " prob += lpSum([x[i, j] for j in range(n_buyers)]) == supply[i]\n", 217 | " \n", 218 | "for j in range(n_buyers):\n", 219 | " prob += lpSum([x[i, j] for i in range(n_suppliers)]) == demand[j]\n", 220 | " \n", 221 | "# Solving problem\n", 222 | "prob.solve()\n", 223 | "output(prob)" 224 | ] 225 | }, 226 | { 227 | "cell_type": "markdown", 228 | "metadata": {}, 229 | "source": [ 230 | "#### Optimization with GUROBI" 231 | ] 232 | }, 233 | { 234 | "cell_type": "code", 235 | "execution_count": 5, 236 | "metadata": {}, 237 | "outputs": [ 238 | { 239 | "name": "stdout", 240 | "output_type": "stream", 241 | "text": [ 242 | "Status: Optimal\n", 243 | "Objective value: 2130.0\n", 244 | "\n", 245 | "Variables Values\n", 246 | "----------- --------\n", 247 | "X[0,0] 0\n", 248 | "X[0,1] 60\n", 249 | "X[0,2] 60\n", 250 | "X[0,3] 0\n", 251 | "X[1,0] 0\n", 252 | "X[1,1] 0\n", 253 | "X[1,2] 0\n", 254 | "X[1,3] 150\n", 255 | "X[2,0] 100\n", 256 | "X[2,1] 0\n", 257 | "X[2,2] 70\n", 258 | "X[2,3] 30\n", 259 | "\n", 260 | "Statistics:\n", 261 | "- Number of variables: 12\n", 262 | "- Number of constraints: 7\n", 263 | "- Solve time: 0.001s\n" 264 | ] 265 | } 266 | ], 267 | "source": [ 268 | "from gurobipy import *\n", 269 | "from ortools.utils import set_gurobi, custom_callback, output\n", 270 | "\n", 271 | "n_suppliers = 3\n", 272 | "n_buyers = 4\n", 273 | "\n", 274 | "costs = [\n", 275 | " [4, 5, 6, 8],\n", 276 | " [4, 7, 9, 2], \n", 277 | " [5, 8, 7, 6]\n", 278 | "]\n", 279 | "\n", 280 | "supply = [120, 150, 200]\n", 281 | "demand = [100, 60, 130, 180]\n", 282 | "\n", 283 | "routes = tuplelist([(i, j) for i in range(n_suppliers) for j in range(n_buyers)])\n", 284 | "\n", 285 | "m = Model('Transportation')\n", 286 | "\n", 287 | "x = m.addVars(routes, lb=0, vtype=GRB.CONTINUOUS, name='X')\n", 288 | "\n", 289 | "m.update()\n", 290 | "\n", 291 | "m.setObjective(quicksum(x[i, j] * costs[i][j] for i in range(n_suppliers) for j in range(n_buyers)), GRB.MINIMIZE)\n", 292 | "\n", 293 | "for i in range(n_suppliers):\n", 294 | " m.addConstr(quicksum(x[i, j] for j in range(n_buyers)) == supply[i])\n", 295 | " \n", 296 | "for j in range(n_buyers):\n", 297 | " m.addConstr(quicksum(x[i, j] for i in range(n_suppliers)) == demand[j])\n", 298 | "\n", 299 | "set_gurobi(m, verbose=False)\n", 300 | "\n", 301 | "# Optimize model\n", 302 | "m.optimize(custom_callback)\n", 303 | "output(m)" 304 | ] 305 | }, 306 | { 307 | "cell_type": "markdown", 308 | "metadata": {}, 309 | "source": [ 310 | "### Unbalanced Transportation Problem\n", 311 | "\n", 312 | "**이강우 & 김정자. (2012). _EXCEL 2010 경영과학_. 한경사, 306.**\n", 313 | "\n", 314 | "현실의 수송문제는 총 공급량과 총 수요량이 일치하는 경우는 거의 없으며 이들이 서로 일치하지 않는 공급과잉이나 수요과잉이 발생하는 것이 일반적인 현상이다. 이와 같이 총 공급량과 총 수요량이 서로 일치하지 않는 수송문제를 불균형 수송문제라고 한다.
\n", 315 | "\n", 316 | "#### Optimization with PuLP" 317 | ] 318 | }, 319 | { 320 | "cell_type": "code", 321 | "execution_count": 7, 322 | "metadata": {}, 323 | "outputs": [ 324 | { 325 | "name": "stdout", 326 | "output_type": "stream", 327 | "text": [ 328 | "Status: Optimal\n", 329 | "Objective value: 2030.0\n", 330 | "\n", 331 | "Variables Values\n", 332 | "----------- --------\n", 333 | "X_(0,_0) 0\n", 334 | "X_(0,_1) 60\n", 335 | "X_(0,_2) 60\n", 336 | "X_(0,_3) 0\n", 337 | "X_(1,_0) 0\n", 338 | "X_(1,_1) 0\n", 339 | "X_(1,_2) 0\n", 340 | "X_(1,_3) 150\n", 341 | "X_(2,_0) 150\n", 342 | "X_(2,_1) 0\n", 343 | "X_(2,_2) 20\n", 344 | "X_(2,_3) 30\n", 345 | "\n", 346 | "Statistics:\n", 347 | "- Number of variables: 12\n", 348 | "- Number of constraints: 7\n", 349 | "- Solve time: 0.007s\n" 350 | ] 351 | } 352 | ], 353 | "source": [ 354 | "from pulp import *\n", 355 | "\n", 356 | "prob = LpProblem('Unbalaced Transportation Problem', LpMinimize)\n", 357 | "\n", 358 | "n_suppliers = 3\n", 359 | "n_buyers = 4\n", 360 | "\n", 361 | "costs = [\n", 362 | " [4, 5, 6, 8],\n", 363 | " [4, 7, 9, 2], \n", 364 | " [5, 8, 7, 6]\n", 365 | "]\n", 366 | "\n", 367 | "supply = [120, 150, 200]\n", 368 | "demand = [150, 60, 130, 180]\n", 369 | "\n", 370 | "routes = [(i, j) for i in range(n_suppliers) for j in range(n_buyers)]\n", 371 | "\n", 372 | "x = LpVariable.dicts('X', routes, lowBound=0)\n", 373 | "\n", 374 | "prob += lpSum([x[i, j] * costs[i][j] for i in range(n_suppliers) for j in range(n_buyers)])\n", 375 | "\n", 376 | "for i in range(n_suppliers):\n", 377 | " prob += lpSum([x[i, j] for j in range(n_buyers)]) == supply[i]\n", 378 | " \n", 379 | "for j in range(n_buyers):\n", 380 | " prob += lpSum([x[i, j] for i in range(n_suppliers)]) <= demand[j]\n", 381 | " \n", 382 | "# Solving problem\n", 383 | "prob.solve()\n", 384 | "output(prob)" 385 | ] 386 | }, 387 | { 388 | "cell_type": "code", 389 | "execution_count": 9, 390 | "metadata": {}, 391 | "outputs": [ 392 | { 393 | "name": "stdout", 394 | "output_type": "stream", 395 | "text": [ 396 | "Status: Optimal\n", 397 | "Objective value: 2030.0\n", 398 | "\n", 399 | "Variables Values\n", 400 | "----------- --------\n", 401 | "X[0,0] 0\n", 402 | "X[0,1] 60\n", 403 | "X[0,2] 60\n", 404 | "X[0,3] 0\n", 405 | "X[1,0] 0\n", 406 | "X[1,1] 0\n", 407 | "X[1,2] 0\n", 408 | "X[1,3] 150\n", 409 | "X[2,0] 150\n", 410 | "X[2,1] 0\n", 411 | "X[2,2] 20\n", 412 | "X[2,3] 30\n", 413 | "\n", 414 | "Statistics:\n", 415 | "- Number of variables: 12\n", 416 | "- Number of constraints: 7\n", 417 | "- Solve time: 0.000s\n" 418 | ] 419 | } 420 | ], 421 | "source": [ 422 | "from gurobipy import *\n", 423 | "\n", 424 | "n_suppliers = 3\n", 425 | "n_buyers = 4\n", 426 | "\n", 427 | "costs = [\n", 428 | " [4, 5, 6, 8],\n", 429 | " [4, 7, 9, 2], \n", 430 | " [5, 8, 7, 6]\n", 431 | "]\n", 432 | "\n", 433 | "supply = [120, 150, 200]\n", 434 | "demand = [150, 60, 130, 180]\n", 435 | "\n", 436 | "routes = tuplelist([(i, j) for i in range(n_suppliers) for j in range(n_buyers)])\n", 437 | "\n", 438 | "m = Model('Unbalaced Transportation Problem')\n", 439 | "\n", 440 | "x = m.addVars(routes, lb=0, vtype=GRB.CONTINUOUS, name='X')\n", 441 | "\n", 442 | "m.update()\n", 443 | "\n", 444 | "m.setObjective(quicksum(x[i, j] * costs[i][j] for i in range(n_suppliers) for j in range(n_buyers)), GRB.MINIMIZE)\n", 445 | "\n", 446 | "for i in range(n_suppliers):\n", 447 | " m.addConstr(quicksum(x[i, j] for j in range(n_buyers)) == supply[i])\n", 448 | " \n", 449 | "for j in range(n_buyers):\n", 450 | " m.addConstr(quicksum(x[i, j] for i in range(n_suppliers)) <= demand[j])\n", 451 | "\n", 452 | "set_gurobi(m, verbose=False)\n", 453 | "\n", 454 | "# Optimize model\n", 455 | "m.optimize(custom_callback)\n", 456 | "output(m)" 457 | ] 458 | }, 459 | { 460 | "cell_type": "code", 461 | "execution_count": null, 462 | "metadata": {}, 463 | "outputs": [], 464 | "source": [] 465 | } 466 | ], 467 | "metadata": { 468 | "kernelspec": { 469 | "display_name": "Python 3", 470 | "language": "python", 471 | "name": "python3" 472 | }, 473 | "language_info": { 474 | "codemirror_mode": { 475 | "name": "ipython", 476 | "version": 3 477 | }, 478 | "file_extension": ".py", 479 | "mimetype": "text/x-python", 480 | "name": "python", 481 | "nbconvert_exporter": "python", 482 | "pygments_lexer": "ipython3", 483 | "version": "3.7.3" 484 | }, 485 | "latex_envs": { 486 | "LaTeX_envs_menu_present": true, 487 | "autocomplete": true, 488 | "bibliofile": "biblio.bib", 489 | "cite_by": "apalike", 490 | "current_citInitial": 1, 491 | "eqLabelWithNumbers": true, 492 | "eqNumInitial": 1, 493 | "hotkeys": { 494 | "equation": "Ctrl-E", 495 | "itemize": "Ctrl-I" 496 | }, 497 | "labels_anchors": false, 498 | "latex_user_defs": false, 499 | "report_style_numbering": false, 500 | "user_envs_cfg": false 501 | }, 502 | "varInspector": { 503 | "cols": { 504 | "lenName": 16, 505 | "lenType": 16, 506 | "lenVar": 40 507 | }, 508 | "kernels_config": { 509 | "python": { 510 | "delete_cmd_postfix": "", 511 | "delete_cmd_prefix": "del ", 512 | "library": "var_list.py", 513 | "varRefreshCmd": "print(var_dic_list())" 514 | }, 515 | "r": { 516 | "delete_cmd_postfix": ") ", 517 | "delete_cmd_prefix": "rm(", 518 | "library": "var_list.r", 519 | "varRefreshCmd": "cat(var_dic_list()) " 520 | } 521 | }, 522 | "types_to_exclude": [ 523 | "module", 524 | "function", 525 | "builtin_function_or_method", 526 | "instance", 527 | "_Feature" 528 | ], 529 | "window_display": false 530 | } 531 | }, 532 | "nbformat": 4, 533 | "nbformat_minor": 4 534 | } 535 | -------------------------------------------------------------------------------- /or-tutorial/integer-programming/capital-budgeting.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Integer Programming\n", 8 | "\n", 9 | "### Capital Budgeting Problem\n", 10 | "\n", 11 | "**이강우 & 김정자. (2012). EXCEL 2010 경영과학. 한경사, 397.**\n", 12 | "\n", 13 | "\n", 14 | "\n", 15 | "| Investment targets | \n", 19 | "NPV (net present value) | \n",
20 | " Investment amount | \n", 21 | "|||
|---|---|---|---|---|---|
| First year | \n", 24 | "Second year | \n", 25 | "Third year | \n", 26 | "Fourth year | \n", 27 | "||
| 1 | \n", 30 | "30 | \n", 31 | "20 | \n", 32 | "25 | \n", 33 | "25 | \n", 34 | "20 | \n", 35 | "
| 2 | \n", 38 | "10 | \n", 39 | "10 | \n", 40 | "20 | \n", 41 | "15 | \n", 42 | "10 | \n", 43 | "
| 3 | \n", 46 | "15 | \n", 47 | "15 | \n", 48 | "30 | \n", 49 | "20 | \n", 50 | "5 | \n", 51 | "
| 4 | \n", 54 | "12 | \n", 55 | "10 | \n", 56 | "15 | \n", 57 | "10 | \n", 58 | "15 | \n", 59 | "
| 5 | \n", 62 | "35 | \n", 63 | "25 | \n", 64 | "30 | \n", 65 | "30 | \n", 66 | "25 | \n", 67 | "
| Capital by year | \n", 70 | "70 | \n", 71 | "90 | \n", 72 | "80 | \n", 73 | "60 | \n", 74 | "
자본예산문제는 투자대상의 선택문제이므로 결정변수 $X_{j}$를 다음과 같이 이진변수로 정의하자.
\n", 78 | "\n", 79 | "$$X_{j} = \n", 80 | "\\begin{cases}\n", 81 | " 1, \\; \\text{if investment target $j$ is selected }(j=1,2,3)\\\\\n", 82 | " 0, \\; \\text{otherwise}\n", 83 | "\\end{cases}$$\n", 84 | "\n", 85 | "\n", 86 | "\n", 87 | "\n", 88 | "\n", 89 | "\n", 90 | "\n", 91 | "" 92 | ] 93 | }, 94 | { 95 | "cell_type": "code", 96 | "execution_count": 1, 97 | "metadata": {}, 98 | "outputs": [], 99 | "source": [ 100 | "import os\n", 101 | "import sys\n", 102 | "\n", 103 | "# Add the parent directory for importing custom library\n", 104 | "sys.path.append('../')" 105 | ] 106 | }, 107 | { 108 | "cell_type": "code", 109 | "execution_count": 2, 110 | "metadata": {}, 111 | "outputs": [ 112 | { 113 | "name": "stdout", 114 | "output_type": "stream", 115 | "text": [ 116 | "Status: Optimal\n", 117 | "Objective value: 80.0\n", 118 | "\n", 119 | "Variables Values\n", 120 | "----------- --------\n", 121 | "X_0 1\n", 122 | "X_1 0\n", 123 | "X_2 1\n", 124 | "X_3 0\n", 125 | "X_4 1\n", 126 | "\n", 127 | "Statistics:\n", 128 | "- Number of variables: 5\n", 129 | "- Number of constraints: 4\n", 130 | "- Solve time: 0.004s\n" 131 | ] 132 | } 133 | ], 134 | "source": [ 135 | "from pulp import *\n", 136 | "from ortools.utils import output\n", 137 | "\n", 138 | "n = 5\n", 139 | "year = 4\n", 140 | "\n", 141 | "npv = [30, 10, 15, 12, 35]\n", 142 | "\n", 143 | "amount = [\n", 144 | " [20, 25, 25, 20],\n", 145 | " [10, 20, 15, 10],\n", 146 | " [15, 30, 20, 5],\n", 147 | " [10, 15, 10, 15],\n", 148 | " [25, 30, 30, 25]\n", 149 | "]\n", 150 | "\n", 151 | "capital = [70, 90, 80, 60]\n", 152 | "\n", 153 | "prob = LpProblem('Capital Budgeting Problem', LpMaximize)\n", 154 | "\n", 155 | "indexs = [(i) for i in range(n)]\n", 156 | "\n", 157 | "x = LpVariable.dicts('X', indexs, lowBound=0, cat='Binary')\n", 158 | "\n", 159 | "prob += lpSum([npv[i]*x[i] for i in range(n)])\n", 160 | "\n", 161 | "for j in range(year):\n", 162 | " prob += lpSum([amount[i][j]*x[i] for i in range(n)]) <= capital[j]\n", 163 | " \n", 164 | "prob.solve()\n", 165 | "output(prob)" 166 | ] 167 | }, 168 | { 169 | "cell_type": "markdown", 170 | "metadata": {}, 171 | "source": [ 172 | "#### Multiple choice constraint\n", 173 | "\n", 174 | "5개의 투자대상 $X_{j}$중에서 3개의 투자대상을 선택하는 제약식, 이를 선다형 제약식(multiple choice constraint)라고 한다.
" 175 | ] 176 | }, 177 | { 178 | "cell_type": "code", 179 | "execution_count": 3, 180 | "metadata": {}, 181 | "outputs": [ 182 | { 183 | "name": "stdout", 184 | "output_type": "stream", 185 | "text": [ 186 | "Status: Optimal\n", 187 | "Objective value: 80.0\n", 188 | "\n", 189 | "Variables Values\n", 190 | "----------- --------\n", 191 | "X_0 1\n", 192 | "X_1 0\n", 193 | "X_2 1\n", 194 | "X_3 0\n", 195 | "X_4 1\n", 196 | "\n", 197 | "Statistics:\n", 198 | "- Number of variables: 5\n", 199 | "- Number of constraints: 5\n", 200 | "- Solve time: 0.007s\n" 201 | ] 202 | } 203 | ], 204 | "source": [ 205 | "from pulp import *\n", 206 | "from ortools.utils import output\n", 207 | "\n", 208 | "n = 5\n", 209 | "year = 4\n", 210 | "\n", 211 | "npv = [30, 10, 15, 12, 35]\n", 212 | "\n", 213 | "amount = [\n", 214 | " [20, 25, 25, 20],\n", 215 | " [10, 20, 15, 10],\n", 216 | " [15, 30, 20, 5],\n", 217 | " [10, 15, 10, 15],\n", 218 | " [25, 30, 30, 25]\n", 219 | "]\n", 220 | "\n", 221 | "capital = [70, 90, 80, 60]\n", 222 | "\n", 223 | "# Define problem\n", 224 | "prob = LpProblem('Capital Budgeting Problem', LpMaximize)\n", 225 | "\n", 226 | "indexs = [(i) for i in range(n)]\n", 227 | "\n", 228 | "x = LpVariable.dicts('X', indexs, lowBound=0, cat='Binary')\n", 229 | "\n", 230 | "# Set objective function\n", 231 | "prob += lpSum([npv[i]*x[i] for i in range(n)])\n", 232 | "\n", 233 | "# Set constraint\n", 234 | "for j in range(year):\n", 235 | " prob += lpSum([amount[i][j]*x[i] for i in range(n)]) <= capital[j]\n", 236 | " \n", 237 | "# Added multiple choice constraint\n", 238 | "prob += lpSum([x[i] for i in range(n)]) == 3\n", 239 | " \n", 240 | "prob.solve()\n", 241 | "output(prob)" 242 | ] 243 | }, 244 | { 245 | "cell_type": "markdown", 246 | "metadata": {}, 247 | "source": [ 248 | "#### Multiple choice constraint\n", 249 | "\n", 250 | "5개의 투자대상 $X_{j}$중에서 3개 이내의 투자대상을 선택하는 제약식
" 251 | ] 252 | }, 253 | { 254 | "cell_type": "code", 255 | "execution_count": 4, 256 | "metadata": {}, 257 | "outputs": [ 258 | { 259 | "name": "stdout", 260 | "output_type": "stream", 261 | "text": [ 262 | "Status: Optimal\n", 263 | "Objective value: 80.0\n", 264 | "\n", 265 | "Variables Values\n", 266 | "----------- --------\n", 267 | "X_0 1\n", 268 | "X_1 0\n", 269 | "X_2 1\n", 270 | "X_3 0\n", 271 | "X_4 1\n", 272 | "\n", 273 | "Statistics:\n", 274 | "- Number of variables: 5\n", 275 | "- Number of constraints: 5\n", 276 | "- Solve time: 0.007s\n" 277 | ] 278 | } 279 | ], 280 | "source": [ 281 | "from pulp import *\n", 282 | "from ortools.utils import output\n", 283 | "\n", 284 | "n = 5\n", 285 | "year = 4\n", 286 | "\n", 287 | "npv = [30, 10, 15, 12, 35]\n", 288 | "\n", 289 | "amount = [\n", 290 | " [20, 25, 25, 20],\n", 291 | " [10, 20, 15, 10],\n", 292 | " [15, 30, 20, 5],\n", 293 | " [10, 15, 10, 15],\n", 294 | " [25, 30, 30, 25]\n", 295 | "]\n", 296 | "\n", 297 | "capital = [70, 90, 80, 60]\n", 298 | "\n", 299 | "# Define problem\n", 300 | "prob = LpProblem('Capital Budgeting Problem', LpMaximize)\n", 301 | "\n", 302 | "indexs = [(i) for i in range(n)]\n", 303 | "\n", 304 | "x = LpVariable.dicts('X', indexs, lowBound=0, cat='Binary')\n", 305 | "\n", 306 | "# Set objective function\n", 307 | "prob += lpSum([npv[i]*x[i] for i in range(n)])\n", 308 | "\n", 309 | "# Set constraint\n", 310 | "for j in range(year):\n", 311 | " prob += lpSum([amount[i][j]*x[i] for i in range(n)]) <= capital[j]\n", 312 | " \n", 313 | "# Added multiple choice constraint\n", 314 | "prob += lpSum([x[i] for i in range(n)]) <= 3\n", 315 | " \n", 316 | "prob.solve()\n", 317 | "output(prob)" 318 | ] 319 | }, 320 | { 321 | "cell_type": "markdown", 322 | "metadata": {}, 323 | "source": [ 324 | "#### Conditional constraint\n", 325 | "\n", 326 | "만일 투자대상 1($X_{1}$)이 선택되면 투자대상 2($X_{2}$)도 선택되어야 한다는 조건부 선택제약식, 위 제약식은 투자대상 2($X_{2}$)가 선택되더라도 투자대상 1($X_{1}$)이 선택된다는 보장이 없으므로 위 제약식을 조건 부 제약식(conditional constraint)이라고 한다.
" 327 | ] 328 | }, 329 | { 330 | "cell_type": "code", 331 | "execution_count": 5, 332 | "metadata": {}, 333 | "outputs": [ 334 | { 335 | "name": "stdout", 336 | "output_type": "stream", 337 | "text": [ 338 | "Status: Optimal\n", 339 | "Objective value: 75.0\n", 340 | "\n", 341 | "Variables Values\n", 342 | "----------- --------\n", 343 | "X_0 1\n", 344 | "X_1 1\n", 345 | "X_2 0\n", 346 | "X_3 0\n", 347 | "X_4 1\n", 348 | "\n", 349 | "Statistics:\n", 350 | "- Number of variables: 5\n", 351 | "- Number of constraints: 5\n", 352 | "- Solve time: 0.008s\n" 353 | ] 354 | } 355 | ], 356 | "source": [ 357 | "from pulp import *\n", 358 | "from ortools.utils import output\n", 359 | "\n", 360 | "n = 5\n", 361 | "year = 4\n", 362 | "\n", 363 | "npv = [30, 10, 15, 12, 35]\n", 364 | "\n", 365 | "amount = [\n", 366 | " [20, 25, 25, 20],\n", 367 | " [10, 20, 15, 10],\n", 368 | " [15, 30, 20, 5],\n", 369 | " [10, 15, 10, 15],\n", 370 | " [25, 30, 30, 25]\n", 371 | "]\n", 372 | "\n", 373 | "capital = [70, 90, 80, 60]\n", 374 | "\n", 375 | "# Define problem\n", 376 | "prob = LpProblem('Capital Budgeting Problem', LpMaximize)\n", 377 | "\n", 378 | "indexs = [(i) for i in range(n)]\n", 379 | "\n", 380 | "x = LpVariable.dicts('X', indexs, lowBound=0, cat='Binary')\n", 381 | "\n", 382 | "# Set objective function\n", 383 | "prob += lpSum([npv[i]*x[i] for i in range(n)])\n", 384 | "\n", 385 | "# Set constraint\n", 386 | "for j in range(year):\n", 387 | " prob += lpSum([amount[i][j]*x[i] for i in range(n)]) <= capital[j]\n", 388 | " \n", 389 | "# Added multiple choice constraint\n", 390 | "prob += x[0] - x[1] <= 0\n", 391 | " \n", 392 | "prob.solve()\n", 393 | "output(prob)" 394 | ] 395 | }, 396 | { 397 | "cell_type": "markdown", 398 | "metadata": {}, 399 | "source": [ 400 | "#### Corequisite constraint\n", 401 | "\n", 402 | "투자대상 1($X_{1}$)과 투자대상 2($X_{2}$)가 동시에 선택되거나 동시에 선택되지 않는 제약식, 이를 동시요구 제약식(corequisite constraint)이라고 한다.
" 403 | ] 404 | }, 405 | { 406 | "cell_type": "code", 407 | "execution_count": 6, 408 | "metadata": {}, 409 | "outputs": [ 410 | { 411 | "name": "stdout", 412 | "output_type": "stream", 413 | "text": [ 414 | "Status: Optimal\n", 415 | "Objective value: 75.0\n", 416 | "\n", 417 | "Variables Values\n", 418 | "----------- --------\n", 419 | "X_0 1\n", 420 | "X_1 1\n", 421 | "X_2 0\n", 422 | "X_3 0\n", 423 | "X_4 1\n", 424 | "\n", 425 | "Statistics:\n", 426 | "- Number of variables: 5\n", 427 | "- Number of constraints: 5\n", 428 | "- Solve time: 0.007s\n" 429 | ] 430 | } 431 | ], 432 | "source": [ 433 | "from pulp import *\n", 434 | "from ortools.utils import output\n", 435 | "\n", 436 | "n = 5\n", 437 | "year = 4\n", 438 | "\n", 439 | "npv = [30, 10, 15, 12, 35]\n", 440 | "\n", 441 | "amount = [\n", 442 | " [20, 25, 25, 20],\n", 443 | " [10, 20, 15, 10],\n", 444 | " [15, 30, 20, 5],\n", 445 | " [10, 15, 10, 15],\n", 446 | " [25, 30, 30, 25]\n", 447 | "]\n", 448 | "\n", 449 | "capital = [70, 90, 80, 60]\n", 450 | "\n", 451 | "# Define problem\n", 452 | "prob = LpProblem('Capital Budgeting Problem', LpMaximize)\n", 453 | "\n", 454 | "indexs = [(i) for i in range(n)]\n", 455 | "\n", 456 | "x = LpVariable.dicts('X', indexs, lowBound=0, cat='Binary')\n", 457 | "\n", 458 | "# Set objective function\n", 459 | "prob += lpSum([npv[i]*x[i] for i in range(n)])\n", 460 | "\n", 461 | "# Set constraint\n", 462 | "for j in range(year):\n", 463 | " prob += lpSum([amount[i][j]*x[i] for i in range(n)]) <= capital[j]\n", 464 | " \n", 465 | "# Added multiple choice constraint\n", 466 | "prob += x[0] - x[1] == 0\n", 467 | " \n", 468 | "prob.solve()\n", 469 | "output(prob)" 470 | ] 471 | }, 472 | { 473 | "cell_type": "markdown", 474 | "metadata": {}, 475 | "source": [ 476 | "투자대상 1($X_{1}$)과 투자대상 2($X_{2}$) 중에서 반드시 1개의 투자대상만을 선택해야 한다는 양자택일형 제약식
" 477 | ] 478 | }, 479 | { 480 | "cell_type": "code", 481 | "execution_count": 7, 482 | "metadata": {}, 483 | "outputs": [ 484 | { 485 | "name": "stdout", 486 | "output_type": "stream", 487 | "text": [ 488 | "Status: Optimal\n", 489 | "Objective value: 80.0\n", 490 | "\n", 491 | "Variables Values\n", 492 | "----------- --------\n", 493 | "X_0 1\n", 494 | "X_1 0\n", 495 | "X_2 1\n", 496 | "X_3 0\n", 497 | "X_4 1\n", 498 | "\n", 499 | "Statistics:\n", 500 | "- Number of variables: 5\n", 501 | "- Number of constraints: 5\n", 502 | "- Solve time: 0.007s\n" 503 | ] 504 | } 505 | ], 506 | "source": [ 507 | "from pulp import *\n", 508 | "from ortools.utils import output\n", 509 | "\n", 510 | "n = 5\n", 511 | "year = 4\n", 512 | "\n", 513 | "npv = [30, 10, 15, 12, 35]\n", 514 | "\n", 515 | "amount = [\n", 516 | " [20, 25, 25, 20],\n", 517 | " [10, 20, 15, 10],\n", 518 | " [15, 30, 20, 5],\n", 519 | " [10, 15, 10, 15],\n", 520 | " [25, 30, 30, 25]\n", 521 | "]\n", 522 | "\n", 523 | "capital = [70, 90, 80, 60]\n", 524 | "\n", 525 | "# Define problem\n", 526 | "prob = LpProblem('Capital Budgeting Problem', LpMaximize)\n", 527 | "\n", 528 | "indexs = [(i) for i in range(n)]\n", 529 | "\n", 530 | "x = LpVariable.dicts('X', indexs, lowBound=0, cat='Binary')\n", 531 | "\n", 532 | "# Set objective function\n", 533 | "prob += lpSum([npv[i]*x[i] for i in range(n)])\n", 534 | "\n", 535 | "# Set constraint\n", 536 | "for j in range(year):\n", 537 | " prob += lpSum([amount[i][j]*x[i] for i in range(n)]) <= capital[j]\n", 538 | " \n", 539 | "# Added multiple choice constraint\n", 540 | "prob += x[0] + x[1] == 1\n", 541 | " \n", 542 | "prob.solve()\n", 543 | "output(prob)" 544 | ] 545 | }, 546 | { 547 | "cell_type": "markdown", 548 | "metadata": {}, 549 | "source": [ 550 | "#### Mutually exclusive constraint\n", 551 | "\n", 552 | "투자대상 1($X_{1}$)과 투자대상 2($X_{2}$) 동시에 선택될 수 없다는 제약식, 이는 2개의 투자대상이 전혀 선택되지 않을 수도 있고 선택된다면 꼭 1개가 선택되는 경우이다. 이와 같은 제약식을 상호배타적 제약식(mutually exclusive constraint)이라고 한다.
" 553 | ] 554 | }, 555 | { 556 | "cell_type": "code", 557 | "execution_count": 19, 558 | "metadata": {}, 559 | "outputs": [ 560 | { 561 | "name": "stdout", 562 | "output_type": "stream", 563 | "text": [ 564 | "Status: Optimal\n", 565 | "Objective value: 80.0\n", 566 | "\n", 567 | "Variables Values\n", 568 | "----------- --------\n", 569 | "x_0 1\n", 570 | "x_1 0\n", 571 | "x_2 1\n", 572 | "x_3 0\n", 573 | "x_4 1\n", 574 | "\n", 575 | "Statistics:\n", 576 | "- Number of variables: 5\n", 577 | "- Number of constraints: 5\n", 578 | "- Solve time: 0.029s\n" 579 | ] 580 | } 581 | ], 582 | "source": [ 583 | "from pulp import *\n", 584 | "from ortools.utils import output\n", 585 | "\n", 586 | "n = 5\n", 587 | "year = 4\n", 588 | "\n", 589 | "npv = [30, 10, 15, 12, 35]\n", 590 | "\n", 591 | "amount = [\n", 592 | " [20, 25, 25, 20],\n", 593 | " [10, 20, 15, 10],\n", 594 | " [15, 30, 20, 5],\n", 595 | " [10, 15, 10, 15],\n", 596 | " [25, 30, 30, 25]\n", 597 | "]\n", 598 | "\n", 599 | "capital = [70, 90, 80, 60]\n", 600 | "\n", 601 | "# Define problem\n", 602 | "prob = LpProblem('Capital Budgeting Problem', LpMaximize)\n", 603 | "\n", 604 | "indexs = [(i) for i in range(n)]\n", 605 | "\n", 606 | "x = LpVariable.dicts('X', indexs, lowBound=0, cat='Binary')\n", 607 | "\n", 608 | "# Set objective function\n", 609 | "prob += lpSum([npv[i]*x[i] for i in range(n)])\n", 610 | "\n", 611 | "# Set constraint\n", 612 | "for j in range(year):\n", 613 | " prob += lpSum([amount[i][j]*x[i] for i in range(n)]) <= capital[j]\n", 614 | " \n", 615 | "# Added multiple choice constraint\n", 616 | "prob += x[0] + x[1] <= 1\n", 617 | " \n", 618 | "prob.solve()\n", 619 | "output(prob)" 620 | ] 621 | }, 622 | { 623 | "cell_type": "markdown", 624 | "metadata": {}, 625 | "source": [ 626 | "다음은 4개의 제약식 중에서 1개의 제약식만을 선택하는 제약식,
" 627 | ] 628 | }, 629 | { 630 | "cell_type": "code", 631 | "execution_count": 25, 632 | "metadata": {}, 633 | "outputs": [ 634 | { 635 | "name": "stdout", 636 | "output_type": "stream", 637 | "text": [ 638 | "Status: Optimal\n", 639 | "Objective value: 55.0\n", 640 | "\n", 641 | "Variables Values\n", 642 | "----------- --------\n", 643 | "X1 1\n", 644 | "X2 1\n", 645 | "X3 1\n", 646 | "Y 0\n", 647 | "\n", 648 | "Statistics:\n", 649 | "- Number of variables: 4\n", 650 | "- Number of constraints: 2\n", 651 | "- Solve time: 0.025s\n" 652 | ] 653 | } 654 | ], 655 | "source": [ 656 | "from pulp import *\n", 657 | "from ortools.utils import output\n", 658 | "\n", 659 | "n = 5\n", 660 | "year = 4\n", 661 | "\n", 662 | "npv = [30, 10, 15, 12, 35]\n", 663 | "\n", 664 | "amount = [\n", 665 | " [20, 25, 25, 20],\n", 666 | " [10, 20, 15, 10],\n", 667 | " [15, 30, 20, 5],\n", 668 | " [10, 15, 10, 15],\n", 669 | " [25, 30, 30, 25]\n", 670 | "]\n", 671 | "\n", 672 | "capital = [70, 90, 80, 60]\n", 673 | "\n", 674 | "M = 1000\n", 675 | "\n", 676 | "# Define problem\n", 677 | "prob = LpProblem('Capital Budgeting Problem', LpMaximize)\n", 678 | "\n", 679 | "x1 = LpVariable('X1', lowBound=0, cat='Binary')\n", 680 | "x2 = LpVariable('X2', lowBound=0, cat='Binary')\n", 681 | "x3 = LpVariable('X3', lowBound=0, cat='Binary')\n", 682 | "y = LpVariable('Y', lowBound=0, cat='Binary')\n", 683 | "\n", 684 | "# Set objective function\n", 685 | "prob += 30*x1 + 10*x2 + 15*x3\n", 686 | "\n", 687 | "# Set constraint\n", 688 | "prob += 20*x1 + 10*x2 + 15*x3 <= 70 + y * M\n", 689 | "prob += 25*x1 + 20*x2 + 30*x3 <= 90 + (1 - y) * M\n", 690 | "\n", 691 | "prob.solve()\n", 692 | "output(prob)" 693 | ] 694 | }, 695 | { 696 | "cell_type": "markdown", 697 | "metadata": {}, 698 | "source": [ 699 | "$m$개의 제약식 중에서 $k$개를 선택하는 제약식(단, $k Table 6-1는 배낭에 넣어 갖고 갈 수 있는 3개의 상이한 품목에 대한 품목별 무게와 효용 및 배낭의 보관능력을 나타내고 있다. 배낭의 보관능력 제약을 만족하면서 배낭에 넣어 갖고 갈 수 있는 품목의 효용을 최대화하는 정수계획모형을 작성한 후 최적 정수해를 구하라. 단, 같은 품목을 중복으로 배낭에 넣을 수 없다. 단일품목 배낭문제를 0-1정수계획모형으로 정식화하기 위해서는 배낭에 넣을 수 있는 품목 $j$를 결정변수 $X_{j}$라고 정의하고 $X_{j}$가 0과 1 중에서 하나의 값만 갖도록 하여야 한다. 왜냐하면 배낭에 넣어 갖고 갈 수 있는 품목은 단일품목 배낭문제의 성격상 그 품목을 선택하거나 또는 선택하지 않기 때문이다. 따라서 $X_{j}$가 1의 값을 가질 때는 품목 $j$가 선택되고, 0의 값을 가질 때는 품목 $j$가 선택되지 않는다고 하자. 만일 각 품목에 대해 전체가 아닌 일부분의 선택이 가능하다면 이 문제는 분할성의 가정이 성립하므로 선형계획문제로 정식화할 수 있다. Table 6-3는 트럭에 적재할 수 있는 3개의 상이한 품목에 대하여 이들 품목별 단위당 무게, 적재가능 수량, 단위당 수익 및 트럭의 적재능력을 나타내고 있다. 트럭의 적재능력의 제약을 만족하면서 트럭에 품목들을 적재하여 최대의 수익을 얻을려고 한다. 트럭의 수익을 최대로 하는 적재 품목의 수량을 결정하기 위한 정수계획 모형을 작성하고 최적해를 구하라. 단, 트럭에 적재하는 품목의 수량은 정수단위로 결정해야 한다.\n",
18 | "
\n",
42 | "\n",
43 | "\n",
20 | " \n",
25 | " 품목 \n",
21 | " 무게(kg) \n",
22 | " 효용 \n",
23 | " 배낭의 보관능력(kg) \n",
24 | " \n",
26 | " \n",
31 | " 1 \n",
27 | " 3 \n",
28 | " 7 \n",
29 | " 6 \n",
30 | " \n",
32 | " \n",
36 | " 2 \n",
33 | " 4 \n",
34 | " 8 \n",
35 | " \n",
37 | " \n",
41 | "3 \n",
38 | " 2 \n",
39 | " 3 \n",
40 | " \n",
117 | "
"
145 | ]
146 | },
147 | {
148 | "cell_type": "code",
149 | "execution_count": 4,
150 | "metadata": {},
151 | "outputs": [
152 | {
153 | "name": "stdout",
154 | "output_type": "stream",
155 | "text": [
156 | "Status Optimal\n",
157 | "Z = 21000.0\n",
158 | "x1 = 100.0\n",
159 | "x2 = 175.0\n",
160 | "x3 = 0.0\n"
161 | ]
162 | }
163 | ],
164 | "source": [
165 | "from pulp import *\n",
166 | "\n",
167 | "prob = LpProblem(name='Knapsack Problem', sense=LpMaximize)\n",
168 | "\n",
169 | "x1 = LpVariable(name='x1', lowBound=0, cat='Integer')\n",
170 | "x2 = LpVariable(name='x2', lowBound=0, cat='Integer')\n",
171 | "x3 = LpVariable(name='x3', lowBound=0, cat='Integer')\n",
172 | "\n",
173 | "prob += 70*x1 + 80*x2 + 30*x3\n",
174 | "\n",
175 | "prob += 30*x1 + 40*x2 + 20*x3 <= 10000\n",
176 | "prob += x1 <= 100\n",
177 | "prob += x2 <= 200\n",
178 | "prob += x3 <= 300\n",
179 | "\n",
180 | "# Solving problem\n",
181 | "prob.solve()\n",
182 | "print('Status', LpStatus[prob.status])\n",
183 | "\n",
184 | "print('Z = {}'.format(value(prob.objective)))\n",
185 | "for i in prob.variables():\n",
186 | " print('{} = {}'.format(i.name, i.varValue))"
187 | ]
188 | },
189 | {
190 | "cell_type": "code",
191 | "execution_count": null,
192 | "metadata": {},
193 | "outputs": [],
194 | "source": []
195 | },
196 | {
197 | "cell_type": "code",
198 | "execution_count": null,
199 | "metadata": {},
200 | "outputs": [],
201 | "source": []
202 | },
203 | {
204 | "cell_type": "markdown",
205 | "metadata": {},
206 | "source": [
207 | "### Example: Bin Packing Problem\n",
208 | "\n",
209 | "$$\\begin{split}\n",
210 | " & \\text{minimize } &Z=&\\sum_{i=1}^{n}y_{i} & &\\\\[1ex]\n",
211 | " & \\text{subject to } & &\\sum_{j=1}^{n}w_{j}x_{ij} \\le cy_{i},\\quad &i \\in N = \\{1,...,n\\},&\\\\[1ex]\n",
212 | " & & &\\sum_{i=1}^{n}x_{ij} = 1, &j \\in N,&\\\\[1ex] \n",
213 | " & & &y_{i} = 0 or 1, &i \\in N,&\\\\[1ex] \n",
214 | " & & &x_{ij} = 0 or 1 &i \\in N, j \\in N,&\\\\[1ex] \n",
215 | "\\end{split}$$"
216 | ]
217 | },
218 | {
219 | "cell_type": "code",
220 | "execution_count": 21,
221 | "metadata": {},
222 | "outputs": [
223 | {
224 | "name": "stdout",
225 | "output_type": "stream",
226 | "text": [
227 | "Solved in 0.05406332015991211 seconds.\n",
228 | "Bins used: 5.0\n",
229 | "0: ['a', 'b', 'e', 'i', 'm', 'n']\n",
230 | "1: ['c', 'g', 'h', 'l']\n",
231 | "12: ['d']\n",
232 | "13: ['f']\n",
233 | "7: ['k']\n"
234 | ]
235 | }
236 | ],
237 | "source": [
238 | "from pulp import *\n",
239 | "import time\n",
240 | "\n",
241 | "#\n",
242 | "# A list of item tuples (name, weight) -- name is meaningless except to humans.\n",
243 | "# Weight and Size are used interchangeably here and elsewhere.\n",
244 | "#\n",
245 | "items = [(\"a\", 5),\n",
246 | " (\"b\", 6),\n",
247 | " (\"c\", 7),\n",
248 | " (\"d\", 32),\n",
249 | " (\"e\", 2),\n",
250 | " (\"f\", 32),\n",
251 | " (\"g\", 5),\n",
252 | " (\"h\", 7),\n",
253 | " (\"i\", 9),\n",
254 | " (\"k\", 12),\n",
255 | " (\"l\", 11),\n",
256 | " (\"m\", 1),\n",
257 | " (\"n\", 2)]\n",
258 | "\n",
259 | "itemCount = len(items)\n",
260 | "\n",
261 | "# Max number of bins allowed.\n",
262 | "maxBins = 32\n",
263 | "\n",
264 | "# Bin Size\n",
265 | "binCapacity = 32\n",
266 | "\n",
267 | "\n",
268 | "\n",
269 | "# Indicator variable assigned 1 when the bin is used.\n",
270 | "y = pulp.LpVariable.dicts('BinUsed', range(maxBins),\n",
271 | " lowBound = 0,\n",
272 | " upBound = 1,\n",
273 | " cat = pulp.LpInteger)\n",
274 | "\n",
275 | "# An indicator variable that is assigned 1 when item is placed into binNum\n",
276 | "possible_ItemInBin = [(itemTuple[0], binNum) for itemTuple in items\n",
277 | " for binNum in range(maxBins)]\n",
278 | "x = pulp.LpVariable.dicts('itemInBin', possible_ItemInBin,\n",
279 | " lowBound = 0,\n",
280 | " upBound = 1,\n",
281 | " cat = pulp.LpInteger)\n",
282 | "\n",
283 | "# Initialize the problem\n",
284 | "prob = LpProblem(\"Bin Packing Problem\", LpMinimize)\n",
285 | "\n",
286 | "# Add the objective function.\n",
287 | "prob += lpSum([y[i] for i in range(maxBins)]), \"Objective: Minimize Bins Used\"\n",
288 | "\n",
289 | "#\n",
290 | "# This is the constraints section.\n",
291 | "#\n",
292 | "\n",
293 | "# First constraint: For every item, the sum of bins in which it appears must be 1\n",
294 | "for j in items:\n",
295 | " prob += lpSum([x[(j[0], i)] for i in range(maxBins)]) == 1, (\"An item can be in only 1 bin -- \" + str(j[0]))\n",
296 | "\n",
297 | "# Second constraint: For every bin, the number of items in the bin cannot exceed the bin capacity\n",
298 | "for i in range(maxBins):\n",
299 | " prob += lpSum([items[j][1] * x[(items[j][0], i)] for j in range(itemCount)]) <= binCapacity*y[i], (\"The sum of item sizes must be smaller than the bin -- \" + str(i))\n",
300 | "\n",
301 | "# Write the model to disk\n",
302 | "\n",
303 | "# Solve the optimization.\n",
304 | "start_time = time.time()\n",
305 | "prob.solve()\n",
306 | "print(\"Solved in %s seconds.\" % (time.time() - start_time))\n",
307 | "\n",
308 | "\n",
309 | "# Bins used\n",
310 | "print(\"Bins used: \" + str(sum(([y[i].value() for i in range(maxBins)]))))\n",
311 | "\n",
312 | "# The rest of this is some unpleasent massaging to get pretty results.\n",
313 | "bins = {}\n",
314 | "for itemBinPair in x.keys():\n",
315 | " if(x[itemBinPair].value() == 1):\n",
316 | " itemNum = itemBinPair[0]\n",
317 | " binNum = itemBinPair[1]\n",
318 | " if binNum in bins:\n",
319 | " bins[binNum].append(itemNum)\n",
320 | " else:\n",
321 | " bins[binNum] = [itemNum]\n",
322 | "\n",
323 | "for b in bins.keys():\n",
324 | " print(str(b) + \": \" + str(bins[b]))"
325 | ]
326 | },
327 | {
328 | "cell_type": "code",
329 | "execution_count": null,
330 | "metadata": {},
331 | "outputs": [],
332 | "source": []
333 | },
334 | {
335 | "cell_type": "markdown",
336 | "metadata": {},
337 | "source": [
338 | "### Problem 3"
339 | ]
340 | },
341 | {
342 | "cell_type": "code",
343 | "execution_count": null,
344 | "metadata": {},
345 | "outputs": [],
346 | "source": [
347 | "from pulp import *\n",
348 | "\n"
349 | ]
350 | },
351 | {
352 | "cell_type": "code",
353 | "execution_count": null,
354 | "metadata": {},
355 | "outputs": [],
356 | "source": [
357 | "prob = LpProblem(name='Profit maximising problem', sense=LpMaximize)"
358 | ]
359 | },
360 | {
361 | "cell_type": "code",
362 | "execution_count": null,
363 | "metadata": {},
364 | "outputs": [],
365 | "source": [
366 | "x1 = LpVariable(name='x1', lowBound=0, cat='Integer')\n",
367 | "x2 = LpVariable(name='x2', lowBound=0, cat='Integer')\n",
368 | "\n",
369 | "prob += 30000*x1 + 45000*x2, 'Profit'\n",
370 | "\n",
371 | "prob += 3*x1 + 4*x2 <= 30\n",
372 | "prob += 5*x1 + 6*x2 <= 60\n",
373 | "prob += 1.5*x1 + 3*x2 <= 21"
374 | ]
375 | },
376 | {
377 | "cell_type": "code",
378 | "execution_count": null,
379 | "metadata": {},
380 | "outputs": [],
381 | "source": [
382 | "prob.solve(solver=GUROBI())\n",
383 | "\n",
384 | "print(LpStatus[prob.status])\n",
385 | "\n",
386 | "# Print our decision variable values\n",
387 | "print('Production of Car x1 = {}'.format(x1.varValue))\n",
388 | "print('Production of Car x2 = {}'.format(x2.varValue))\n",
389 | "\n",
390 | "# Print our objective function value\n",
391 | "print(value(prob.objective))"
392 | ]
393 | },
394 | {
395 | "cell_type": "markdown",
396 | "metadata": {},
397 | "source": [
398 | "### Knapsack Problem"
399 | ]
400 | },
401 | {
402 | "cell_type": "code",
403 | "execution_count": null,
404 | "metadata": {},
405 | "outputs": [],
406 | "source": [
407 | "from pulp import *"
408 | ]
409 | },
410 | {
411 | "cell_type": "code",
412 | "execution_count": null,
413 | "metadata": {},
414 | "outputs": [],
415 | "source": [
416 | "model = LpProblem('knapsack problem', LpMaximize)"
417 | ]
418 | },
419 | {
420 | "cell_type": "code",
421 | "execution_count": null,
422 | "metadata": {},
423 | "outputs": [],
424 | "source": [
425 | "x1 = LpVariable('x1', lowBound=0, upBound=1, cat=LpInteger)\n",
426 | "x2 = LpVariable('x2', lowBound=0, upBound=1, cat=LpInteger)\n",
427 | "x3 = LpVariable('x3', lowBound=0, upBound=1, cat=LpInteger)"
428 | ]
429 | },
430 | {
431 | "cell_type": "code",
432 | "execution_count": null,
433 | "metadata": {},
434 | "outputs": [],
435 | "source": [
436 | "model += 7*x1 + 8*x2 + 3*x3\n",
437 | "model += 3*x1 + 4*x2 + 2*x3 <= 6"
438 | ]
439 | },
440 | {
441 | "cell_type": "code",
442 | "execution_count": null,
443 | "metadata": {},
444 | "outputs": [],
445 | "source": [
446 | "model.solve(GUROBI())\n",
447 | "\n",
448 | "print('Status', LpStatus[model.status])\n",
449 | "print(value(model.objective))\n",
450 | "for v in model.variables():\n",
451 | " print(v.name, '=', v.varValue)"
452 | ]
453 | },
454 | {
455 | "cell_type": "markdown",
456 | "metadata": {},
457 | "source": [
458 | "### Knapsack Problem II"
459 | ]
460 | },
461 | {
462 | "cell_type": "code",
463 | "execution_count": null,
464 | "metadata": {},
465 | "outputs": [],
466 | "source": [
467 | "from pulp import *"
468 | ]
469 | },
470 | {
471 | "cell_type": "code",
472 | "execution_count": null,
473 | "metadata": {},
474 | "outputs": [],
475 | "source": [
476 | "items = ['A', 'B', 'C']\n",
477 | "weights = [3, 4, 2]\n",
478 | "values = [7, 8, 3]"
479 | ]
480 | },
481 | {
482 | "cell_type": "code",
483 | "execution_count": null,
484 | "metadata": {},
485 | "outputs": [],
486 | "source": [
487 | "prob = LpProblem('knapsack problem', LpMaximize)\n",
488 | "\n",
489 | "# Define decision variables\n",
490 | "decision_variables = []\n",
491 | "for num, i in enumerate(items):\n",
492 | " var_str = str('x' + str(num))\n",
493 | " variables = LpVariable(str(var_str), lowBound=0, upBound=1, cat='Integer')\n",
494 | " decision_variables.append(variables)\n",
495 | "print(decision_variables)\n",
496 | "\n",
497 | "# Define objective function\n",
498 | "objective_function = ''\n",
499 | "for u, uf in enumerate(values):\n",
500 | " for d, dv in enumerate(decision_variables):\n",
501 | " if u == d:\n",
502 | " objective_function += uf * dv\n",
503 | " \n",
504 | "prob += objective_function\n",
505 | "print(objective_function)\n",
506 | "\n",
507 | "# Define constraint\n",
508 | "capacity = 6\n",
509 | "constraint = ''\n",
510 | "for w, wt in enumerate(weights):\n",
511 | " for d, dv in enumerate(decision_variables):\n",
512 | " if w == d:\n",
513 | " constraint += wt * dv\n",
514 | " \n",
515 | "prob += constraint <= capacity\n",
516 | "print(constraint)"
517 | ]
518 | },
519 | {
520 | "cell_type": "code",
521 | "execution_count": null,
522 | "metadata": {},
523 | "outputs": [],
524 | "source": [
525 | "prob.solve(GUROBI())\n",
526 | "\n",
527 | "print('Status', LpStatus[prob.status])\n",
528 | "print(value(prob.objective))\n",
529 | "for v in prob.variables():\n",
530 | " print(v.name, '=', v.varValue)"
531 | ]
532 | },
533 | {
534 | "cell_type": "code",
535 | "execution_count": null,
536 | "metadata": {},
537 | "outputs": [],
538 | "source": [
539 | "from pulp import *"
540 | ]
541 | },
542 | {
543 | "cell_type": "code",
544 | "execution_count": null,
545 | "metadata": {},
546 | "outputs": [],
547 | "source": [
548 | "data = {\n",
549 | " (\"SMITH\"): [6,8,30,6,20], (\"JOHNSON\"): [6,8,50,0,24], \n",
550 | " ('WILLIAMS'): [6,8,30,0,24], ('JONES'): [6,8,30,0,24], \n",
551 | " ('BROWN'): [6,8,40,0,24], ('DAVIS'): [6,8,50,0,24],\n",
552 | " ('MILLER'): [6,8,45,6,18], ('WILSON'): [6,8,30,0,24], \n",
553 | " ('MOORE'): [6,8,35,0,24], ('TAYLOR'): [6,8,40,0,24], \n",
554 | " ('ANDERSON'): [2,3,60,0,6], ('THOMAS'): [2,4,40,0,24],\n",
555 | " ('JACKSON') :[2,4,60,8,16], ('WHITE'): [2,6,55,0,24], \n",
556 | " ('HARRIS'): [2,6,45,0,24], ('MARTIN'): [2,3,40,0,24], \n",
557 | " ('THOMPSON'): [2,5,50,12,24], ('GARCIA'): [2,4,50,0,24],\n",
558 | " ('MARTINEZ'): [2,4,40,0,24], ('ROBINSON'): [2,5,50,0,24]\n",
559 | "}\n",
560 | "\n",
561 | "required = [1,1,2,3,6,6,7,8,9,8,8,8,7,6,6,5,5,4,4,3,2,2,2,2]\n",
562 | "\n",
563 | "time = 24"
564 | ]
565 | },
566 | {
567 | "cell_type": "code",
568 | "execution_count": null,
569 | "metadata": {},
570 | "outputs": [],
571 | "source": [
572 | "employee = list(data.keys())\n",
573 | "mins, maxs, costs, avs, ave = splitDict(data)"
574 | ]
575 | },
576 | {
577 | "cell_type": "code",
578 | "execution_count": null,
579 | "metadata": {},
580 | "outputs": [],
581 | "source": [
582 | "x = {}\n",
583 | "for d in employee:\n",
584 | " for i in range(time):\n",
585 | " for j in range(i+1, time+1):\n",
586 | " x[d,i,j] = LpVariable(name='x_%s%d%d'%(d,i,j), cat='Binary')\n",
587 | " \n",
588 | "staff_number = {}\n",
589 | "for t in range(time):\n",
590 | " staff_number[t] = LpVariable(name='staffNumber_%d'%t, cat='Integer', lowBound=required[t])"
591 | ]
592 | },
593 | {
594 | "cell_type": "code",
595 | "execution_count": null,
596 | "metadata": {},
597 | "outputs": [],
598 | "source": [
599 | "prob = LpProblem('Work Schedule', LpMinimize)"
600 | ]
601 | },
602 | {
603 | "cell_type": "code",
604 | "execution_count": null,
605 | "metadata": {},
606 | "outputs": [],
607 | "source": [
608 | "prob += lpSum(lpSum(lpSum((j-i) * x[d,i,j] * costs[d] for j in range(i+1,time+1)) \\\n",
609 | " for i in range(time)) for d in employee)"
610 | ]
611 | },
612 | {
613 | "cell_type": "code",
614 | "execution_count": null,
615 | "metadata": {},
616 | "outputs": [],
617 | "source": [
618 | "for d in employee:\n",
619 | " prob += (lpSum(lpSum(x[d,i,j] for j in range(i+1,ave[d]+1)if min[d] <= \\\n",
620 | " (j-i) <= max[d]) for i in range(avs[d],ave[d])) <= 1)\n",
621 | " \n",
622 | " prob += (lpSum(lpSum(x[d,i,j] for j in range(i+1,time+1)) for i in range(time)) <= \\\n",
623 | " lpSum(quicksum(x[d,i,j] for j in range(i+1,ave[d]+1) if min[d] <= (j-i) <= \\\n",
624 | " max[d]) for i in range(avs[d],ave[d])))\n",
625 | "\n",
626 | " \n",
627 | " \n",
628 | "for d in employee:\n",
629 | " m.addConstr(quicksum(quicksum(x[d,i,j] for j in range(i+1,ave[d]+1)if min[d] <= (j-i) <= max[d])for i in range(avs[d],ave[d]))<=1)\n",
630 | " m.addConstr(quicksum(quicksum(x[d,i,j] for j in range(i+1,t+1))for i in range(t))<=quicksum(quicksum(x[d,i,j] for j in range(i+1,ave[d]+1)\n",
631 | " if min[d] <= (j-i) <= max[d])for i in range(avs[d],ave[d])))\n",
632 | " \n",
633 | " \n",
634 | "for c in range(t):\n",
635 | " m.addConstr(quicksum(quicksum(quicksum(x[d,i,j] for j in range(i+1,t+1)if i <= c \n",
119 | " \n",
125 | " 품목 \n",
120 | " 단위당 무게(kg) \n",
121 | " 적재가능수량(개) \n",
122 | " 단위당 수익(천원) \n",
123 | " 적재능력(kg) \n",
124 | " \n",
126 | " \n",
132 | " 1 \n",
127 | " 30 \n",
128 | " 100 \n",
129 | " 70 \n",
130 | " 6 \n",
131 | " \n",
133 | " \n",
138 | " 2 \n",
134 | " 40 \n",
135 | " 200 \n",
136 | " 80 \n",
137 | " \n",
139 | " \n",
144 | "3 \n",
140 | " 20 \n",
141 | " 300 \n",
142 | " 30 \n",
143 | "