From 53cb00ab26c1200138a827960b0309e2633a035b Mon Sep 17 00:00:00 2001 From: Viu Long Kong Date: Wed, 6 Nov 2019 15:58:49 +0100 Subject: [PATCH] 2.11.176 --- examples/cp/basic/house_building.py | 1 + .../mp/jupyter/Benders_decomposition.ipynb | 4 +- examples/mp/jupyter/boxes.ipynb | 4 +- .../mp/jupyter/chicago_coffee_shops.ipynb | 4 +- examples/mp/jupyter/efficient.ipynb | 184 ++++--- examples/mp/jupyter/green_truck.ipynb | 4 +- .../mp/jupyter/incremental_modeling.ipynb | 4 +- .../mp/jupyter/lagrangian_relaxation.ipynb | 4 +- examples/mp/jupyter/lifegame.ipynb | 4 +- examples/mp/jupyter/load_balancing.ipynb | 24 +- examples/mp/jupyter/logical_cts.ipynb | 244 ++------- examples/mp/jupyter/marketing_campaign.ipynb | 14 +- examples/mp/jupyter/mining_pandas.ipynb | 4 +- .../nurses_pandas-multi_objective.ipynb | 60 +-- examples/mp/jupyter/nurses_pandas.ipynb | 22 +- examples/mp/jupyter/nurses_scheduling.ipynb | 507 ++---------------- examples/mp/jupyter/oil_blending.ipynb | 4 +- examples/mp/jupyter/pasta_production.ipynb | 16 +- examples/mp/jupyter/progress.ipynb | 313 ++--------- examples/mp/jupyter/sports_scheduling.ipynb | 4 +- .../tutorials/Beyond_Linear_Programming.ipynb | 50 +- .../tutorials/Linear_Programming.ipynb | 4 +- examples/mp/jupyter/ucp_pandas.ipynb | 4 +- examples/mp/modeling/diet.py | 38 +- 24 files changed, 349 insertions(+), 1172 deletions(-) diff --git a/examples/cp/basic/house_building.py b/examples/cp/basic/house_building.py index b95c177..3ba1b4f 100644 --- a/examples/cp/basic/house_building.py +++ b/examples/cp/basic/house_building.py @@ -26,6 +26,7 @@ # Max number of periods for the schedule MAX_SCHEDULE = 318 +MAX_SCHEDULE = 200000 # House construction tasks Task = (namedtuple("Task", ["name", "duration"])) diff --git a/examples/mp/jupyter/Benders_decomposition.ipynb b/examples/mp/jupyter/Benders_decomposition.ipynb index 8e80a2c..ec7b9a9 100644 --- a/examples/mp/jupyter/Benders_decomposition.ipynb +++ b/examples/mp/jupyter/Benders_decomposition.ipynb @@ -15,7 +15,7 @@ "\n", ">This notebook is part of **[Prescriptive Analytics for Python](http://ibmdecisionoptimization.github.io/docplex-doc/)**\n", ">\n", - ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/>) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", + ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", "and you can start using Watson Studio Cloud right away).\n", "\n", "Table of contents:\n", @@ -584,7 +584,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.1" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/examples/mp/jupyter/boxes.ipynb b/examples/mp/jupyter/boxes.ipynb index 53393e0..8a55a28 100644 --- a/examples/mp/jupyter/boxes.ipynb +++ b/examples/mp/jupyter/boxes.ipynb @@ -12,7 +12,7 @@ "\n", ">This notebook is part of [Prescriptive Analytics for Python](http://ibmdecisionoptimization.github.io/docplex-doc/)\n", ">\n", - ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/>) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", + ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", "and you can start using Watson Studio Cloud right away).\n", "\n", "\n", @@ -601,7 +601,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.1" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/examples/mp/jupyter/chicago_coffee_shops.ipynb b/examples/mp/jupyter/chicago_coffee_shops.ipynb index 304e45f..9353403 100644 --- a/examples/mp/jupyter/chicago_coffee_shops.ipynb +++ b/examples/mp/jupyter/chicago_coffee_shops.ipynb @@ -14,7 +14,7 @@ "\n", ">This notebook is part of [Prescriptive Analytics for Python](http://ibmdecisionoptimization.github.io/docplex-doc/)\n", ">\n", - ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/>) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", + ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", "and you can start using Watson Studio Cloud right away).\n", "\n", "\n", @@ -666,7 +666,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.1" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/examples/mp/jupyter/efficient.ipynb b/examples/mp/jupyter/efficient.ipynb index 34fd895..59e7d58 100644 --- a/examples/mp/jupyter/efficient.ipynb +++ b/examples/mp/jupyter/efficient.ipynb @@ -10,7 +10,7 @@ "\n", ">This notebook is part of **[Prescriptive Analytics for Python](http://ibmdecisionoptimization.github.io/docplex-doc/)**\n", ">\n", - ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/>) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", + ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", "and you can start using Watson Studio Cloud right away)." ] }, @@ -36,7 +36,7 @@ "text": [ "--> begin fibonacci 30\n", "fibonacci(30) = 832040\n", - "<-- end fibonacci 30, time: 218 ms\n" + "<-- end fibonacci 30, time: 154 ms\n" ] } ], @@ -151,7 +151,7 @@ "output_type": "stream", "text": [ "--> begin bench1_size_1000\n", - "<-- end bench1_size_1000, time: 4488 ms\n", + "<-- end bench1_size_1000, time: 3333 ms\n", "Model: bench1\n", " - number of variables: 1000\n", " - binary=1000, integer=0, continuous=0\n", @@ -186,7 +186,7 @@ "output_type": "stream", "text": [ "--> begin bench1 size=3000\n", - "<-- end bench1 size=3000, time: 39637 ms\n" + "<-- end bench1 size=3000, time: 24649 ms\n" ] } ], @@ -196,6 +196,68 @@ " build_bench_model1(N)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Pitfall #1 : use Model.sum(), not Python sum()\n", + "\n", + "In the above code, we compute the sum of variables using `Model.sum()`, not Python builtin function `sum`. One could wonder why Docplex had to redefine a specific sum function?\n", + "\n", + "Python's um function calls the `+` operator repeatedly, that is, sum([x,y,z, t]) is evaluated as ((x+y)+z)+t. Calling `sum` with `N` arguments then creates `N` intermediate expressions, but there's more. Each intermediate expression has to be copied for the next sum, and as the size of the intermediate expressions grow, each copy takes an O(n) time, and th efinal sum has time in O(N^2).\n", + "On the opposite, `Model.sum()` creates only _one_ expression and incrementally adds each argument to it.\n", + "\n", + "**Summary**: never use Python's builtin sum, instead use `Model.sum()` to compute expresssions in Docplex.\n", + "\n", + "Let's experiment with our benchmark model. First we define a variant function to build the same model as above with Python `sum`, and measure the two build times." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--> begin python_sum_too_slow_n=1000\n", + "<-- end python_sum_too_slow_n=1000, time: 5435 ms\n", + "--> begin same_model_with_model_sum_n=1000\n", + "<-- end same_model_with_model_sum_n=1000, time: 2546 ms\n" + ] + } + ], + "source": [ + "def build_bench_sum(size=10):\n", + " m = Model(name=\"bench1\")\n", + " rsize = range(size)\n", + " # create variables as a dictionary indexed by the range\n", + " ys = m.binary_var_dict(rsize, name=\"my_yvar\")\n", + " # create constraints\n", + " k = {(i,j) : (i + (i+j) %3) for i in rsize for j in rsize}\n", + " for i in rsize:\n", + " m.add(sum(ys[i] * k[i,j] for j in rsize) >= i, \"ct_sum_yjs_%d\" %i)\n", + " # for minimize, create a list of coefficients\n", + " rsize1 = [i+1 for i in rsize]\n", + " m.minimize(sum(ys[k] * rsize[k] for k in rsize))\n", + " return m\n", + "\n", + "s = 1000\n", + "with ContextTimer(\"python_sum_too_slow_n=%d\" % s):\n", + " build_bench_sum(size=s)\n", + "\n", + "with ContextTimer(\"same_model_with_model_sum_n=%d\" % s):\n", + " build_bench_model1(size=s)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Building the Python sum model takes roughly twice as much time as the model with `Model.sum()'." + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -217,7 +279,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -225,7 +287,7 @@ "output_type": "stream", "text": [ "--> begin bench2 size=3000\n", - "<-- end bench2 size=3000, time: 24449 ms\n" + "<-- end bench2 size=3000, time: 15698 ms\n" ] } ], @@ -258,8 +320,8 @@ "\n", "The method is `Model.dotf` takes two arguments:\n", "\n", - " - a dictionary of variables, as create by the Model.xxx_var-dict methods\n", - " - a Python function that takes a variable key an dreturn a float, the coefficient \\\n", + " - a dictionary of variables, as create by the Model._var_dict methods\n", + " - a Python function that takes a variable key and returns a float, the coefficient\n", " \n", "In our example, keys are the integer from 0 to `size-1` .\n", "The coefficient for y_j in the i_th constraint is i+(i+j)%3: here we do not need\n", @@ -270,7 +332,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -278,7 +340,7 @@ "output_type": "stream", "text": [ "--> begin bench3 size=3000\n", - "<-- end bench3 size=3000, time: 15718 ms\n" + "<-- end bench3 size=3000, time: 9409 ms\n" ] } ], @@ -318,7 +380,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -326,7 +388,7 @@ "output_type": "stream", "text": [ "--> begin bench4 size=3000\n", - "<-- end bench4 size=3000, time: 15214 ms\n" + "<-- end bench4 size=3000, time: 9946 ms\n" ] } ], @@ -361,7 +423,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -369,7 +431,7 @@ "output_type": "stream", "text": [ "--> begin bench5 size=3000\n", - "<-- end bench5 size=3000, time: 14938 ms\n" + "<-- end bench5 size=3000, time: 11013 ms\n" ] } ], @@ -402,7 +464,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -410,7 +472,7 @@ "output_type": "stream", "text": [ "--> begin bench6 size=3000\n", - "<-- end bench6 size=3000, time: 11661 ms\n" + "<-- end bench6 size=3000, time: 9232 ms\n" ] } ], @@ -437,7 +499,7 @@ "source": [ "# Summary\n", "\n", - "From version 1 to version 6 , model build time has decreased from 35s to 4s (on our platform). Result smay well differ on other platforms, but still, this demonstrates that the way the model is built can greatly influence the performance.\n", + "From version 1 to version 6 , model build time has decreased from 35s to 4s (on our platform). Results may well differ on other platforms, but still, this demonstrates that the way the model is built can greatly influence the performance.\n", "\n", "Here is a list of tricks to try to improve model building time:\n", "\n", @@ -464,7 +526,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -474,77 +536,77 @@ "* start computing performance data\n", "* start computing results...\n", "--> begin [1/36] use build_bench_model1 with size=100\n", - "<-- end [1/36] use build_bench_model1 with size=100, time: 66 ms\n", + "<-- end [1/36] use build_bench_model1 with size=100, time: 42 ms\n", "--> begin [2/36] use build_bench_model2 with size=100\n", - "<-- end [2/36] use build_bench_model2 with size=100, time: 43 ms\n", + "<-- end [2/36] use build_bench_model2 with size=100, time: 28 ms\n", "--> begin [3/36] use build_bench_model3 with size=100\n", - "<-- end [3/36] use build_bench_model3 with size=100, time: 45 ms\n", + "<-- end [3/36] use build_bench_model3 with size=100, time: 23 ms\n", "--> begin [4/36] use build_bench_model4 with size=100\n", - "<-- end [4/36] use build_bench_model4 with size=100, time: 32 ms\n", + "<-- end [4/36] use build_bench_model4 with size=100, time: 21 ms\n", "--> begin [5/36] use build_bench_model5 with size=100\n", - "<-- end [5/36] use build_bench_model5 with size=100, time: 33 ms\n", + "<-- end [5/36] use build_bench_model5 with size=100, time: 19 ms\n", "--> begin [6/36] use build_bench_model6 with size=100\n", - "<-- end [6/36] use build_bench_model6 with size=100, time: 29 ms\n", + "<-- end [6/36] use build_bench_model6 with size=100, time: 17 ms\n", "--> begin [7/36] use build_bench_model1 with size=300\n", - "<-- end [7/36] use build_bench_model1 with size=300, time: 358 ms\n", + "<-- end [7/36] use build_bench_model1 with size=300, time: 254 ms\n", "--> begin [8/36] use build_bench_model2 with size=300\n", - "<-- end [8/36] use build_bench_model2 with size=300, time: 211 ms\n", + "<-- end [8/36] use build_bench_model2 with size=300, time: 151 ms\n", "--> begin [9/36] use build_bench_model3 with size=300\n", - "<-- end [9/36] use build_bench_model3 with size=300, time: 255 ms\n", + "<-- end [9/36] use build_bench_model3 with size=300, time: 117 ms\n", "--> begin [10/36] use build_bench_model4 with size=300\n", - "<-- end [10/36] use build_bench_model4 with size=300, time: 216 ms\n", + "<-- end [10/36] use build_bench_model4 with size=300, time: 101 ms\n", "--> begin [11/36] use build_bench_model5 with size=300\n", - "<-- end [11/36] use build_bench_model5 with size=300, time: 174 ms\n", + "<-- end [11/36] use build_bench_model5 with size=300, time: 97 ms\n", "--> begin [12/36] use build_bench_model6 with size=300\n", - "<-- end [12/36] use build_bench_model6 with size=300, time: 141 ms\n", + "<-- end [12/36] use build_bench_model6 with size=300, time: 67 ms\n", "--> begin [13/36] use build_bench_model1 with size=600\n", - "<-- end [13/36] use build_bench_model1 with size=600, time: 1324 ms\n", + "<-- end [13/36] use build_bench_model1 with size=600, time: 1021 ms\n", "--> begin [14/36] use build_bench_model2 with size=600\n", - "<-- end [14/36] use build_bench_model2 with size=600, time: 818 ms\n", + "<-- end [14/36] use build_bench_model2 with size=600, time: 892 ms\n", "--> begin [15/36] use build_bench_model3 with size=600\n", - "<-- end [15/36] use build_bench_model3 with size=600, time: 619 ms\n", + "<-- end [15/36] use build_bench_model3 with size=600, time: 417 ms\n", "--> begin [16/36] use build_bench_model4 with size=600\n", - "<-- end [16/36] use build_bench_model4 with size=600, time: 564 ms\n", + "<-- end [16/36] use build_bench_model4 with size=600, time: 410 ms\n", "--> begin [17/36] use build_bench_model5 with size=600\n", - "<-- end [17/36] use build_bench_model5 with size=600, time: 540 ms\n", + "<-- end [17/36] use build_bench_model5 with size=600, time: 418 ms\n", "--> begin [18/36] use build_bench_model6 with size=600\n", - "<-- end [18/36] use build_bench_model6 with size=600, time: 369 ms\n", + "<-- end [18/36] use build_bench_model6 with size=600, time: 251 ms\n", "--> begin [19/36] use build_bench_model1 with size=1000\n", - "<-- end [19/36] use build_bench_model1 with size=1000, time: 3748 ms\n", + "<-- end [19/36] use build_bench_model1 with size=1000, time: 3026 ms\n", "--> begin [20/36] use build_bench_model2 with size=1000\n", - "<-- end [20/36] use build_bench_model2 with size=1000, time: 2663 ms\n", + "<-- end [20/36] use build_bench_model2 with size=1000, time: 1701 ms\n", "--> begin [21/36] use build_bench_model3 with size=1000\n", - "<-- end [21/36] use build_bench_model3 with size=1000, time: 1562 ms\n", + "<-- end [21/36] use build_bench_model3 with size=1000, time: 1092 ms\n", "--> begin [22/36] use build_bench_model4 with size=1000\n", - "<-- end [22/36] use build_bench_model4 with size=1000, time: 1802 ms\n", + "<-- end [22/36] use build_bench_model4 with size=1000, time: 1207 ms\n", "--> begin [23/36] use build_bench_model5 with size=1000\n", - "<-- end [23/36] use build_bench_model5 with size=1000, time: 1527 ms\n", + "<-- end [23/36] use build_bench_model5 with size=1000, time: 1125 ms\n", "--> begin [24/36] use build_bench_model6 with size=1000\n", - "<-- end [24/36] use build_bench_model6 with size=1000, time: 1092 ms\n", + "<-- end [24/36] use build_bench_model6 with size=1000, time: 704 ms\n", "--> begin [25/36] use build_bench_model1 with size=3000\n", - "<-- end [25/36] use build_bench_model1 with size=3000, time: 34271 ms\n", + "<-- end [25/36] use build_bench_model1 with size=3000, time: 23946 ms\n", "--> begin [26/36] use build_bench_model2 with size=3000\n", - "<-- end [26/36] use build_bench_model2 with size=3000, time: 21442 ms\n", + "<-- end [26/36] use build_bench_model2 with size=3000, time: 15195 ms\n", "--> begin [27/36] use build_bench_model3 with size=3000\n", - "<-- end [27/36] use build_bench_model3 with size=3000, time: 13377 ms\n", + "<-- end [27/36] use build_bench_model3 with size=3000, time: 9592 ms\n", "--> begin [28/36] use build_bench_model4 with size=3000\n", - "<-- end [28/36] use build_bench_model4 with size=3000, time: 13483 ms\n", + "<-- end [28/36] use build_bench_model4 with size=3000, time: 9393 ms\n", "--> begin [29/36] use build_bench_model5 with size=3000\n", - "<-- end [29/36] use build_bench_model5 with size=3000, time: 14593 ms\n", + "<-- end [29/36] use build_bench_model5 with size=3000, time: 10426 ms\n", "--> begin [30/36] use build_bench_model6 with size=3000\n", - "<-- end [30/36] use build_bench_model6 with size=3000, time: 12268 ms\n", + "<-- end [30/36] use build_bench_model6 with size=3000, time: 7888 ms\n", "--> begin [31/36] use build_bench_model1 with size=5000\n", - "<-- end [31/36] use build_bench_model1 with size=5000, time: 97333 ms\n", + "<-- end [31/36] use build_bench_model1 with size=5000, time: 69977 ms\n", "--> begin [32/36] use build_bench_model2 with size=5000\n", - "<-- end [32/36] use build_bench_model2 with size=5000, time: 61049 ms\n", + "<-- end [32/36] use build_bench_model2 with size=5000, time: 45892 ms\n", "--> begin [33/36] use build_bench_model3 with size=5000\n", - "<-- end [33/36] use build_bench_model3 with size=5000, time: 37885 ms\n", + "<-- end [33/36] use build_bench_model3 with size=5000, time: 28273 ms\n", "--> begin [34/36] use build_bench_model4 with size=5000\n", - "<-- end [34/36] use build_bench_model4 with size=5000, time: 38767 ms\n", + "<-- end [34/36] use build_bench_model4 with size=5000, time: 27294 ms\n", "--> begin [35/36] use build_bench_model5 with size=5000\n", - "<-- end [35/36] use build_bench_model5 with size=5000, time: 40835 ms\n", + "<-- end [35/36] use build_bench_model5 with size=5000, time: 29352 ms\n", "--> begin [36/36] use build_bench_model6 with size=5000\n", - "<-- end [36/36] use build_bench_model6 with size=5000, time: 26912 ms\n", + "<-- end [36/36] use build_bench_model6 with size=5000, time: 18474 ms\n", "* end computing results\n" ] } @@ -581,12 +643,12 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -627,14 +689,14 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "* geometric mean of time improvement is 3.0\n" + "* geometric mean of time improvement is 3.5\n" ] } ], @@ -672,9 +734,9 @@ ], "metadata": { "kernelspec": { - "display_name": "531_36", + "display_name": "Python 3", "language": "python", - "name": "531_36" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -686,7 +748,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.8" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/examples/mp/jupyter/green_truck.ipynb b/examples/mp/jupyter/green_truck.ipynb index 7ddc126..ceebc62 100644 --- a/examples/mp/jupyter/green_truck.ipynb +++ b/examples/mp/jupyter/green_truck.ipynb @@ -15,7 +15,7 @@ "\n", ">This notebook is part of **[Prescriptive Analytics for Python](http://ibmdecisionoptimization.github.io/docplex-doc/)**\n", ">\n", - ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/>) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", + ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", "and you can start using Watson Studio Cloud right away).\n", "\n", "\n", @@ -790,7 +790,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.1" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/examples/mp/jupyter/incremental_modeling.ipynb b/examples/mp/jupyter/incremental_modeling.ipynb index 6732c52..6193001 100644 --- a/examples/mp/jupyter/incremental_modeling.ipynb +++ b/examples/mp/jupyter/incremental_modeling.ipynb @@ -21,7 +21,7 @@ "\n", ">This notebook is part of **[Prescriptive Analytics for Python](http://ibmdecisionoptimization.github.io/docplex-doc/)**\n", ">\n", - ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/>) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", + ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", "and you can start using Watson Studio Cloud right away).\n", "\n", "\n", @@ -640,7 +640,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.1" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/examples/mp/jupyter/lagrangian_relaxation.ipynb b/examples/mp/jupyter/lagrangian_relaxation.ipynb index f24d60f..a5188e3 100644 --- a/examples/mp/jupyter/lagrangian_relaxation.ipynb +++ b/examples/mp/jupyter/lagrangian_relaxation.ipynb @@ -13,7 +13,7 @@ "\n", ">This notebook is part of **[Prescriptive Analytics for Python](http://ibmdecisionoptimization.github.io/docplex-doc/)**\n", ">\n", - ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/>) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", + ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", "and you can start using Watson Studio Cloud right away).\n", "\n", "Some familiarity with Python is recommended." @@ -523,7 +523,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.1" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/examples/mp/jupyter/lifegame.ipynb b/examples/mp/jupyter/lifegame.ipynb index a5904fd..f1f937f 100644 --- a/examples/mp/jupyter/lifegame.ipynb +++ b/examples/mp/jupyter/lifegame.ipynb @@ -15,7 +15,7 @@ "\n", ">This notebook is part of **[Prescriptive Analytics for Python](http://ibmdecisionoptimization.github.io/docplex-doc/)**\n", ">\n", - ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/>) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", + ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", "and you can start using Watson Studio Cloud right away).\n", "\n", "This model is greater than the size allowed in trial mode of CPLEX.\n", @@ -483,7 +483,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.1" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/examples/mp/jupyter/load_balancing.ipynb b/examples/mp/jupyter/load_balancing.ipynb index de80067..57636ab 100644 --- a/examples/mp/jupyter/load_balancing.ipynb +++ b/examples/mp/jupyter/load_balancing.ipynb @@ -15,7 +15,7 @@ "\n", ">This notebook is part of **[Prescriptive Analytics for Python](http://ibmdecisionoptimization.github.io/docplex-doc/)**\n", ">\n", - ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/>) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", + ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", "and you can start using Watson Studio Cloud right away).\n", "\n", "\n", @@ -114,9 +114,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "from collections import namedtuple" @@ -136,9 +134,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "try:\n", @@ -234,9 +230,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "from docplex.mp.model import Model\n", @@ -271,9 +265,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "def _is_migration(user, server):\n", @@ -307,9 +299,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "# each assignment var is <= active_server(s)\n", @@ -488,7 +478,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.1" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/examples/mp/jupyter/logical_cts.ipynb b/examples/mp/jupyter/logical_cts.ipynb index 127baed..8065460 100644 --- a/examples/mp/jupyter/logical_cts.ipynb +++ b/examples/mp/jupyter/logical_cts.ipynb @@ -15,7 +15,7 @@ "\n", ">This notebook is part of **[Prescriptive Analytics for Python](http://ibmdecisionoptimization.github.io/docplex-doc/)**\n", ">\n", - ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/>) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", + ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", "and you can start using Watson Studio Cloud right away).\n", "\n", "\n", @@ -82,7 +82,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -143,17 +143,9 @@ }, { "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "the truth value of [ix+iy <= 3] is 1.0\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "from docplex.mp.model import Model\n", "\n", @@ -181,20 +173,9 @@ }, { "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "objective: 8\n", - " \"ix\"=4\n", - " \"iy\"=4\n", - "the truth value of [ix+iy <= 3] is 0\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "m2 = Model(name='logical2')\n", "x = m2.integer_var(name='ix', ub=4)\n", @@ -233,19 +214,9 @@ }, { "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "iy: 4\n", - " \"ix\"=2\n", - " \"iy\"=4\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "m3 = Model(name='logical3')\n", "x = m3.integer_var(name='ix', ub=4)\n", @@ -273,20 +244,9 @@ }, { "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "objective: 12\n", - " \"ix\"=2\n", - " \"iy\"=5\n", - " \"iz\"=5\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "m31 = Model(name='logical31')\n", "x = m31.integer_var(name='ix', ub=4)\n", @@ -318,27 +278,9 @@ }, { "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "objective: 903\n", - " \"x1\"=3\n", - " \"x2\"=100\n", - " \"x3\"=100\n", - " \"x4\"=100\n", - " \"x5\"=100\n", - " \"x6\"=100\n", - " \"x7\"=100\n", - " \"x8\"=100\n", - " \"x9\"=100\n", - " \"x10\"=100\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "m4 = Model(name='logical4')\n", "xs = m4.integer_var_list(10, ub=100)\n", @@ -361,27 +303,9 @@ }, { "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "objective: 902\n", - " \"x1\"=3\n", - " \"x2\"=100\n", - " \"x3\"=100\n", - " \"x4\"=100\n", - " \"x5\"=100\n", - " \"x6\"=100\n", - " \"x7\"=100\n", - " \"x8\"=100\n", - " \"x9\"=100\n", - " \"x10\"=100\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "preference = m4.dot(cts, (k+1 for k in range(len(xs))))\n", "# we prefer lower indices for satisfying the x==3 constraint\n", @@ -412,22 +336,9 @@ }, { "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "objective: 6\n", - " \"ix\"=2\n", - " \"iy\"=4\n", - "objective: 8\n", - " \"ix\"=4\n", - " \"iy\"=4\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "m5 = Model(name='logical5')\n", "x = m5.integer_var(name='ix', ub=4)\n", @@ -476,19 +387,9 @@ }, { "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "objective: 5\n", - " \"ix\"=2\n", - " \"iy\"=3\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "m6 = Model(name='logical6')\n", "x = m6.integer_var(name='ix', ub=4)\n", @@ -533,38 +434,9 @@ }, { "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "objective: 7\n", - " i_0=5\n", - " i_1=5\n", - " i_2=5\n", - " i_3=5\n", - " i_4=5\n", - " i_5=5\n", - " i_6=5\n", - " j_0=7\n", - " j_1=7\n", - " j_2=7\n", - " j_3=7\n", - " j_4=7\n", - " j_5=7\n", - " j_6=7\n", - " b_0=1\n", - " b_1=1\n", - " b_2=1\n", - " b_3=1\n", - " b_4=1\n", - " b_5=1\n", - " b_6=1\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "m7 = Model(name='logical7')\n", "size = 7\n", @@ -616,22 +488,9 @@ }, { "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "objective: 200.000\n", - " x=100.000\n", - " b=1\n", - "objective: 103.140\n", - " x=3.140\n", - " b=1\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "m8 = Model(name='logical8')\n", "x = m8.continuous_var(name='x', ub=100)\n", @@ -672,20 +531,9 @@ }, { "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "objective: 2403.140\n", - " \"x\"=3.140\n", - " \"iy\"=11\n", - " \"iz\"=13\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "m9 = Model(name='logical9')\n", "x = m9.continuous_var(name='x', ub=100)\n", @@ -709,19 +557,9 @@ }, { "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "objective: 118.000\n", - " \"x\"=100.000\n", - " \"iy\"=9\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# y and z are pushed to their ub, so x is down to 3.14\n", "m9.maximize(x + 2 *(y + z))\n", @@ -780,9 +618,9 @@ "anaconda-cloud": {}, "gist_id": "6011986", "kernelspec": { - "display_name": "531_36", + "display_name": "Python 3", "language": "python", - "name": "531_36" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -794,7 +632,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.8" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/examples/mp/jupyter/marketing_campaign.ipynb b/examples/mp/jupyter/marketing_campaign.ipynb index 702c816..ff8beb4 100644 --- a/examples/mp/jupyter/marketing_campaign.ipynb +++ b/examples/mp/jupyter/marketing_campaign.ipynb @@ -12,7 +12,7 @@ "\n", ">This notebook is part of [Prescriptive Analytics for Python](http://ibmdecisionoptimization.github.io/docplex-doc/)\n", ">\n", - ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/>) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", + ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", "and you can start using Watson Studio Cloud right away).\n", "\n", "\n", @@ -78,9 +78,9 @@ "The predictions show which offers a customer is most likely to accept, and the confidence that they will accept, depending on each customer’s details.\n", "\n", "For example:\n", - "(139987, \"Pension\", 0.13221, \"Mortgage\", 0.10675) indicates that customer Id=139987 will certainly not buy a _Pension_ as the level is only 13.2%, \n", + "(139987, \"Pension\", 0.13221, \"Mortgage\", 0.10675) indicates that customer Id=139987 will certainly not buy a _Pension_ as the level is only 13.2%, \n", "whereas\n", - "(140030, \"Savings\", 0.95678, \"Pension\", 0.84446) is more than likely to buy _Savings_ and a _Pension_ as the rates are 95.7% and 84.4%.\n", + "(140030, \"Savings\", 0.95678, \"Pension\", 0.84446) is more than likely to buy _Savings_ and a _Pension_ as the rates are 95.7% and 84.4%.\n", "\n", "This data is taken from a SPSS example, except that the names of the customers were modified.\n", "\n", @@ -337,7 +337,7 @@ " for p in productsR \n", " for c in channelsR) )\n", "\n", - "mdl.add_constraint( budgetSpent == mdl.sum(channelVars[o,p,c]*channels.get_value(index=c, col=\"cost\") \n", + "mdl.add_constraint( budgetSpent == mdl.sum(channelVars[o,p,c]*channels.at[c, \"cost\"] \n", " for o in offersR \n", " for p in productsR \n", " for c in channelsR) )\n", @@ -348,7 +348,7 @@ " <= budgetShare[p] * totaloffers )\n", " \n", "# Do not exceed the budget\n", - "mdl.add_constraint( mdl.sum(channelVars[o,p,c]*channels.get_value(index=c, col=\"cost\") \n", + "mdl.add_constraint( mdl.sum(channelVars[o,p,c]*channels.at[c, \"cost\"] \n", " for o in offersR \n", " for p in productsR \n", " for c in channelsR) <= availableBudget ) \n", @@ -418,7 +418,7 @@ "metadata": {}, "outputs": [], "source": [ - "report = [(channels.get_value(index=c, col=\"name\"), products[p], names[offers.get_value(o, \"customerid\")]) \n", + "report = [(channels.at[c, \"name\"], products[p], names[offers.at[o, \"customerid\"]]) \n", " for c in channelsR \n", " for p in productsR \n", " for o in offersR if channelVars[o,p,c].solution_value==1]\n", @@ -505,7 +505,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.1" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/examples/mp/jupyter/mining_pandas.ipynb b/examples/mp/jupyter/mining_pandas.ipynb index dcb44c9..cfa22a5 100644 --- a/examples/mp/jupyter/mining_pandas.ipynb +++ b/examples/mp/jupyter/mining_pandas.ipynb @@ -12,7 +12,7 @@ "\n", ">This notebook is part of [Prescriptive Analytics for Python](http://ibmdecisionoptimization.github.io/docplex-doc/)\n", ">\n", - ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/>) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", + ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", "and you can start using Watson Studio Cloud right away).\n", "\n", "\n", @@ -906,7 +906,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.1" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/examples/mp/jupyter/nurses_pandas-multi_objective.ipynb b/examples/mp/jupyter/nurses_pandas-multi_objective.ipynb index dd014b9..0b591c0 100644 --- a/examples/mp/jupyter/nurses_pandas-multi_objective.ipynb +++ b/examples/mp/jupyter/nurses_pandas-multi_objective.ipynb @@ -12,7 +12,7 @@ "\n", ">This notebook is part of **[Prescriptive Analytics for Python](http://ibmdecisionoptimization.github.io/docplex-doc/)**\n", ">\n", - ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/>) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", + ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", "and you can start using Watson Studio Cloud right away).\n", "\n", "\n", @@ -84,9 +84,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "import pip\n", @@ -117,9 +115,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "import sys\n", @@ -161,9 +157,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "CSS = \"\"\"\n", @@ -209,9 +203,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "from IPython.core.display import HTML\n", @@ -223,9 +215,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "try:\n", @@ -237,9 +227,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "try:\n", @@ -305,9 +293,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "# maximum work time (in hours)\n", @@ -424,9 +410,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "df_shifts[\"duration\"] = df_shifts.wend - df_shifts.wstart" @@ -509,9 +493,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "# first global collections to iterate upon\n", @@ -697,9 +679,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "for preferred_assign in df_preferred_assign.itertuples():\n", @@ -744,9 +724,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "for incompatible_assign in df_incompatible_assign.itertuples():\n", @@ -852,9 +830,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "# Use pandas' groupby operation to enforce minimum requirement constraint for each shift\n", @@ -1122,9 +1098,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "# Use the pandas groupby operation to enforce the constraint calculating number of worked shifts for each nurse\n", @@ -1169,9 +1143,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "mdl.minimize(total_salary_cost + total_overw + total_underw) # incorporate over_worked and under_worked in objective" @@ -1328,7 +1300,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.1" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/examples/mp/jupyter/nurses_pandas.ipynb b/examples/mp/jupyter/nurses_pandas.ipynb index 2e8d964..00803c4 100644 --- a/examples/mp/jupyter/nurses_pandas.ipynb +++ b/examples/mp/jupyter/nurses_pandas.ipynb @@ -12,7 +12,7 @@ "\n", ">This notebook is part of [Prescriptive Analytics for Python](http://ibmdecisionoptimization.github.io/docplex-doc/)\n", ">\n", - ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/>) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", + ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", "and you can start using Watson Studio Cloud right away).\n", "\n", "\n", @@ -224,18 +224,6 @@ " from io import StringIO" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "try:\n", - " from urllib2 import urlopen\n", - "except ImportError:\n", - " from urllib.request import urlopen" - ] - }, { "cell_type": "code", "execution_count": null, @@ -259,17 +247,17 @@ "\n", "# Use pandas to read the file, one tab for each table.\n", "data_url = \"https://github.com/IBMDecisionOptimization/docplex-examples/blob/master/examples/mp/jupyter/nurses_data.xls?raw=true\"\n", - "nurse_xls_file = pd.ExcelFile(urlopen(data_url))\n", + "nurse_xls_file = pd.ExcelFile(data_url)\n", "\n", "df_skills = nurse_xls_file.parse('Skills')\n", - "df_depts = nurse_xls_file.parse('Departments')\n", + "df_depts = nurse_xls_file.parse('Departments')\n", "df_shifts = nurse_xls_file.parse('Shifts')\n", "# Rename df_shifts index\n", "df_shifts.index.name = 'shiftId'\n", "\n", "# Index is column 0: name\n", "df_nurses = nurse_xls_file.parse('Nurses', header=0, index_col=0)\n", - "df_nurse_skilles = nurse_xls_file.parse('NurseSkills')\n", + "df_nurse_skills = nurse_xls_file.parse('NurseSkills')\n", "df_vacations = nurse_xls_file.parse('NurseVacations')\n", "df_associations = nurse_xls_file.parse('NurseAssociations')\n", "df_incompatibilities = nurse_xls_file.parse('NurseIncompatibilities')\n", @@ -1334,7 +1322,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.1" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/examples/mp/jupyter/nurses_scheduling.ipynb b/examples/mp/jupyter/nurses_scheduling.ipynb index 3896030..82bf3d0 100644 --- a/examples/mp/jupyter/nurses_scheduling.ipynb +++ b/examples/mp/jupyter/nurses_scheduling.ipynb @@ -12,7 +12,7 @@ "\n", ">This notebook is part of [Prescriptive Analytics for Python](http://ibmdecisionoptimization.github.io/docplex-doc/)\n", ">\n", - ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/>) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", + ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", "and you can start using Watson Studio Cloud right away).\n", "\n", "\n", @@ -90,7 +90,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -133,7 +133,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -233,7 +233,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -279,7 +279,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -291,7 +291,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -303,305 +303,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
nameseniorityqualificationpay_rate
0Anne11125
1Bethanie4528
2Betsy2217
3Cathy2217
4Cecilia9538
5Chris11438
6Cindy5221
7David1215
8Debbie7224
9Dee3321
10Gloria8225
11Isabelle3116
12Jane3423
13Janelle4322
14Janice2217
15Jemma2422
16Joan5324
17Joyce8329
18Jude4322
19Julie6222
20Juliet7431
21Kate5324
22Nancy8432
23Nathalie9538
24Nicole0214
25Patricia1113
26Patrick6119
27Roberta3526
28Suzanne5118
29Vickie7120
30Wendie5221
31Zoe8329
\n", - "
" - ], - "text/plain": [ - " name seniority qualification pay_rate\n", - "0 Anne 11 1 25\n", - "1 Bethanie 4 5 28\n", - "2 Betsy 2 2 17\n", - "3 Cathy 2 2 17\n", - "4 Cecilia 9 5 38\n", - "5 Chris 11 4 38\n", - "6 Cindy 5 2 21\n", - "7 David 1 2 15\n", - "8 Debbie 7 2 24\n", - "9 Dee 3 3 21\n", - "10 Gloria 8 2 25\n", - "11 Isabelle 3 1 16\n", - "12 Jane 3 4 23\n", - "13 Janelle 4 3 22\n", - "14 Janice 2 2 17\n", - "15 Jemma 2 4 22\n", - "16 Joan 5 3 24\n", - "17 Joyce 8 3 29\n", - "18 Jude 4 3 22\n", - "19 Julie 6 2 22\n", - "20 Juliet 7 4 31\n", - "21 Kate 5 3 24\n", - "22 Nancy 8 4 32\n", - "23 Nathalie 9 5 38\n", - "24 Nicole 0 2 14\n", - "25 Patricia 1 1 13\n", - "26 Patrick 6 1 19\n", - "27 Roberta 3 5 26\n", - "28 Suzanne 5 1 18\n", - "29 Vickie 7 1 20\n", - "30 Wendie 5 2 21\n", - "31 Zoe 8 3 29" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# This notebook requires pandas to work\n", "import pandas as pd\n", @@ -616,14 +320,9 @@ " !pip install xlrd \n", " else:\n", " !pip install --user xlrd \n", - " \n", - "try:\n", - " from urllib2 import urlopen\n", - "except ImportError:\n", - " from urllib.request import urlopen\n", "\n", "data_url = \"https://github.com/IBMDecisionOptimization/docplex-examples/blob/master/examples/mp/jupyter/nurses_data.xls?raw=true\"\n", - "nurse_xls_file = pd.ExcelFile(urlopen(data_url))\n", + "nurse_xls_file = pd.ExcelFile(data_url)\n", "\n", "SkillTable = nurse_xls_file.parse('Skills')\n", "DeptTable = nurse_xls_file.parse('Departments')\n", @@ -649,7 +348,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -692,21 +391,9 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "* system is: Windows 64bit\n", - "* Python version 3.6.8, located at: C:\\python\\anaconda531\\envs\\531_36\\python.exe\n", - "* docplex is present, version is (2, 10, 0)\n", - "* CPLEX library is present, version is 12.9.0.0, located at: C:\\OPTIM\\python\\cplex1290R1\\3.6\\x64_win64\n", - "* pandas is present, version is 0.23.4\n" - ] - } - ], + "outputs": [], "source": [ "from docplex.mp.environment import Environment\n", "env = Environment()\n", @@ -723,7 +410,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -746,7 +433,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -775,20 +462,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "docplex.mp.LinearConstraint[average](18AverageWorkTime,EQ,NurseWorkTime_Betsy+NurseWorkTime_Cathy+NurseWorkTime_Cindy+NurseWorkTime_Debbie+NurseWorkTime_Dee+NurseWorkTime_Isabelle+NurseWorkTime_Jane+NurseWorkTime_Janelle+NurseWorkTime_Janice+NurseWorkTime_Jemma+NurseWorkTime_Joan+NurseWorkTime_Jude+NurseWorkTime_Julie+NurseWorkTime_Kate+NurseWorkTime_Patrick+NurseWorkTime_Suzanne+NurseWorkTime_Vickie+NurseWorkTime_Wendie)" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "mdl.add_constraint(len(nurses) * average_nurse_work_time ==\n", " mdl.sum(nurse_work_time_vars[n] for n in nurses), \"average\")" @@ -803,7 +479,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -838,7 +514,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -860,17 +536,9 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "# overlapping shifts: 20\n" - ] - } - ], + "outputs": [], "source": [ "# Post only one constraint per couple(s1, s2)\n", "number_of_overlaps = 0\n", @@ -899,7 +567,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -923,7 +591,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -947,7 +615,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -974,7 +642,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1007,23 +675,9 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Model: nurses\n", - " - number of variables: 793\n", - " - binary=738, integer=0, continuous=55\n", - " - number of constraints: 961\n", - " - linear=961\n", - " - parameters: defaults\n", - " - problem type is: MILP\n" - ] - } - ], + "outputs": [], "source": [ "total_number_of_assignments = mdl.sum(nurse_assignment_vars[n,s] for n in nurses for s in shifts)\n", "nurse_costs = [nurse_assignment_vars[n, s] * n.pay_rate * shift_activities[s].duration for n in nurses for s in shifts]\n", @@ -1056,7 +710,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1073,74 +727,9 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPXPARAM_Read_DataCheck 1\n", - "CPXPARAM_MIP_Tolerances_MIPGap 1.0000000000000001e-05\n", - "Bound infeasibility column 'NurseWorkTime_Betsy'.\n", - "Presolve time = 0.00 sec. (0.29 ticks)\n", - "\n", - "Root node processing (before b&c):\n", - " Real time = 0.00 sec. (0.45 ticks)\n", - "Parallel b&c, 8 threads:\n", - " Real time = 0.00 sec. (0.00 ticks)\n", - " Sync time (average) = 0.00 sec.\n", - " Wait time (average) = 0.00 sec.\n", - " ------------\n", - "Total (root+branch&cut) = 0.00 sec. (0.45 ticks)\n", - "Warning: 55 constraint(s) will not be relaxed (e.g.: average: 18AverageWorkTime == NurseWorkTime_Betsy+NurseWorkTime_Cathy+NurseWorkTime_Cindy+NurseWorkTime_Debbie+NurseWorkTime_Dee+NurseWorkTime_Isabelle+NurseWorkTime_Jane+NurseWorkTime_Janelle+NurseWorkTime_Janice+NurseWorkTime_Jemma+NurseWorkTime_Joan+NurseWorkTime_Jude+NurseWorkTime_Julie+NurseWorkTime_Kate+NurseWorkTime_Patrick+NurseWorkTime_Suzanne+NurseWorkTime_Vickie+NurseWorkTime_Wendie)\n", - "* number of relaxations: 35\n", - " - relaxed: high_req_min_EMER_Mon_08_4, with relaxation: -2.0\n", - " - relaxed: high_req_min_EMER_Mon_18_3, with relaxation: -3.0\n", - " - relaxed: high_req_min_CONS_Mon_08_10, with relaxation: -5.0\n", - " - relaxed: high_req_min_CONS_Mon_12_8, with relaxation: -4.0\n", - " - relaxed: high_req_min_CARD_Mon_08_10, with relaxation: -4.0\n", - " - relaxed: high_req_min_CARD_Mon_12_8, with relaxation: -5.0\n", - " - relaxed: high_req_min_EMER_Tue_08_4, with relaxation: -2.0\n", - " - relaxed: high_req_min_EMER_Tue_18_3, with relaxation: -3.0\n", - " - relaxed: high_req_min_CONS_Tue_08_10, with relaxation: -5.0\n", - " - relaxed: high_req_min_CONS_Tue_12_8, with relaxation: -5.0\n", - " - relaxed: high_req_min_CARD_Tue_18_3, with relaxation: -3.0\n", - " - relaxed: high_req_min_EMER_Wed_12_2, with relaxation: -1.0\n", - " - relaxed: high_req_min_EMER_Wed_18_3, with relaxation: -3.0\n", - " - relaxed: high_req_min_EMER_Thu_18_3, with relaxation: -3.0\n", - " - relaxed: high_req_min_CONS_Thu_08_10, with relaxation: -2.0\n", - " - relaxed: high_req_min_EMER_Fri_02_3, with relaxation: -1.0\n", - " - relaxed: high_req_min_EMER_Fri_18_3, with relaxation: -3.0\n", - " - relaxed: high_req_min_CONS_Fri_08_10, with relaxation: -3.0\n", - " - relaxed: high_req_min_CONS_Fri_12_8, with relaxation: -3.0\n", - " - relaxed: high_req_min_EMER_Sat_02_5, with relaxation: -5.0\n", - " - relaxed: high_req_min_EMER_Sat_12_7, with relaxation: -5.0\n", - " - relaxed: high_req_min_EMER_Sat_20_12, with relaxation: -4.0\n", - " - relaxed: high_req_min_EMER_Sun_02_5, with relaxation: -5.0\n", - " - relaxed: high_req_min_EMER_Sun_12_7, with relaxation: -7.0\n", - " - relaxed: high_required_Emergency_Cardiac Care_1_EMER_Mon_18, with relaxation: -1.0\n", - " - relaxed: high_required_Emergency_Cardiac Care_1_EMER_Tue_18, with relaxation: -1.0\n", - " - relaxed: high_required_Emergency_Cardiac Care_1_EMER_Wed_18, with relaxation: -1.0\n", - " - relaxed: high_required_Emergency_Cardiac Care_1_EMER_Thu_02, with relaxation: -1.0\n", - " - relaxed: high_required_Emergency_Cardiac Care_1_EMER_Thu_18, with relaxation: -1.0\n", - " - relaxed: high_required_Emergency_Cardiac Care_1_EMER_Fri_18, with relaxation: -1.0\n", - " - relaxed: high_required_Emergency_Cardiac Care_1_EMER_Sat_02, with relaxation: -1.0\n", - " - relaxed: high_required_Emergency_Cardiac Care_1_EMER_Sat_12, with relaxation: -1.0\n", - " - relaxed: high_required_Emergency_Cardiac Care_1_EMER_Sat_20, with relaxation: -1.0\n", - " - relaxed: high_required_Emergency_Cardiac Care_1_EMER_Sun_02, with relaxation: -1.0\n", - " - relaxed: high_required_Emergency_Cardiac Care_1_EMER_Sun_12, with relaxation: -1.0\n", - "* total absolute relaxation: 97.0\n", - "* model nurses solved with objective = 14097.333\n", - "* KPI: Total salary cost = 13940.000\n", - "* KPI: Total number of assignments = 134.000\n", - "* KPI: AverageWorkTime = 37.667\n", - "* KPI: Total over-average worktime = 11.667\n", - "* KPI: Total under-average worktime = 11.667\n", - "* KPI: Total fairness = 23.333\n" - ] - } - ], + "outputs": [], "source": [ "# Set Cplex mipgap to 1e-5 to enforce precision to be of the order of a unit (objective value magnitude is ~1e+5).\n", "mdl.parameters.mip.tolerances.mipgap = 1e-5\n", @@ -1181,20 +770,9 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "-24" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "min(shift_activities, key=lambda i: shift_activities[i].day_start_time)\n", "min(s.day_start_time for s in shift_activities.values())" @@ -1202,22 +780,9 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "import matplotlib.gridspec as gridspec\n", @@ -1346,9 +911,9 @@ ], "metadata": { "kernelspec": { - "display_name": "531_36", + "display_name": "Python 3", "language": "python", - "name": "531_36" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -1360,7 +925,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.8" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/examples/mp/jupyter/oil_blending.ipynb b/examples/mp/jupyter/oil_blending.ipynb index 2abe1e2..f4a895d 100644 --- a/examples/mp/jupyter/oil_blending.ipynb +++ b/examples/mp/jupyter/oil_blending.ipynb @@ -13,7 +13,7 @@ "\n", ">This notebook is part of [Prescriptive Analytics for Python](http://ibmdecisionoptimization.github.io/docplex-doc/)\n", ">\n", - ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/>) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", + ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", "and you can start using Watson Studio Cloud right away).\n", "\n", "\n", @@ -708,7 +708,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.1" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/examples/mp/jupyter/pasta_production.ipynb b/examples/mp/jupyter/pasta_production.ipynb index 5454911..c168b49 100644 --- a/examples/mp/jupyter/pasta_production.ipynb +++ b/examples/mp/jupyter/pasta_production.ipynb @@ -12,7 +12,7 @@ "\n", ">This notebook is part of **[Prescriptive Analytics for Python](http://ibmdecisionoptimization.github.io/docplex-doc/)**\n", ">\n", - ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/>) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", + ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", "and you can start using Watson Studio Cloud right away).\n", "\n", "\n", @@ -94,9 +94,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "import sys\n", @@ -119,9 +117,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "products = [(\"kluski\", 100, 0.6, 0.8),\n", @@ -197,9 +193,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "inside_vars = mdl.continuous_var_dict(products, name='inside')\n", @@ -352,7 +346,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.1" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/examples/mp/jupyter/progress.ipynb b/examples/mp/jupyter/progress.ipynb index a021e11..071ca85 100644 --- a/examples/mp/jupyter/progress.ipynb +++ b/examples/mp/jupyter/progress.ipynb @@ -15,7 +15,7 @@ "\n", ">This notebook is part of **[Prescriptive Analytics for Python](http://ibmdecisionoptimization.github.io/docplex-doc/)**\n", ">\n", - ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/>) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", + ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", "and you can start using Watson Studio Cloud right away).\n", "\n", "\n", @@ -86,7 +86,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -132,23 +132,9 @@ }, { "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Model: love_hearts_5\n", - " - number of variables: 15\n", - " - binary=15, integer=0, continuous=0\n", - " - number of constraints: 35\n", - " - linear=35\n", - " - parameters: defaults\n", - " - problem type is: MILP\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "m5 = build_hearts(5)\n", "m5.print_information()" @@ -173,7 +159,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -191,7 +177,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -215,21 +201,9 @@ }, { "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " 1+: Node=0 Left=1 Best Integer=7.0000, Best Bound=10.0000, gap=42.86%, ItCnt=21 [0.0s]\n", - " 2+: Node=0 Left=1 Best Integer=7.0000, Best Bound=9.3266, gap=33.24%, ItCnt=33 [0.0s]\n", - " 3+: Node=0 Left=1 Best Integer=7.0000, Best Bound=9.1960, gap=31.37%, ItCnt=41 [0.0s]\n", - " 4+: Node=0 Left=1 Best Integer=8.0000, Best Bound=9.1960, gap=14.95%, ItCnt=41 [0.0s]\n", - " 5+: Node=0 Left=1 Best Integer=8.0000, Best Bound=9.0000, gap=12.50%, ItCnt=50 [0.0s]\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "m5.solve(clean_before_solve=True);" ] @@ -260,17 +234,9 @@ }, { "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "listener #1 has type 'TextProgressListener', clock=ProgressClock.Gap\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "for l, listener in enumerate(m5.iter_progress_listeners(), start=1):\n", " print(\"listener #{0} has type '{1}', clock={2}\".format(l, listener.__class__.__name__, listener.clock))" @@ -287,30 +253,9 @@ }, { "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " 1+: Node=0 Left=1 Best Integer=7.0000, Best Bound=10.0000, gap=42.86%, ItCnt=21 [0.0s]\n", - " 2+: Node=0 Left=1 Best Integer=7.0000, Best Bound=10.0000, gap=42.86%, ItCnt=21 [0.0s]\n", - " 3+: Node=0 Left=1 Best Integer=7.0000, Best Bound=10.0000, gap=42.86%, ItCnt=33 [0.0s]\n", - " 4+: Node=0 Left=1 Best Integer=7.0000, Best Bound=9.3266, gap=33.24%, ItCnt=33 [0.0s]\n", - " 5+: Node=0 Left=1 Best Integer=7.0000, Best Bound=9.3266, gap=33.24%, ItCnt=41 [0.0s]\n", - " 6+: Node=0 Left=1 Best Integer=7.0000, Best Bound=9.1960, gap=31.37%, ItCnt=41 [0.0s]\n", - " 7+: Node=0 Left=1 Best Integer=8.0000, Best Bound=9.1960, gap=14.95%, ItCnt=41 [0.0s]\n", - " 8+: Node=0 Left=1 Best Integer=8.0000, Best Bound=9.1960, gap=14.95%, ItCnt=46 [0.0s]\n", - " 9+: Node=0 Left=1 Best Integer=8.0000, Best Bound=9.1110, gap=13.89%, ItCnt=46 [0.0s]\n", - " 10+: Node=0 Left=1 Best Integer=8.0000, Best Bound=9.1110, gap=13.89%, ItCnt=50 [0.0s]\n", - " 11+: Node=0 Left=1 Best Integer=8.0000, Best Bound=9.0000, gap=12.50%, ItCnt=50 [0.0s]\n", - " 12+: Node=0 Left=1 Best Integer=8.0000, Best Bound=9.0000, gap=12.50%, ItCnt=51 [0.0s]\n", - " 13+: Node=0 Left=1 Best Integer=8.0000, Best Bound=9.0000, gap=12.50%, ItCnt=51 [0.0s]\n", - " 14+: Node=0 Left=1 Best Integer=8.0000, Best Bound=9.0000, gap=12.50%, ItCnt=53 [0.0s]\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "m5.clear_progress_listeners()\n", "m5.add_progress_listener(TextProgressListener(clock='all'))\n", @@ -335,18 +280,9 @@ }, { "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " 1+: Node=0 Left=1 Best Integer=7.0000, Best Bound=10.0000, gap=42.86%, ItCnt=21 [0.0s]\n", - " 2+: Node=0 Left=1 Best Integer=8.0000, Best Bound=9.1960, gap=14.95%, ItCnt=41 [0.0s]\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "m5.clear_progress_listeners()\n", "m5.add_progress_listener(TextProgressListener(clock='objective', absdiff=1, reldiff=0))\n", @@ -378,7 +314,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -398,7 +334,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -415,22 +351,9 @@ }, { "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "* The recorder contains 5 solutions\n", - " - solution #1, obj=7.0, non-zero-values=7, total=7.0\n", - " - solution #2, obj=7.0, non-zero-values=7, total=7.0\n", - " - solution #3, obj=7.0, non-zero-values=7, total=7.0\n", - " - solution #4, obj=8.0, non-zero-values=8, total=8.0\n", - " - solution #5, obj=8.0, non-zero-values=8, total=8.0\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# utility function to display recorded solutions in a recorder.\n", "def display_recorded_solutions(rec):\n", @@ -452,19 +375,9 @@ }, { "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "* The recorder contains 2 solutions\n", - " - solution #1, obj=7.0, non-zero-values=7, total=7.0\n", - " - solution #2, obj=8.0, non-zero-values=8, total=8.0\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "sol_recorder2 = SolutionRecorder(clock='objective')\n", "m5.clear_progress_listeners()\n", @@ -506,7 +419,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -559,107 +472,9 @@ }, { "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "----> #new objective=24.0, time=0.031000000002677552s\n", - "----> non improving time=0.0s\n", - "----> non improving time=0.01600000000325963s\n", - "----> non improving time=0.01600000000325963s\n", - "----> non improving time=0.04700000000593718s\n", - "----> non improving time=0.04700000000593718s\n", - "----> non improving time=0.07800000000861473s\n", - "----> non improving time=0.07800000000861473s\n", - "----> non improving time=0.09399999999732245s\n", - "----> non improving time=0.09399999999732245s\n", - "----> non improving time=0.125s\n", - "----> non improving time=0.125s\n", - "----> non improving time=0.15600000000267755s\n", - "----> non improving time=0.15600000000267755s\n", - "----> non improving time=0.1870000000053551s\n", - "----> non improving time=0.1870000000053551s\n", - "----> non improving time=0.21899999999732245s\n", - "----> non improving time=0.21899999999732245s\n", - "----> non improving time=0.2340000000112923s\n", - "----> non improving time=0.25s\n", - "----> non improving time=0.2649999999994179s\n", - "----> non improving time=0.2649999999994179s\n", - "----> non improving time=0.2970000000059372s\n", - "----> non improving time=0.2970000000059372s\n", - "----> non improving time=0.32800000000861473s\n", - "----> non improving time=0.32800000000861473s\n", - "----> non improving time=0.375s\n", - "----> non improving time=0.375s\n", - "----> non improving time=0.40600000000267755s\n", - "----> non improving time=0.40600000000267755s\n", - "----> non improving time=0.46800000000803266s\n", - "----> non improving time=0.4840000000112923s\n", - "----> non improving time=0.577000000004773s\n", - "----> non improving time=0.577000000004773s\n", - "----> non improving time=0.6090000000112923s\n", - "----> non improving time=0.6090000000112923s\n", - "----> non improving time=0.6090000000112923s\n", - "----> non improving time=0.6090000000112923s\n", - "----> non improving time=0.6090000000112923s\n", - "----> non improving time=0.6240000000107102s\n", - "----> non improving time=0.6240000000107102s\n", - "----> non improving time=0.6240000000107102s\n", - "----> non improving time=0.6399999999994179s\n", - "----> non improving time=0.6549999999988358s\n", - "----> non improving time=0.6549999999988358s\n", - "----> non improving time=0.6710000000020955s\n", - "----> non improving time=0.702000000004773s\n", - "----> non improving time=0.7180000000080327s\n", - "----> non improving time=0.7330000000074506s\n", - "----> non improving time=0.7649999999994179s\n", - "----> non improving time=0.7960000000020955s\n", - "----> non improving time=0.8430000000080327s\n", - "----> non improving time=0.8740000000107102s\n", - "----> non improving time=0.9210000000020955s\n", - "----> non improving time=0.952000000004773s\n", - "----> non improving time=0.9990000000107102s\n", - "----> non improving time=1.0299999999988358s\n", - "----> non improving time=1.077000000004773s\n", - "----> non improving time=1.1390000000101281s\n", - "----> non improving time=2.0130000000062864s\n", - "----> non improving time=2.059000000008382s\n", - "----> non improving time=2.1370000000024447s\n", - "----> non improving time=2.2150000000110595s\n", - "----> non improving time=2.309000000008382s\n", - "----> non improving time=2.3870000000024447s\n", - "----> non improving time=2.4180000000051223s\n", - "----> non improving time=2.4650000000110595s\n", - "----> non improving time=2.5120000000024447s\n", - "----> non improving time=2.559000000008382s\n", - "----> non improving time=2.6050000000104774s\n", - "----> non improving time=2.6680000000051223s\n", - "----> non improving time=2.6990000000078s\n", - "----> non improving time=2.745999999999185s\n", - "----> non improving time=2.7930000000051223s\n", - "----> non improving time=2.8550000000104774s\n", - "----> non improving time=2.9170000000012806s\n", - "----> non improving time=2.9800000000104774s\n", - "----> non improving time=3.0420000000012806s\n", - "----> non improving time=3.1200000000098953s\n", - "----> non improving time=3.18300000000454s\n", - "----> non improving time=3.2920000000012806s\n", - "----> non improving time=3.3540000000066357s\n", - "----> non improving time=3.4320000000006985s\n", - "----> non improving time=3.5100000000093132s\n", - "----> non improving time=3.573000000003958s\n", - "----> non improving time=3.665999999997439s\n", - "----> non improving time=3.7600000000093132s\n", - "----> non improving time=3.853000000002794s\n", - "----> non improving time=3.9470000000001164s\n", - "!! aborting cplex, elapsed=4.040999999997439 >= max_no_improve: 4\n", - "!! aborting cplex, elapsed=4.103000000002794 >= max_no_improve: 4\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "large_hearts = build_hearts(12)\n", "#large_hearts.add_progress_listener(TextProgressListener(clock='gap'))\n", @@ -679,18 +494,9 @@ }, { "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "* solution has objective 24\n", - "* solve status is 'aborted'\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "large_s = large_hearts.solution\n", "print('* solution has objective {0}'.format(large_s.objective_value))\n", @@ -718,7 +524,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -735,27 +541,9 @@ }, { "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "-- new gap: 71.4%, time: 0 ms\n", - "-- new gap: 65.2%, time: 16 ms\n", - "-- new gap: 63.1%, time: 16 ms\n", - "-- new gap: 60.9%, time: 31 ms\n", - "-- new gap: 59.9%, time: 31 ms\n", - "-- new gap: 58.9%, time: 47 ms\n", - "-- new gap: 58.1%, time: 47 ms\n", - "-- new gap: 56.2%, time: 78 ms\n", - "-- new gap: 54.9%, time: 78 ms\n", - "-- new gap: 54.1%, time: 94 ms\n", - "-- new gap: 53.3%, time: 125 ms\n" - ] - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "m8 = build_hearts(8)\n", "m8.add_progress_listener(MipGapPrinter())\n", @@ -773,7 +561,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -783,7 +571,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -817,22 +605,9 @@ }, { "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmEAAAEKCAYAAABaLoJPAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3XmYXFWd//H3t5fsIXtYAiGJbAmLgD1uYVHjKAojGoKg/B5wRKNsjooouNDGGXwyBlDIgBoVAUWIBHEZZhwFWQwZMnYwaCAhBBIgbEnMvpitz++Pqm466b3T1ber+v16nn761qlbVd86qWo+nHPuvZFSQpIkSV2rLOsCJEmSeiJDmCRJUgYMYZIkSRkwhEmSJGXAECZJkpQBQ5gkSVIGDGGSJEkZMIRJkiRlwBAmSZKUgYqsC2iL4cOHpzFjxmRdhiRJUqsWLFiwJqU0orX9iiKEjRkzhpqamqzLkCRJalVEPN+W/ZyOlCRJyoAhTJIkKQOGMEmSpAwYwiRJkjJgCJMkScpAURwdWUgxLRq1peqUQSWSJKkn6dEjYU0FsJbaJUmSOkuPDmGSJElZMYRJkiRlwBDWjJgWVE6rzLoMSZJUogxhLdjFLmJauEZMkiR1uh4dwpo7CjJVJw4ffPgebXVh7OGnHu6K0iRJUomLlLr/6RiqqqpSVhfw/tQvP8WsJ2Y1av/cP3yO699/fQYVSZKk7iwiFqSUqlrdzxDWNr966ld88O4PNmo/YeQJPH7R4xlUJEmSuiNDWIGsXr2akTePbNTev6I/m7+yOYOKJElSd9LWENaj14R1xIgRI0jViVSdKGvQfVt2bXERvyRJarMef9mifbG7ejcAw6YPY+32tfXtdUFs1cWrmhw187JIkiTJkbBO8Lcr/0aqTrxz9Dv3aG8qgIGXRZIkSYawTvWHf/4DqTox8z0zsy5FkiR1c4awArj0bZc65ShJklpkCMvIsTcdm3UJkiQpQ4awjCxas4iYFsxdMjfrUiRJUgYKGsIi4nMR8WRELIqIOyOiT0SMjYj5EfFMRMyOiF6FrCFLzU1JVsbrFwY/efbJLtSXJKkHKtgpKiJiFPAZYEJKaVtE/Bw4F3g/8O2U0l0R8T3gQuC7haoja80FsTVr1jDiphH1t2NaMH7oeJ667KmuKk2SJGWo0NORFUDfiKgA+gGvAO8C5uTvvw1ofC2gHmD48OGk6sRZh59V37Z47WKnKCVJ6iEKFsJSSi8B1wIvkAtfG4AFwPqU0q78biuBUU09PiKmRkRNRNSsXr26UGVmbs5H55Cqk1OUkiT1MIWcjhwCnAmMBdYDdwPva2LXJufrUkqzgFmQu3ZkgcrsNnZcvaPJKcqjhh7FkrVLGu3vKTAkSSpuhZyOfDewPKW0OqW0E/gF8HZgcH56EuBg4OUC1lBU6qYozxt/Xn1bUwEMPOu+JEnFrpAh7AXgrRHRLyICmAQ8BTwITMnvcwHwqwLWUJR++uGfNpqilCRJpaVg05EppfkRMQd4HNgF/Jnc9OJ9wF0R8W/5th8VqoZit+PqHS2OeDV1XznlnHLIKdx95t0MGzasTY9xalOSpK4XKXX//wBXVVWlmpqarMvIRFdNOxrEJEnqHBGxIKVU1dp+njG/iKXqRKpOrLl0DccOP5ag44Ft3LfHdWJlkiSpNY6EFYHOmEKc/LPJ3PvMve16TPVJ1Xx90tfb9RhJknq6to6EGcJ6kH2d2hxYOZAVn17B0KFDXVsmSVIz2hrCCrYwX8WlYYA68sYjWbpuaaN9Nu3cxLCZjRf714lpYRCTJKmNXBPWgzQXkPZuf/ozT9evN0vVifnnzaci2pbXY1rQ51/78KsnPfOIJEktcTpS7dbRac03jXwTNRe9/u/olKYkqRQ5HalM9C7rzfba7U3et2DVglYDnFOakqSewhCmTvX3r/29Udtbv/9W5r86v83P0VRQC4JBvQfxoSM/xPXvvJ7Bgwfv0/MZ9CRJWXM6Uh2yr8GmkCehDYL9eu3He97wHu5efHez+xnEJEmF4HSkCqqQAabuuR9a8RCf++/PsWTNEv5e23iErdnHk9iwY0OLAQz2DIJB0Ke8D/sP2J/Txp3G9FOnM2jQoFZfy1E2SVJHORKmTLQ0EtaRELNwxUIu+t1FPLHqCbbt3rYvpXUKg5gk9VyerFXdXleMIrUU9v6l6l+4b9l9vLzpZbbt3kai8N+FyrJKRu83mi+f9GU+/qaPt/vxjrxJUvdnCJPo/BE3gA0bNlA9t5obam7oaFmtqlvX9u4x7+aW029hv/32K8h7kSR1PkOYlFeo0aO2hqKnVj7Fp/7nUyx8dSGbd23e59dtSu/y3gzvO5yqA6v46ju+StVBrX739+AImyR1HkOYVGCdPTK1ceNGrpl3Dbctuo01W9ewO+3el/JaFQSVZZXsqN3R7D4GMUlqP0OY1AW6cgSppdBXRhm11Hb6axrCJKn9PEWF1AW6S0jZXd22UbNXNr3Ct/74LX777G9ZuWklW3duLUh4kyS1zpEwqYgUYuTNBf+S1LkcCZNKkKFIkkpHWdYFSMpWc8HOwCdJhWUIk0SqTnuEroP6H5RhNZLUMxjCJNU78/AzAXh5y8sZVyJJpc8QJqneLz/6y/rtZa8uy7ASSSp9hjBJTZrwgwlZlyBJJc0QJmkPt33gNgB21u7MuBJJKm2GMEl7OP+E8+u3r517bYaVSFJpM4RJaqRveV8ArnjgiowrkaTSZQiT1Miqz67KugRJKnmGMEmNDBgwoH775B+dnGElklS6DGGSmnTE0CMAmLtybsaVSFJpMoRJatLTlz1dv7158+YMK5Gk0mQIk9SqQ/7jkKxLkKSSYwiT1KzLqi4DYP329RlXIkmlxxAmqVk3nn5j/fajyx/NsBJJKj2GMEktKsv/mTjl9lMyrkSSSoshTFKLHjn/EQBqqc24EkkqLQUNYRExOCLmRMSSiFgcEW+LiKER8fuIeCb/e0gha5C0byaOnVi//Zn7PpNhJZJUWgo9EnYD8NuU0lHAG4HFwJXAAymlw4EH8rcldWODeg0CYGbNzIwrkaTSUbAQFhH7AacAPwJIKe1IKa0HzgRuy+92G/DBQtUgqXOsvGxl1iVIUskp5EjYOGA18OOI+HNE/DAi+gP7p5ReAcj/HtnUgyNiakTURETN6tWrC1impNY0vIzR+JnjM6xEkkpHIUNYBXAi8N2U0gnAFtox9ZhSmpVSqkopVY0YMaJQNUpqo7eNehsAS9YuybgSSSoNhQxhK4GVKaX5+dtzyIWy1yLiQID871UFrEFSJ5n3iXn1217GSJL2XcFCWErpVeDFiDgy3zQJeAr4NXBBvu0C4FeFqkFSYYz8TpOrCCRJ7VDooyMvA+6IiL8AxwPfBKYD/xgRzwD/mL8tqQjMmDQDgG27t2VciSQVv4KGsJTSwvy6ruNSSh9MKa1LKf0tpTQppXR4/vfaQtYgqfN84aQv1G/fvejuDCuRpOLnGfMltUtFVABwzj3nZFyJJBU3Q5ikdlk8dTEAiZRxJZJU3AxhktrlsAMOq9+ecueUDCuRpOJmCJPUbvv32x+Ae5bek3ElklS8DGGS2u3VK17NugRJKnqGMEn7ZNS1o7IuQZKKkiFMUoecdcRZALy85eWMK5Gk4mQIk9Qhcz4yp3572avLMqxEkoqTIUxShwUBwPhZ4zOuRJKKjyFMUofNPms2ALvSrowrkaTiYwiT1GFnH3N2/fa1c6/NsBJJKj6GMEn7pG95XwCueOCKjCuRpOJiCJO0T1Z9dlXWJUhSUWpTCIuIIRFxdESMiwiDm6R6AwYMqN8++UcnZ1iJJBWXiubuiIhBwCXAR4BewGqgD7B/RDwG3JxSerBLqpTUrR019CiWrF3C3JVzsy5FkopGS6Nac4AXgZNTSkemlE5KKVWllA4BpgNnRsSFXVKlpG5t8WWL67c3b96cYSWSVDyaHQlLKf1jC/ctABYUpCJJRe2Q/ziEdVeuy7oMSer22ry+KyJGRMS/RcR1EXFYIYuSVHwuq7oMgPXb12dciSQVh/Yssr8OeAT4LXBnYcqRVKxuPP3G+u1Hlz+aYSWSVByaDWER8duIaHioUy9gRf6nd2HLklSMyvJ/Uk65/ZSMK5Gk7q+lkbBzyC2+/1lEvAH4GnA1uUX5F3dFcZKKyyPnPwJALbUZVyJJ3V9LC/M3AF+IiHHANcBLwCX5dklqZOLYifXbn7nvM3tMUUqS9tTSdOS4iJgBfAK4HPgV8POIuCwiyruqQEnFZXDvwQDMrJmZcSWS1L21NB15J7lF+I8BP0kp/TGl9F5gI/C7rihOUvF58dIXsy5BkopCSyGsD7A8/9OvrjGldBtwRoHrklSkGl7GaPzM8RlWIkndW0sh7GJgBvBl4NMN70gpbStkUZKK20kHnwTAkrVLMq5EkrqvlhbmPwp4sh9J7fbHC/9ITAsgdxmjhqNjkqSclhbm/yYizoiIyibuGxcR34iIjxe2PEnFbuR3RmZdgiR1Sy1NR34SOAVYEhF/ioj/iog/RMRzwPeBBSmlW7qkSklFZ8akGQBs2+3qBUlqSqSUWt8pYgxwILANWJpS2lrYsvZUVVWVampquvIlJXWCuinJ2ZNn8+FjP5xxNZLUNSJiQUqpqrX92nTtyJTSipTS/6aUFnZ1AJNUvCoit+z03F+cm3ElktT9tOcC3pLULounLgYg0fqIuyT1NIYwSQVz2AGH1W9PuXNKhpVIUvfTphAWEb0i4riIODYiehW6KEml46D+BwFwz9J7Mq5EkrqXVkNYRJwOPAvcCPwHsCwi3lfowiSVhpe+8FLWJUhSt9SWkbDrgHemlN6RUjoVeCfw7cKWJakUHTDjgKxLkKRuoy0hbFVKaVmD288Bq9r6AhFRHhF/joj/zN8eGxHzI+KZiJjt9KZU+s464iwAXtv6WsaVSFL30ZYQ9mT+RK0fi4gLgN8Af4qIyRExuQ2P/xdgcYPb/w58O6V0OLAOuLDdVUsqKnM+Mqd+e9mry1rYU5J6jraEsD7Aa8CpwDuA1cBQ4J+AM1p6YEQcDJwO/DB/O4B3AXV/kW8DPtiBuiUVmSB34tbxs8ZnXIkkdQ/NXsC7Tkrpn/fh+b8DfBEYmL89DFifUtqVv70SGLUPzy+pSMw+azYfvufD7Kr/+ktSz9aWoyP7RMQlEXFzRNxS99OGx51Bbj3ZgobNTeza5FkcI2JqRNRERM3q1atbezlJ3dzZx5xdv33t3GszrESSuoe2TEf+BDgAeC/wMHAwsKkNj5sIfCAiVgB3kZuG/A4wOCLqRuAOBl5u6sEppVkppaqUUtWIESPa8HKSuru+5X0BuOKBKzKuRJKy15YQdlhK6WvAlpTSbeTWeB3b2oNSSlellA5OKY0BzgX+kFI6D3gQqDt19gXArzpUuaSis+qzbT6wWpJKXltC2M787/URcQwwCBizD6/5JeDzEbGM3BqxH+3Dc0kqIgMGDKjffvsP355hJZKUvVYX5gOzImII8DXg18AA4Or2vEhK6SHgofz2c8Cb21WlpJJx9PCjeXLNk/zvS/+bdSmSlKlWR8JSSj9MKa1LKT2cUhqXUhqZUvpeVxQnqfQsumRR/fbmzZszrESSstXqSFhEfL6J5g3AgpTSws4vSVJPcfDMg1l/1fqsy5CkTLRlTVgV8Gly5/MaBUwld9LWH0TEFwtXmqRSdVnVZQBs2LEh40okKTttCWHDgBNTSpenlC4nF8pGAKcAHytgbZJK1I2n31i//ejyRzOsRJKy05YQNhrY0eD2TuDQlNI2YHtBqpJU8sryf35Ouf2UjCuRpGy0JYT9DHgsIqojohp4FLgzIvoDTxW0Okkl65HzHwGgltqMK5GkbLTl6Mh/BT4JrCe3IP/TKaVvpJS25E++KkntNnHsxPrtz9z3mQwrkaRstGUkjJTSgpTSDSml76SUagpdlKSeYXDvwQDMrJmZcSWS1PXaFMIkqRBevPTFrEuQpMwYwiRlpuFljI6ceWSGlUhS1zOEScrUSQefBMDStUszrkSSupYhTFKm/njhH+u3Y1rU/0hSqTOEScpUc4HLICap1LV67UhJykpTQSwIepX3YmjvoZx44IlcMfEKTh17agbVSdK+MYRJKiqJxPbd23ll6yvc9+x93Pfsfa0+piIq6NerH4fudyiTj5rMFW+5gv79+3dBtZLUvEgpZV1Dq6qqqlJNjacnk0pRS9OOqfr1v0+LVi1i+sPTmffSPF7d8irbd20v2Nn2g6B3eW+G9x1O1QFVXHnSlbzl0Ld03vM38Z4bvldJxS0iFqSUqlrdzxAmKUttDWHttWXLFm756y385C8/4dl1z7Jx+0Z2pV0dfr7WVEQFA3oNYNyQcXz06I/y6RM+3eRoW6Her6TuwxAmqWh0l5Gh+c/P59vzv828lfNYvXU1O3bv6NJrWxrCpNLQ1hDmmjBJmesu4eMth76Fuw69q837b9myhRtqbuCeJffw3Lrn2Lxjc0FH2ySVFkfCJKkLOR0plb62joR5njBJ6iZiWvChuz6UdRmSuoghTJK6UGujXb98+pfEtGDJmiVdVJGkrLgmTJK6WHNBbOKPJjJv5TwAxt80nv3778+rX3i1K0uT1IUcCZOkbuLRCx9lyxVbqIjc/x+/tuU1Ylow/ZHpGVcmqRAMYZLUjfTr14+dV+/kundfV9921YNXUT6tnK1bt2ZYmaTOZgiTpG7o8xM/T6pOHND/AABqqaX/jP68edabM65MUmcxhElSN/bKF17h+Uuer7/9p1f+REwL/vDsHzKsSlJnMIRJUjc3evhoUnViylFT6tsm/XQSA785MMOqJO0rQ5gkFYm7z7mbVJ3oU94HgM07NxPTgk/+8pMZVyapIzxjviQVoXufvJfJcya3up9n4Ze6nmfMl6QS9qGjP0SqTkwYPqHF/Vq6TJKkbBnCJKmIPXnJk2y5YkvWZUjqAEOYJBW5fv36tXh/TAsqvlHB5b+9vIsqktQWhjBJ6gF2p91cP/96YloQ04L9Z+zPsrXLsi5L6tEMYZJU4lZetpLR+43eo23V1lUcPvNwYlpQPq2cs2efnVF1Us/l0ZGSVCKaWoTf1NGR0x+ZTvXD1eyo3dHk8wzsNZB7P3wvk94wqb6tfFo5tdTW3y6jjN3Vuzuhaqn0tPXoyIKFsIg4BLgdOACoBWallG6IiKHAbGAMsAL4cEppXUvPZQiTpMLYtm0bb7v1bTyx6ol2P9YgJjWtO5yiYhdweUppPPBW4JKImABcCTyQUjoceCB/W5KUgb59+7LwooWk6kSqTtw1+S76VbS80L9Ow5ExSe1XsBCWUnolpfR4fnsTsBgYBZwJ3Jbf7Tbgg4WqQZLUPuccew5bvrKlPpRNGjupxf1XrF/RNYVJJahLFuZHxBjgBGA+sH9K6RXIBTVgZFfUIElqv/vPv7/F+8feMJaYFoy6bhTr/76+i6qSSkNFoV8gIgYA9wCfTSltjGjb2ZsjYiowFWD06NGt7C1JKpQyylqdenx588sM+fchABwx9Aie+OQT9OnTpyvKk4pWQUfCIqKSXAC7I6X0i3zzaxFxYP7+A4FVTT02pTQrpVSVUqoaMWJEIcuUJLVgd/Vuyvb6z0UZZfVTlnefdTe9y3vX37d07VL6/ntfYlrwlllv6epypaJRyKMjg9yar7Uppc82aJ8B/C2lND0irgSGppS+2NJzeXSkJBWHG//3Ri7//eXsSrv2aA+C095wGv/1//4LgF7f6MXOtLP+/sqoZMfVTZ8yQyo23eEUFScBfwT+CvXj2F8mty7s58Bo4AXg7JTS2paeyxAmScXni7/7Itc9dh21qW1HURrEVCoyD2GdyRAmScXtY/d+jNv/cjuJlv+b09TJZaViYwiTJHVLTZ3Zv6GyKGN43+F8aeKX+PzbP99FVUmdxxAmSeqWWgthTSmLMkYPHM30d0/nnGPPaXKffv/Wj227t9Xf7lvel61f3drhOqWO6g5nzJckqZHKqGy2PVUnZp81mzGDxlAWr/8nqjbVsmLjCs79xbnEtCCmBRXfqGDCTROY+/zcRgEMYNvubfT7t7ad/V/KgiNhkqQu196jI6+fdz0z5s1g1dZVbV7oX8d1ZupqTkdKkkra5f9zOT9e+GPW/X1dm/Yvo4xeFb0Y1ncYRw8/mikTpnDBcRfQq1evRvsOmT6E9dtfvwLA4N6DWXdl215HMoRJknqMjqwza0pLVwcwiKmt2hrCCn7ZIkmSCq1ved9Ga8Lq2usW52/esZkfLPgB9y65l6V/W8r6v69nx+4de5w2o6XLM63fvp6tO7fSr9J1ZuocjoRJkkpCZxwd+ezaZzls5mEt7hMEo/YbxfRJ0znvuPM6VKtKm9ORkiR1QEtTm0E0OuFsr7JenHzoydw15S6G9xte6PJUBDxFhSRJHTC49+Bm22ura1l/xXo+cMQH6FPRB4AdtTt4YPkDjJgxgpgWjPjWCGY8OqMrS1aRciRMkqS9tOfoyPuevo/LfnsZK9avaDRKVhEVvPGAN3LH5Ds4cviR9e2jrhvFy5tfrr990ICDeOnylzr5XSgrTkdKktTFdu7cycX/fTF3LbqLzTs3N7p/v977sWvXLrbubrxWzSBWOpyOlCSpi1VWVvKDD/yATV/eRKpO/N8n/o9jRh5DeZQDsHH7xiYDGLDHyJh6BkfCJEnqIlfdfxXTH53e7P1B0Lu8N8P7DefYkccyZcIUzj/ufCoqPKNUMXE6UpKkbqijJ5Ytj3IG9h7ImEFjOHXMqVxcdTFHDD9ij32OvulonlrzVP3tCcMn8OQlT+5TvWo/Q5gkSd3Q3ovy69StCdu1axdzFs/hzkV3svC1hazasortu7Y3WvRfp270bOfunexmd6P7DWJdzxAmSVI31dGjI5f9bRnfrfkuDy5/kOUblrNp+yZ2p8bBa2+nH3467xr7Lj567Ec5YMAB+1S7WmcIkySph9i1axeV11S2ef9eZb0Y1GcQYwaP4c2j3szk8ZM5dfSplJeXN9r33be/mweWP1B/e9LYSdx//v2dUnepMoRJktSDtLTW7Jvv+iYPP/8wS9YsYfWW1Wzbta3J6c2yKKNfZT8O6H8AR488msWrF7N07dJG+xnEWmYIkySpB9l7UX6d5taE7di9g/uW3sdvnv4Nj7/6OC9ueJGNOzayq3ZXm17vY2/8GIcMOoQxg8dw+NDDOWr4UYzoP6LD9V9838XMWjCL3Wk35VHO1DdN5ebTb+7w82XJECZJUg/TWUdHLl2zlNlPzubqh65u92MryiroXd6bAb0GMKj3IIb1G8bI/iMZNXAUoweNZtyQcRwx7AiOGHYEfSv7ArkA9t2a7zZ6rouqLirKIGYIkyRJ+6SlKc65/zyXZWuXsXzdcl7Y+AKvbHqF1VtXs3bb2txJaXduZfvu7dSm2uafn6CyvJIdu3c0eX95lLPr6raNzHUnbQ1hnv1NkiQ1adLYSXssym/YPnH0RCaOntjqc9TW1vL8hudZsmYJz657lufXP8/KjSt5dfOrrNm6hnV/X8dLm5o+MrQtR34WM0OYJElq0v3n37/PR0eWlZUxdshYxg4Z2+w+Fd+oaDJw1V3uqVQZwiRJUrO64ijIqW+a2uSasD4VfXhs5WO89eC3FryGLHgBb0mSlKmbT7+Zi6ouqh/5Ko9yJo+fzMj+Izn5xydz7bxrW1xbVqxcmC9Jkrql9X9fz4W/vpBfLP4FZxxxBreeeSvD+g3LuqxWtXVhviNhkiSpWxrcZzBzzp7DzPfN5HfP/o4Tvn8C816cl3VZncYQJkmSuq2I4NI3X8q8j8+jsrySU358Ct969FslMT1pCJMkSd3emw56E49PfZzJ4yfzpfu/xBk/O4M1W9dkXdY+MYRJkqSiMKjPIGZPmc1N77+JB5Y/wPHfO565L8zNuqwOM4RJkqSiERFc/A8X89iFj9G3si/vuPUdTJ87vSinJw1hkiSp6Jxw4AksmLqAKROmcNUDV3H6z05n9ZbVWZfVLoYwSZJUlPbrvR93nnUn3zv9ezy4/EGO//7xPPL8I1mX1WaGMEmSVLQigk9VfYrHPvEY/Sv7887b3sk1j1xTFNOThjBJklT0jj/geBZMXcA5R5/DVx/8Ku+7432s2rIq67JalEkIi4jTIuLpiFgWEVdmUYMkSSotA3sP5I7JdzDrjFk88vwjHP+943loxUNZl9WsLg9hEVEO3AS8D5gAfCQiJnR1HZIkqfREBJ980yeZ/4n5DOw9kEm3T2LKz6dw6HcOpWxaGWO+M4Y7/npH1mUC2YyEvRlYllJ6LqW0A7gLODODOiRJUok6bv/jWDB1AW87+G3cs/geXtjwAonE8xueZ+pvpnaLIJZFCBsFvNjg9sp8myRJUqcZ0GsAL258sVH71p1b+coDX8mgoj1lEcKiibbUaKeIqRFRExE1q1cX13k/JElS9/DihsYhDOCFDS90cSWNZRHCVgKHNLh9MPDy3jullGallKpSSlUjRozosuIkSVLpGD1odLvau1IWIexPwOERMTYiegHnAr/OoA5JklTirpl0Df0q++3R1q+yH9dMuiajil7X5SEspbQLuBT4H2Ax8POU0pNdXYckSSp95x17HrP+aRaHDjqUIDh00KHM+qdZnHfseVmXRqTUaDlWt1NVVZVqamqyLkOSJKlVEbEgpVTV2n6eMV+SJCkDhjBJkqQMGMIkSZIyYAiTJEnKgCFMkiQpA0VxdGRErAaeL/DLDAfWFPg1io190ph90ph90ph90ph90ph9sqdS6o9DU0qtnmm+KEJYV4iImrYcTtqT2CeN2SeN2SeN2SeN2SeN2Sd76on94XSkJElSBgxhkiRJGTCEvW5W1gV0Q/ZJY/ZJY/ZJY/ZJY/ZJY/bJnnpcf7gmTJIkKQOOhEmSJGXAEAZExGkR8XRELIuIK7Oup6tExIqI+GtELIyImnzb0Ij4fUQ8k/89JN8eEXFjvo/+EhEnZlt954mIWyJiVUQsatDW7n6IiAvy+z8TERdk8V46QzP98fWIeCn/WVkYEe9vcN9V+f54OiLe26C9ZL5XEXFIRDwYEYsj4smI+Jd8e0/+nDTXJz32sxIRfSLi/yLiiXyfTMu3j42I+fl/89kR0SuBA01FAAAG3UlEQVTf3jt/e1n+/jENnqvJvio2LfTJrRGxvMHn5Ph8e8l/d/aQUurRP0A58CwwDugFPAFMyLquLnrvK4Dhe7V9C7gyv30l8O/57fcD/w0E8FZgftb1d2I/nAKcCCzqaD8AQ4Hn8r+H5LeHZP3eOrE/vg58oYl9J+S/M72BsfnvUnmpfa+AA4ET89sDgaX5996TPyfN9UmP/azk/70H5Lcrgfn5f/+fA+fm278HXJTfvhj4Xn77XGB2S32V9fvr5D65FZjSxP4l/91p+ONIGLwZWJZSei6ltAO4Czgz45qydCZwW377NuCDDdpvTzmPAYMj4sAsCuxsKaVHgLV7Nbe3H94L/D6ltDaltA74PXBa4avvfM30R3POBO5KKW1PKS0HlpH7TpXU9yql9EpK6fH89iZgMTCKnv05aa5PmlPyn5X8v/fm/M3K/E8C3gXMybfv/Tmp+/zMASZFRNB8XxWdFvqkOSX/3WnIEJb7o/Fig9srafkPSSlJwO8iYkFETM237Z9SegVyf2SBkfn2ntZP7e2HntA/l+anB26pm3ajB/ZHfsroBHL/R+/nhEZ9Aj34sxIR5RGxEFhFLig8C6xPKe3K79Lw/dW/9/z9G4BhlHifpJTqPifX5D8n346I3vm2HvE5qWMIyw157q2nHDI6MaV0IvA+4JKIOKWFfXtyPzXUXD+Uev98F3gDcDzwCnBdvr1H9UdEDADuAT6bUtrY0q5NtJVkvzTRJz36s5JS2p1SOh44mNzo1fimdsv/7pF9EhHHAFcBRwH/QG6K8Uv53XtEn9QxhOXS9CENbh8MvJxRLV0qpfRy/vcq4F5yfzBeq5tmzP9eld+9p/VTe/uhpPsnpfRa/g9pLfADXp8a6TH9ERGV5MLGHSmlX+Sbe/TnpKk+8bOSk1JaDzxEbl3T4IioyN/V8P3Vv/f8/YPILQUo9T45LT+dnVJK24Ef00M/J4Yw+BNweP7olV7kFkf+OuOaCi4i+kfEwLpt4D3AInLvve6okwuAX+W3fw2cnz9y5a3AhrppmBLV3n74H+A9ETEkP/3ynnxbSdhr/d+HyH1WINcf5+aP8hoLHA78HyX2vcqv0/kRsDildH2Du3rs56S5PunJn5WIGBERg/PbfYF3k1sr9yAwJb/b3p+Tus/PFOAPKaVE831VdJrpkyUN/uclyK2Ra/g5Kenvzh6yOiKgO/2QOxpjKbm5+69kXU8Xvedx5I6+eQJ4su59k1uP8ADwTP730Hx7ADfl++ivQFXW76ET++JOctMmO8n939aFHekH4OPkFtAuA/456/fVyf3xk/z7/Qu5P5IHNtj/K/n+eBp4X4P2kvleASeRm/r4C7Aw//P+Hv45aa5PeuxnBTgO+HP+vS8Crs63jyMXopYBdwO98+198reX5e8f11pfFdtPC33yh/znZBHwU14/grLkvzsNfzxjviRJUgacjpQkScqAIUySJCkDhjBJkqQMGMIkSZIyYAiTJEnKgCFMkiQpA4YwSd1WRAyOiIsb3D4oIua09Jh9eK0PRsTVnfA810bEuzqjJkmlzfOESeq28heG/s+U0jFd8FrzgA+klNbs4/McCvwgpfSezqlMUqlyJExSdzYdeENELIyIGRExJiIWAUTExyLilxHxm4hYHhGXRsTnI+LPEfFYRAzN7/eGiPhtRCyIiD9GxFF7v0hEHAFsrwtgEXFrRHw3Ih6MiOci4tSIuCUiFkfErfl9yvP7LYqIv0bE5wBSSs8DwyLigK7pIknFqqL1XSQpM1cCx6SUjof6kbGGjgFOIHf5l2XAl1JKJ0TEt4Hzge8As4BPp5SeiYi3ADcDe08XTgQe36ttSH6/DwC/ye/zCeBPEXE8UA6Mqhulq7s+Xt7j+f3v6djbltQTGMIkFbMHU0qbgE0RsYFcWILcNeeOi4gBwNuBu3PXCQagdxPPcyCweq+236SUUkT8FXgtpfRXgIh4EhgDPAyMi4iZwH3A7xo8dhVw0L6+OUmlzRAmqZhtb7Bd2+B2Lbm/b2XA+rqRtBZsAwY189wNn7f+uVNK6yLijcB7gUuAD5O7wDDkRua2teN9SOqBXBMmqTvbBAzs6INTShuB5RFxNkDkvLGJXRcDh7XnuSNiOFCWUroH+BpwYoO7jwAWdaxqST2FIUxSt5VS+hvwaH7x+4wOPs15wIUR8QTwJHBmE/s8ApwQDeYs22AU8FBELARuBa4CiIhKcoGupoP1SuohPEWFJAERcQO5dWD37+PzfAg4MaX0tc6pTFKpciRMknK+CfTrhOepAK7rhOeRVOIcCZMkScqAI2GSJEkZMIRJkiRlwBAmSZKUAUOYJElSBgxhkiRJGfj/upBpD7TTxrkAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "m9 = build_hearts(9)\n", "m9.add_progress_listener(MipGapPlotter())\n", @@ -894,7 +669,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.1" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/examples/mp/jupyter/sports_scheduling.ipynb b/examples/mp/jupyter/sports_scheduling.ipynb index 6155914..be19c04 100644 --- a/examples/mp/jupyter/sports_scheduling.ipynb +++ b/examples/mp/jupyter/sports_scheduling.ipynb @@ -15,7 +15,7 @@ "\n", ">This notebook is part of [Prescriptive Analytics for Python](http://ibmdecisionoptimization.github.io/docplex-doc/)\n", ">\n", - ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/>) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", + ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", "and you can start using Watson Studio Cloud right away).\n", "\n", "\n", @@ -713,7 +713,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.1" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/examples/mp/jupyter/tutorials/Beyond_Linear_Programming.ipynb b/examples/mp/jupyter/tutorials/Beyond_Linear_Programming.ipynb index 02fdf2e..acec3dd 100644 --- a/examples/mp/jupyter/tutorials/Beyond_Linear_Programming.ipynb +++ b/examples/mp/jupyter/tutorials/Beyond_Linear_Programming.ipynb @@ -14,7 +14,7 @@ "\n", ">This notebook is part of **[Prescriptive Analytics for Python](http://ibmdecisionoptimization.github.io/docplex-doc/)**\n", ">\n", - ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/>) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", + ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", "and you can start using Watson Studio Cloud right away).\n", "\n", "\n", @@ -50,9 +50,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "import sys\n", @@ -79,9 +77,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "url = None\n", @@ -196,9 +192,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "capacities = {1: 15, 2: 20}\n", @@ -266,9 +260,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "# for each node, total outgoing flow must be smaller than available quantity\n", @@ -930,9 +922,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "tm2 = Model('decision_phone')" @@ -1018,9 +1008,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "tm2.maximize(12 * desk + 20 * cell)" @@ -1146,9 +1134,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "import pandas as pd\n", @@ -1232,12 +1218,10 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ - "from docplex.mp.advmodel import AdvModel as Model\n", + "from docplex.mp.model import Model\n", "\n", "mdl = Model(name='portfolio_miqp')" ] @@ -1252,9 +1236,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "# create variables\n", @@ -1278,9 +1260,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "# max fraction\n", @@ -1320,9 +1300,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "# KPIs\n", @@ -1518,7 +1496,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.1" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/examples/mp/jupyter/tutorials/Linear_Programming.ipynb b/examples/mp/jupyter/tutorials/Linear_Programming.ipynb index a362e5b..5207655 100644 --- a/examples/mp/jupyter/tutorials/Linear_Programming.ipynb +++ b/examples/mp/jupyter/tutorials/Linear_Programming.ipynb @@ -17,7 +17,7 @@ "\n", ">This notebook is part of **[Prescriptive Analytics for Python](http://ibmdecisionoptimization.github.io/docplex-doc/)**\n", ">\n", - ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/>) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", + ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", "and you can start using Watson Studio Cloud right away).\n", "\n", "\n", @@ -1159,7 +1159,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.1" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/examples/mp/jupyter/ucp_pandas.ipynb b/examples/mp/jupyter/ucp_pandas.ipynb index b44a471..59de905 100644 --- a/examples/mp/jupyter/ucp_pandas.ipynb +++ b/examples/mp/jupyter/ucp_pandas.ipynb @@ -12,7 +12,7 @@ "\n", ">This notebook is part of [Prescriptive Analytics for Python](http://ibmdecisionoptimization.github.io/docplex-doc/)\n", ">\n", - ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/>) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", + ">It requires either an [installation of CPLEX Optimizers](http://ibmdecisionoptimization.github.io/docplex-doc/getting_started.html) or it can be run on [IBM Watson Studio Cloud](https://www.ibm.com/cloud/watson-studio/) (Sign up for a [free IBM Cloud account](https://dataplatform.cloud.ibm.com/registration/stepone?context=wdp&apps=all>)\n", "and you can start using Watson Studio Cloud right away).\n", "\n", "\n", @@ -1071,7 +1071,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.1" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/examples/mp/modeling/diet.py b/examples/mp/modeling/diet.py index 8d2cc82..3dfd14b 100644 --- a/examples/mp/modeling/diet.py +++ b/examples/mp/modeling/diet.py @@ -13,7 +13,6 @@ from docplex.mp.model import Model from docplex.util.environment import get_environment - # ---------------------------------------------------------------------------- # Initialize the problem data # ---------------------------------------------------------------------------- @@ -61,19 +60,21 @@ # ---------------------------------------------------------------------------- def build_diet_model(name='diet', **kwargs): - # Create tuples with named fields for foods and nutrients + ints = kwargs.pop('ints', False) + # Create tuples with named fields for foods and nutrients foods = [Food(*f) for f in FOODS] nutrients = [Nutrient(*row) for row in NUTRIENTS] food_nutrients = {(fn[0], nutrients[n].name): - fn[1 + n] for fn in FOOD_NUTRIENTS for n in range(len(NUTRIENTS))} + fn[1 + n] for fn in FOOD_NUTRIENTS for n in range(len(NUTRIENTS))} # Model mdl = Model(name=name, **kwargs) # Decision variables, limited to be >= Food.qmin and <= Food.qmax - qty = mdl.continuous_var_dict(foods, lb=lambda f: f.qmin, ub=lambda f: f.qmax, name=lambda f: "q_%s" % f.name) + ftype = mdl.integer_vartype if ints else mdl.continuous_vartype + qty = mdl.var_dict(foods, ftype, lb=lambda f: f.qmin, ub=lambda f: f.qmax, name=lambda f: "q_%s" % f.name) # Limit range of nutrients, and mark them as KPIs for n in nutrients: @@ -82,23 +83,36 @@ def build_diet_model(name='diet', **kwargs): mdl.add_kpi(amount, publish_name="Total %s" % n.name) # Minimize cost - mdl.minimize(mdl.sum(qty[f] * f.unit_cost for f in foods)) + total_cost = mdl.sum(qty[f] * f.unit_cost for f in foods) + mdl.add_kpi(total_cost, 'Total cost') + + # add a functional KPI , taking a model and a solution as argument + # this KPI counts the number of foods used. + def nb_products(mdl_, s_): + qvs = mdl_.find_matching_vars(pattern="q_") + return sum(1 for qv in qvs if s_[qv] >= 1e-5) + + mdl.add_kpi(nb_products, 'Nb foods') + mdl.minimize(total_cost) return mdl + # ---------------------------------------------------------------------------- # Solve the model and display the result # ---------------------------------------------------------------------------- - if __name__ == '__main__': - mdl = build_diet_model() + mdl = build_diet_model(ints=True, log_output=True, float_precision=6) mdl.print_information() - mdl.export_as_lp() - if mdl.solve(): - mdl.float_precision = 3 - print("* model solved as function:") - mdl.print_solution() + + s = mdl.solve() + if s: + qty_vars = mdl.find_matching_vars(pattern="q_") + for fv in qty_vars: + food_name = fv.name[2:] + print("Buy {0:<25} = {1:9.6g}".format(food_name, fv.solution_value)) + mdl.report_kpis() # Save the CPLEX solution as "solution.json" program output with get_environment().get_output_stream("solution.json") as fp: