{ "nbformat": 4, "nbformat_minor": 0, "metadata": { "colab": { "provenance": [] }, "kernelspec": { "name": "python3", "display_name": "Python 3" }, "language_info": { "name": "python" } }, "cells": [ { "cell_type": "code", "execution_count": null, "metadata": { "id": "Jo2_AFTcj6kv", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "f938c5ad-6f41-41c8-c8b4-d0bfb7ee51a2" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "\u001b[K |████████████████████████████████| 11.1 MB 7.5 MB/s \n", "\u001b[K |████████████████████████████████| 49 kB 3.8 MB/s \n", "\u001b[?25h" ] } ], "source": [ "# Instalación de Pyomo como paquete de modelado\n", "!pip install -q pyomo" ] }, { "cell_type": "code", "source": [ "# Instalación el solver glpk para problemas lineales (continuos y enteros)\n", "!apt-get install -y -qq glpk-utils" ], "metadata": { "id": "09XhHawVj81s", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "703b4490-90fb-4637-9887-2c4f6d76ed90" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Selecting previously unselected package libsuitesparseconfig5:amd64.\n", "(Reading database ... 124016 files and directories currently installed.)\n", "Preparing to unpack .../libsuitesparseconfig5_1%3a5.1.2-2_amd64.deb ...\n", "Unpacking libsuitesparseconfig5:amd64 (1:5.1.2-2) ...\n", "Selecting previously unselected package libamd2:amd64.\n", "Preparing to unpack .../libamd2_1%3a5.1.2-2_amd64.deb ...\n", "Unpacking libamd2:amd64 (1:5.1.2-2) ...\n", "Selecting previously unselected package libcolamd2:amd64.\n", "Preparing to unpack .../libcolamd2_1%3a5.1.2-2_amd64.deb ...\n", "Unpacking libcolamd2:amd64 (1:5.1.2-2) ...\n", "Selecting previously unselected package libglpk40:amd64.\n", "Preparing to unpack .../libglpk40_4.65-1_amd64.deb ...\n", "Unpacking libglpk40:amd64 (4.65-1) ...\n", "Selecting previously unselected package glpk-utils.\n", "Preparing to unpack .../glpk-utils_4.65-1_amd64.deb ...\n", "Unpacking glpk-utils (4.65-1) ...\n", "Setting up libsuitesparseconfig5:amd64 (1:5.1.2-2) ...\n", "Setting up libcolamd2:amd64 (1:5.1.2-2) ...\n", "Setting up libamd2:amd64 (1:5.1.2-2) ...\n", "Setting up libglpk40:amd64 (4.65-1) ...\n", "Setting up glpk-utils (4.65-1) ...\n", "Processing triggers for libc-bin (2.27-3ubuntu1.6) ...\n", "Processing triggers for man-db (2.8.3-2ubuntu0.1) ...\n" ] } ] }, { "cell_type": "code", "source": [ "# Instalación el solver cbc para problemas lineales (continuos y enteros)\n", "!apt-get install -y -qq coinor-cbc" ], "metadata": { "id": "XV0iEmdJRrsu", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "c9401085-f573-4727-f6fa-226a586d2f3f" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Selecting previously unselected package coinor-libcoinutils3v5.\n", "(Reading database ... \r(Reading database ... 5%\r(Reading database ... 10%\r(Reading database ... 15%\r(Reading database ... 20%\r(Reading database ... 25%\r(Reading database ... 30%\r(Reading database ... 35%\r(Reading database ... 40%\r(Reading database ... 45%\r(Reading database ... 50%\r(Reading database ... 55%\r(Reading database ... 60%\r(Reading database ... 65%\r(Reading database ... 70%\r(Reading database ... 75%\r(Reading database ... 80%\r(Reading database ... 85%\r(Reading database ... 90%\r(Reading database ... 95%\r(Reading database ... 100%\r(Reading database ... 124219 files and directories currently installed.)\n", "Preparing to unpack .../0-coinor-libcoinutils3v5_2.10.14+repack1-1_amd64.deb ...\n", "Unpacking coinor-libcoinutils3v5 (2.10.14+repack1-1) ...\n", "Selecting previously unselected package coinor-libosi1v5.\n", "Preparing to unpack .../1-coinor-libosi1v5_0.107.9+repack1-1_amd64.deb ...\n", "Unpacking coinor-libosi1v5 (0.107.9+repack1-1) ...\n", "Selecting previously unselected package coinor-libclp1.\n", "Preparing to unpack .../2-coinor-libclp1_1.16.11+repack1-1_amd64.deb ...\n", "Unpacking coinor-libclp1 (1.16.11+repack1-1) ...\n", "Selecting previously unselected package coinor-libcgl1.\n", "Preparing to unpack .../3-coinor-libcgl1_0.59.10+repack1-1_amd64.deb ...\n", "Unpacking coinor-libcgl1 (0.59.10+repack1-1) ...\n", "Selecting previously unselected package coinor-libcbc3.\n", "Preparing to unpack .../4-coinor-libcbc3_2.9.9+repack1-1_amd64.deb ...\n", "Unpacking coinor-libcbc3 (2.9.9+repack1-1) ...\n", "Selecting previously unselected package coinor-cbc.\n", "Preparing to unpack .../5-coinor-cbc_2.9.9+repack1-1_amd64.deb ...\n", "Unpacking coinor-cbc (2.9.9+repack1-1) ...\n", "Setting up coinor-libcoinutils3v5 (2.10.14+repack1-1) ...\n", "Setting up coinor-libosi1v5 (0.107.9+repack1-1) ...\n", "Setting up coinor-libclp1 (1.16.11+repack1-1) ...\n", "Setting up coinor-libcgl1 (0.59.10+repack1-1) ...\n", "Setting up coinor-libcbc3 (2.9.9+repack1-1) ...\n", "Setting up coinor-cbc (2.9.9+repack1-1) ...\n", "Processing triggers for man-db (2.8.3-2ubuntu0.1) ...\n", "Processing triggers for libc-bin (2.27-3ubuntu1.6) ...\n" ] } ] }, { "cell_type": "code", "source": [ "# Instalación el solver ipopt para problemas lineales (continuos y enteros) - método del punto interior\n", "!wget -N -q \"https://ampl.com/dl/open/ipopt/ipopt-linux64.zip\"\n", "!unzip -o -q ipopt-linux64" ], "metadata": { "id": "ddfPx3vr6qM3" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "# Instalación el solver bonmin para problemas no lineales (continuos y enteros)\n", "!wget -N -q \"https://ampl.com/dl/open/bonmin/bonmin-linux64.zip\"\n", "!unzip -o -q bonmin-linux64" ], "metadata": { "id": "frMCSVC662Du" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "# Importación de los paquetes de Python\n", "from pyomo.environ import *\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from google.colab import files" ], "metadata": { "id": "9tiuahJPlLd3" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "def cargarModelo():\n", "\n", " # Genero problema lineal continuo en pyomo\n", "\n", " # max f1 = X1 \n", " # max f2 = 3 X1 + 4 X2 \n", " # st X1 <= 20 \n", " # X2 <= 40 \n", " # 5 X1 + 4 X2 <= 200 \n", " # X >= 0\n", "\n", " model = ConcreteModel()\n", "\n", " model.X1 = Var(within=NonNegativeReals)\n", " model.X2 = Var(within=NonNegativeReals)\n", "\n", " model.C1 = Constraint(expr = model.X1 <= 20)\n", " model.C2 = Constraint(expr = model.X2 <= 40)\n", " model.C3 = Constraint(expr = 5 * model.X1 + 4 * model.X2 <= 200)\n", "\n", " model.f1 = Var()\n", " model.f2 = Var()\n", " model.C_f1 = Constraint(expr= model.f1 == model.X1)\n", " model.C_f2 = Constraint(expr= model.f2 == 3 * model.X1 + 4 * model.X2)\n", " model.O_f1 = Objective(expr= model.f1 , sense=maximize)\n", " model.O_f2 = Objective(expr= model.f2 , sense=maximize)\n", "\n", " return model" ], "metadata": { "id": "aTRq-_LjEH81" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "def cargarModelo_int():\n", "\n", " # Genero problema lineal entero en pyomo\n", "\n", " # max f1 = X1 \n", " # max f2 = 3 X1 + 4 X2 \n", " # st X1 <= 20 \n", " # X2 <= 40 \n", " # 5 X1 + 4 X2 <= 200 \n", " # X entero\n", "\n", " model = ConcreteModel()\n", "\n", " model.X1 = Var(within=NonNegativeIntegers)\n", " model.X2 = Var(within=NonNegativeIntegers)\n", "\n", " model.C1 = Constraint(expr = model.X1 <= 20)\n", " model.C2 = Constraint(expr = model.X2 <= 40)\n", " model.C3 = Constraint(expr = 5 * model.X1 + 4 * model.X2 <= 200)\n", "\n", " model.f1 = Var()\n", " model.f2 = Var()\n", " model.C_f1 = Constraint(expr= model.f1 == model.X1)\n", " model.C_f2 = Constraint(expr= model.f2 == 3 * model.X1 + 4 * model.X2)\n", " model.O_f1 = Objective(expr= model.f1 , sense=maximize)\n", " model.O_f2 = Objective(expr= model.f2 , sense=maximize)\n", "\n", " return model" ], "metadata": { "id": "dz6stTlfArEF" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "def cargarModelo_nl():\n", "\n", " # Genero problema no lineal continuo en pyomo\n", "\n", " # max f1 = X1 * X1\n", " # max f2 = 3 X1 + 4 X2 \n", " # st X1 <= 20 \n", " # X2 <= 40 \n", " # 5 X1 + 4 X2 <= 200 \n", " # X >= 0\n", "\n", " model = ConcreteModel()\n", "\n", " model.X1 = Var(within=NonNegativeIntegers)\n", " model.X2 = Var(within=NonNegativeIntegers)\n", "\n", " model.C1 = Constraint(expr = model.X1 <= 20)\n", " model.C2 = Constraint(expr = model.X2 <= 40)\n", " model.C3 = Constraint(expr = 5 * model.X1 + 4 * model.X2 <= 200)\n", "\n", " model.f1 = Var()\n", " model.f2 = Var()\n", " model.C_f1 = Constraint(expr= model.f1 == model.X1 * model.X1)\n", " model.C_f2 = Constraint(expr= model.f2 == 3 * model.X1 + 4 * model.X2)\n", " model.O_f1 = Objective(expr= model.f1 , sense=maximize)\n", " model.O_f2 = Objective(expr= model.f2 , sense=maximize)\n", "\n", " return model" ], "metadata": { "id": "29pQZYgG7Pg8" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "def cargarModelo_nl_int():\n", "\n", " # Genero problema no lineal entero en pyomo\n", "\n", " # max f1 = X1 * X1\n", " # max f2 = 3 X1 + 4 X2 \n", " # st X1 <= 20 \n", " # X2 <= 40 \n", " # 5 X1 + 4 X2 <= 200 \n", " # X entero\n", "\n", " model = ConcreteModel()\n", "\n", " model.X1 = Var(within=NonNegativeIntegers)\n", " model.X2 = Var(within=NonNegativeIntegers)\n", "\n", " model.C1 = Constraint(expr = model.X1 <= 20)\n", " model.C2 = Constraint(expr = model.X2 <= 40)\n", " model.C3 = Constraint(expr = 5 * model.X1 + 4 * model.X2 <= 200)\n", "\n", " model.f1 = Var()\n", " model.f2 = Var()\n", " model.C_f1 = Constraint(expr= model.f1 == model.X1 * model.X1)\n", " model.C_f2 = Constraint(expr= model.f2 == 3 * model.X1 + 4 * model.X2)\n", " model.O_f1 = Objective(expr= model.f1 , sense=maximize)\n", " model.O_f2 = Objective(expr= model.f2 , sense=maximize)\n", "\n", " return model" ], "metadata": { "id": "bEdm9-Ju8q0I" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "def encontrarExtremos(model):\n", "\n", " # Para usar glpk\n", " solver = SolverFactory('glpk')\n", " # Opciones para glpk\n", " solver.options = {'tmlim': 20, 'mipgap': 0.00}\n", "\n", " # Para usar CBC\n", " #solver = SolverFactory('cbc')\n", " # Opciones para CBC\n", " #solver.options = {'sec': 20, 'threads': 6, 'ratio': 0.00}\n", "\n", " # Maximizo f1 libremente\n", " model.O_f2.deactivate()\n", " model.O_f1.activate()\n", "\n", " solver.solve(model, tee=False)\n", "\n", " print('Extremo 1')\n", " print( '( X1 , X2 ) = ( ' + str(value(model.X1)) + ' , ' + str(value(model.X2)) + ' )')\n", " print( 'f1 = ' + str(value(model.f1)) )\n", " print( 'f2 = ' + str(value(model.f2)) )\n", " f2_min = value(model.f2)\n", " f1_max = value(model.f1)\n", "\n", " # Maximizo f2 libremente\n", " model.O_f2.activate()\n", " model.O_f1.deactivate()\n", "\n", " solver.solve(model, tee=False);\n", "\n", " print('Extremo 2')\n", " print( '( X1 , X2 ) = ( ' + str(value(model.X1)) + ' , ' + str(value(model.X2)) + ' )')\n", " print( 'f1 = ' + str(value(model.f1)) )\n", " print( 'f2 = ' + str(value(model.f2)) )\n", " f2_max = value(model.f2)\n", " f1_min = value(model.f1)\n", "\n", " model.O_f1.activate()\n", "\n", " return f2_min, f2_max, f1_min, f1_max, solver" ], "metadata": { "id": "9XfG0Kktq-QR" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "model = cargarModelo()\n", "f2_min, f2_max, f1_min, f1_max, solver = encontrarExtremos(model)" ], "metadata": { "id": "GeLLF-VAlE27" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "def encontrarExtremosLexicographic(model):\n", "\n", " # Para usar glpk\n", " #solver = SolverFactory('glpk')\n", " # Opciones para glpk\n", " #solver.options = {'tmlim': 20, 'mipgap': 0.02}\n", "\n", " # Para usar CBC\n", " solver = SolverFactory('cbc')\n", " # Opciones para CBC\n", " #solver.options = {'sec': 20, 'threads': 6, 'ratio': 0.02}\n", "\n", " # Maximizo f1 libremente\n", " model.O_f2.deactivate()\n", " model.O_f1.activate()\n", "\n", " solver.solve(model)\n", "\n", " print('Extremo 1')\n", " print('Primer paso')\n", " print( '( X1 , X2 ) = ( ' + str(value(model.X1)) + ' , ' + str(value(model.X2)) + ' )')\n", " print( 'f1 = ' + str(value(model.f1)) )\n", " print( 'f2 = ' + str(value(model.f2)) )\n", " f1_max = value(model.f1)\n", "\n", " # Maximizo f2 sujeto a que f1 no empeore\n", " model.O_f2.activate()\n", " model.O_f1.deactivate()\n", " model.C_epsilon = Constraint(expr = model.f1 >= f1_max)\n", "\n", " solver.solve(model)\n", "\n", " print('Segundo paso')\n", " print( '( X1 , X2 ) = ( ' + str(value(model.X1)) + ' , ' + str(value(model.X2)) + ' )')\n", " print( 'f1 = ' + str(value(model.f1)) )\n", " print( 'f2 = ' + str(value(model.f2)) )\n", " \n", " # Tomo el mínimo de f2 sobre el frente de Pareto\n", " f2_min = value(model.f2)\n", " # Elimino restricción que impide empeorar a f1 para volver \n", " # el modelo a su estado original\n", " model.del_component(model.C_epsilon)\n", "\n", " # Maximizo f2 libremente\n", " model.O_f1.deactivate()\n", " model.O_f2.activate()\n", "\n", " solver.solve(model)\n", "\n", " print('Extremo 2')\n", " print('Primer paso')\n", " print( '( X1 , X2 ) = ( ' + str(value(model.X1)) + ' , ' + str(value(model.X2)) + ' )')\n", " print( 'f1 = ' + str(value(model.f1)) )\n", " print( 'f2 = ' + str(value(model.f2)) )\n", " f2_max = value(model.f2)\n", "\n", " # Maximizo f1 sujeto a que f2 no empeore\n", " model.O_f1.activate()\n", " model.O_f2.deactivate()\n", " model.C_epsilon = Constraint(expr = model.f2 >= f2_max)\n", " \n", " solver.solve(model)\n", "\n", " print('Segundo paso')\n", " print( '( X1 , X2 ) = ( ' + str(value(model.X1)) + ' , ' + str(value(model.X2)) + ' )')\n", " print( 'f1 = ' + str(value(model.f1)) )\n", " print( 'f2 = ' + str(value(model.f2)) )\n", "\n", " # Tomo el mínimo de f1 sobre el frente de Pareto\n", " f1_min = value(model.f1)\n", " # Elimino restricción que impide empeorar a f2 para volver \n", " # el modelo a su estado original\n", " model.del_component(model.C_epsilon)\n", "\n", " model.O_f1.activate()\n", "\n", " return f2_min, f2_max, f1_min, f1_max, solver" ], "metadata": { "id": "q1bdkb7dOj7T" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "model = cargarModelo_nl()\n", "f2_min, f2_max, f1_min, f1_max, solver = encontrarExtremosLexicographic(model)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "aC9uWQj9OqSO", "outputId": "94b1d777-efb1-4436-b584-4bf5b45fa28a" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Extremo 1\n", "Primer paso\n", "( X1 , X2 ) = ( 20.0 , 0.0 )\n", "f1 = 400.0\n", "f2 = 60.0\n", "Segundo paso\n", "( X1 , X2 ) = ( 20.0 , 25.0 )\n", "f1 = 399.999999999988\n", "f2 = 160.0000000000066\n", "Extremo 2\n", "Primer paso\n", "( X1 , X2 ) = ( 8.0 , 40.0 )\n", "f1 = 64.00000000000108\n", "f2 = 184.00000000000153\n", "Segundo paso\n", "( X1 , X2 ) = ( 8.0 , 40.0 )\n", "f1 = 64.00000000091299\n", "f2 = 183.99999999994532\n" ] } ] }, { "cell_type": "code", "source": [ "def applyNormalizedWeightingSum(model, f2_min, f2_max, f1_min, f1_max, solver, n):\n", "\n", " # Aplicar Programación por compromiso normalizada\n", "\n", " model.O_f1.deactivate()\n", " model.O_f2.deactivate()\n", "\n", " # Creo vectores de pesos\n", " model.w1 = Param(initialize=0, mutable=True, within = NonNegativeReals)\n", " model.w2 = Param(initialize=0, mutable=True, within = NonNegativeReals)\n", "\n", " # Creo nueva función objetivo en base a las sumas ponderadas\n", " model.O_f = Objective(expr= ( (f1_max - model.f1)/(f1_max - f1_min) ) * model.w1 + ( (f2_max - model.f2)/(f2_max - f2_min) ) * model.w2 , sense=minimize)\n", "\n", " # Genero el paso con el que variaré los pesos\n", " step = 1/n\n", "\n", " x1_l = []\n", " x2_l = []\n", " f1_l = []\n", " f2_l = []\n", "\n", " # Aplico el proceso iterativo para realizar la búsqueda de las n soluciones\n", " for i in range(n):\n", "\n", " # Varío los pesos\n", " model.w1 = i * step\n", " cte = i * step\n", " model.w2 = 1 - cte\n", "\n", " solver.solve(model)\n", "\n", " x1_l.append(value(model.X1))\n", " x2_l.append(value(model.X2)) \n", " f1_l.append(value(model.f1))\n", " f2_l.append(value(model.f2))\n", "\n", " print(\"Sol vars - it:\" + str(i) + \" x1= \" + str(x1_l[len(x1_l)-1]) + \" x2= \" + str(x2_l[len(x2_l)-1]))\n", " print(\"Sol FO - it:\" + str(i) + \" f1= \" + str(f1_l[len(f1_l)-1]) + \" f2= \" + str(f2_l[len(f2_l)-1]))\n", "\n", " # Para graficar el frente de Pareto hallado en el espacio de decisiones o variables\n", " plt.plot(x1_l,x2_l,'o-.')\n", " plt.plot(0,0,'x-.')\n", " plt.title('Normalized Weighted Sum Pareto-front Vars')\n", " plt.xlabel(\"X1\", fontsize = 10)\n", " plt.ylabel(\"X2\", fontsize = 10) \n", " plt.grid(True)\n", " plt.savefig(\"Normalized Weighted Sum - Vars\", dpi = 600, bbox_inches=\"tight\")\n", " plt.show()\n", " plt.close()\n", "\n", " # Para graficar el frente de Pareto hallado en el espacio de búsqueda o de objetivos\n", " plt.plot(f1_l,f2_l,'o-.')\n", " plt.plot(0,0,'x-.')\n", " plt.title('Normalized Weighted Sum Pareto-front FO')\n", " plt.xlabel(\"f1\", fontsize = 10)\n", " plt.ylabel(\"f2\", fontsize = 10) \n", " plt.grid(True)\n", " plt.savefig(\"Normalized Weighted Sum - FO\", dpi = 600, bbox_inches=\"tight\")\n", " plt.show()\n", " # Comando que permite descargar la imagen\n", " # files.download(\"Normalized Weighted Sum - FO.png\") \n", " plt.close()\n", "\n", " # Vuelvo el modelo a su estado original\n", " model.del_component(model.O_f)\n", " model.del_component(model.w1)\n", " model.del_component(model.w2)\n", " model.O_f1.activate()\n", " model.O_f2.activate()" ], "metadata": { "id": "0VzT0nzVovy6" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "model = cargarModelo()\n", "f2_min, f2_max, f1_min, f1_max, solver = encontrarExtremosLexicographic(model)\n", "n = 10\n", "applyNormalizedWeightingSum(model, f2_min, f2_max, f1_min, f1_max, solver, n)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 1000 }, "id": "0eA5fV_Do9mN", "outputId": "2fa545ff-b89b-4474-be6e-e71e0d8d0541" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Extremo 1\n", "Primer paso\n", "( X1 , X2 ) = ( 20.0 , 0.0 )\n", "f1 = 20.0\n", "f2 = 60.0\n", "Segundo paso\n", "( X1 , X2 ) = ( 20.0 , 25.0 )\n", "f1 = 20.0\n", "f2 = 160.0\n", "Extremo 2\n", "Primer paso\n", "( X1 , X2 ) = ( 8.0 , 40.0 )\n", "f1 = 8.0\n", "f2 = 184.0\n", "Segundo paso\n", "( X1 , X2 ) = ( 8.0 , 40.0 )\n", "f1 = 8.0\n", "f2 = 184.0\n", "Sol vars - it:0 x1= 8.0 x2= 40.0\n", "Sol FO - it:0 f1= 8.0 f2= 184.0\n", "Sol vars - it:1 x1= 8.0 x2= 40.0\n", "Sol FO - it:1 f1= 8.0 f2= 184.0\n", "Sol vars - it:2 x1= 8.0 x2= 40.0\n", "Sol FO - it:2 f1= 8.0 f2= 184.0\n", "Sol vars - it:3 x1= 8.0 x2= 40.0\n", "Sol FO - it:3 f1= 8.0 f2= 184.0\n", "Sol vars - it:4 x1= 8.0 x2= 40.0\n", "Sol FO - it:4 f1= 8.0 f2= 184.0\n", "Sol vars - it:5 x1= 20.0 x2= 25.0\n", "Sol FO - it:5 f1= 20.0 f2= 160.0\n", "Sol vars - it:6 x1= 20.0 x2= 25.0\n", "Sol FO - it:6 f1= 20.0 f2= 160.0\n", "Sol vars - it:7 x1= 20.0 x2= 25.0\n", "Sol FO - it:7 f1= 20.0 f2= 160.0\n", "Sol vars - it:8 x1= 20.0 x2= 25.0\n", "Sol FO - it:8 f1= 20.0 f2= 160.0\n", "Sol vars - it:9 x1= 20.0 x2= 25.0\n", "Sol FO - it:9 f1= 20.0 f2= 160.0\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": { "needs_background": "light" } }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": { "needs_background": "light" } } ] }, { "cell_type": "code", "source": [ "def applyNormalEpsilonConstraint(model, f2_min, f2_max, solver, n):\n", "\n", " # Aplico epsilon-restricciones normal\n", "\n", " model.O_f1.activate()\n", " model.O_f2.deactivate()\n", "\n", " # Creo el parámetro de epsilon y traslado al objetivo f2 a las restricciones.\n", " model.e = Param(initialize=0, mutable=True)\n", " model.C_epsilon = Constraint(expr = model.f2 >= model.e)\n", "\n", " # Creo el paso que uso para variar los epsilon\n", " step = (f2_max - f2_min) / n\n", "\n", " x1_l = []\n", " x2_l = []\n", " f1_l = []\n", " f2_l = []\n", "\n", " # Aplico el proceso iterativo para realizar la búsqueda de las n + 1 soluciones\n", " i = 0\n", " while i < n + 1:\n", "\n", " # Varío el valor de epsilon\n", " model.e = f2_min + i * step\n", " e_ = f2_min + i * step\n", "\n", " solver.solve(model)\n", "\n", " x1_l.append(value(model.X1))\n", " x2_l.append(value(model.X2))\n", " f1_l.append(value(model.f1))\n", " f2_l.append(value(model.f2))\n", "\n", " print(\"Epsilon \" + str(e_))\n", " print(\"Sol vars - it:\" + str(i) + \" x1= \" + str(x1_l[len(x1_l)-1]) + \" x2= \" + str(x2_l[len(x2_l)-1]))\n", " print(\"Sol FO - it:\" + str(i) + \" f1= \" + str(f1_l[len(f1_l)-1]) + \" f2= \" + str(f2_l[len(f2_l)-1]))\n", "\n", " i = i + 1\n", "\n", " # Para graficar el frente de Pareto hallado en el espacio de decisiones o variables\n", " plt.plot(x1_l,x2_l,'o-.')\n", " plt.plot(0,0,'x-.')\n", " plt.title('Normal epsilon-Constraint Pareto-front Vars')\n", " plt.xlabel(\"X1\", fontsize = 10)\n", " plt.ylabel(\"X2\", fontsize = 10) \n", " plt.grid(True)\n", " #plt.savefig(\"Normal epsilon-Constraint - Vars\", dpi = 600, bbox_inches=\"tight\")\n", " plt.show()\n", " plt.close()\n", "\n", " # Para graficar el frente de Pareto hallado en el espacio de búsqueda o de objetivos\n", " plt.plot(f1_l,f2_l,'o-.')\n", " plt.plot(0,0,'x-.')\n", " plt.title('Normal epsilon-Constraint Pareto-front FO')\n", " plt.xlabel(\"f1\", fontsize = 10)\n", " plt.ylabel(\"f2\", fontsize = 10) \n", " plt.grid(True)\n", " #plt.savefig(\"Normal epsilon-Constraint - FO\", dpi = 600, bbox_inches=\"tight\")\n", " #files.download(\"Normal epsilon-Constraint - FO.png\") \n", " plt.show()\n", " plt.close()\n", "\n", " # Vuelvo el modelo a su estado original\n", " model.del_component(model.C_epsilon)\n", " model.del_component(model.e)" ], "metadata": { "id": "jh9GRN9Tthv0" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [], "metadata": { "id": "92mLdoUmz_xM" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "model = cargarModelo_int()\n", "#model = cargarModelo_nl_int()\n", "f2_min, f2_max, f1_min, f1_max, solver = encontrarExtremosLexicographic(model)\n", "n = 100\n", "applyNormalEpsilonConstraint(model, f2_min, f2_max, solver, n)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 1000 }, "id": "11iuPyC7t0wV", "outputId": "5406fbf8-cf5a-4a26-e7dd-fb3669636449" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Extremo 1\n", "Primer paso\n", "( X1 , X2 ) = ( 20.0 , 0.0 )\n", "f1 = 20.0\n", "f2 = 60.0\n", "Segundo paso\n", "( X1 , X2 ) = ( 20.0 , 25.0 )\n", "f1 = 20.0\n", "f2 = 160.0\n", "Extremo 2\n", "Primer paso\n", "( X1 , X2 ) = ( 8.0 , 40.0 )\n", "f1 = 8.0\n", "f2 = 184.0\n", "Segundo paso\n", "( X1 , X2 ) = ( 8.0 , 40.0 )\n", "f1 = 8.0\n", "f2 = 184.0\n", "Epsilon 160.0\n", "Sol vars - it:0 x1= 20.0 x2= 25.0\n", "Sol FO - it:0 f1= 20.0 f2= 160.0\n", "Epsilon 160.24\n", "Sol vars - it:1 x1= 19.0 x2= 26.0\n", "Sol FO - it:1 f1= 19.0 f2= 161.0\n", "Epsilon 160.48\n", "Sol vars - it:2 x1= 19.0 x2= 26.0\n", "Sol FO - it:2 f1= 19.0 f2= 161.0\n", "Epsilon 160.72\n", "Sol vars - it:3 x1= 19.0 x2= 26.0\n", "Sol FO - it:3 f1= 19.0 f2= 161.0\n", "Epsilon 160.96\n", "Sol vars - it:4 x1= 19.0 x2= 26.0\n", "Sol FO - it:4 f1= 19.0 f2= 161.0\n", "Epsilon 161.2\n", "Sol vars - it:5 x1= 18.0 x2= 27.0\n", "Sol FO - it:5 f1= 18.0 f2= 162.0\n", "Epsilon 161.44\n", "Sol vars - it:6 x1= 18.0 x2= 27.0\n", "Sol FO - it:6 f1= 18.0 f2= 162.0\n", "Epsilon 161.68\n", "Sol vars - it:7 x1= 18.0 x2= 27.0\n", "Sol FO - it:7 f1= 18.0 f2= 162.0\n", "Epsilon 161.92\n", "Sol vars - it:8 x1= 18.0 x2= 27.0\n", "Sol FO - it:8 f1= 18.0 f2= 162.0\n", "Epsilon 162.16\n", "Sol vars - it:9 x1= 17.0 x2= 28.0\n", "Sol FO - it:9 f1= 17.0 f2= 163.0\n", "Epsilon 162.4\n", "Sol vars - it:10 x1= 17.0 x2= 28.0\n", "Sol FO - it:10 f1= 17.0 f2= 163.0\n", "Epsilon 162.64\n", "Sol vars - it:11 x1= 17.0 x2= 28.0\n", "Sol FO - it:11 f1= 17.0 f2= 163.0\n", "Epsilon 162.88\n", "Sol vars - it:12 x1= 17.0 x2= 28.0\n", "Sol FO - it:12 f1= 17.0 f2= 163.0\n", "Epsilon 163.12\n", "Sol vars - it:13 x1= 16.0 x2= 29.0\n", "Sol FO - it:13 f1= 16.0 f2= 164.0\n", "Epsilon 163.36\n", "Sol vars - it:14 x1= 16.0 x2= 29.0\n", "Sol FO - it:14 f1= 16.0 f2= 164.0\n", "Epsilon 163.6\n", "Sol vars - it:15 x1= 16.0 x2= 29.0\n", "Sol FO - it:15 f1= 16.0 f2= 164.0\n", "Epsilon 163.84\n", "Sol vars - it:16 x1= 16.0 x2= 29.0\n", "Sol FO - it:16 f1= 16.0 f2= 164.0\n", "Epsilon 164.08\n", "Sol vars - it:17 x1= 16.0 x2= 30.0\n", "Sol FO - it:17 f1= 16.0 f2= 168.0\n", "Epsilon 164.32\n", "Sol vars - it:18 x1= 16.0 x2= 30.0\n", "Sol FO - it:18 f1= 16.0 f2= 168.0\n", "Epsilon 164.56\n", "Sol vars - it:19 x1= 16.0 x2= 30.0\n", "Sol FO - it:19 f1= 16.0 f2= 168.0\n", "Epsilon 164.8\n", "Sol vars - it:20 x1= 16.0 x2= 30.0\n", "Sol FO - it:20 f1= 16.0 f2= 168.0\n", "Epsilon 165.04\n", "Sol vars - it:21 x1= 16.0 x2= 30.0\n", "Sol FO - it:21 f1= 16.0 f2= 168.0\n", "Epsilon 165.28\n", "Sol vars - it:22 x1= 16.0 x2= 30.0\n", "Sol FO - it:22 f1= 16.0 f2= 168.0\n", "Epsilon 165.52\n", "Sol vars - it:23 x1= 16.0 x2= 30.0\n", "Sol FO - it:23 f1= 16.0 f2= 168.0\n", "Epsilon 165.76\n", "Sol vars - it:24 x1= 16.0 x2= 30.0\n", "Sol FO - it:24 f1= 16.0 f2= 168.0\n", "Epsilon 166.0\n", "Sol vars - it:25 x1= 16.0 x2= 30.0\n", "Sol FO - it:25 f1= 16.0 f2= 168.0\n", "Epsilon 166.24\n", "Sol vars - it:26 x1= 16.0 x2= 30.0\n", "Sol FO - it:26 f1= 16.0 f2= 168.0\n", "Epsilon 166.48\n", "Sol vars - it:27 x1= 16.0 x2= 30.0\n", "Sol FO - it:27 f1= 16.0 f2= 168.0\n", "Epsilon 166.72\n", "Sol vars - it:28 x1= 16.0 x2= 30.0\n", "Sol FO - it:28 f1= 16.0 f2= 168.0\n", "Epsilon 166.96\n", "Sol vars - it:29 x1= 16.0 x2= 30.0\n", "Sol FO - it:29 f1= 16.0 f2= 168.0\n", "Epsilon 167.2\n", "Sol vars - it:30 x1= 16.0 x2= 30.0\n", "Sol FO - it:30 f1= 16.0 f2= 168.0\n", "Epsilon 167.44\n", "Sol vars - it:31 x1= 16.0 x2= 30.0\n", "Sol FO - it:31 f1= 16.0 f2= 168.0\n", "Epsilon 167.68\n", "Sol vars - it:32 x1= 16.0 x2= 30.0\n", "Sol FO - it:32 f1= 16.0 f2= 168.0\n", "Epsilon 167.92\n", "Sol vars - it:33 x1= 16.0 x2= 30.0\n", "Sol FO - it:33 f1= 16.0 f2= 168.0\n", "Epsilon 168.16\n", "Sol vars - it:34 x1= 15.0 x2= 31.0\n", "Sol FO - it:34 f1= 15.0 f2= 169.0\n", "Epsilon 168.4\n", "Sol vars - it:35 x1= 15.0 x2= 31.0\n", "Sol FO - it:35 f1= 15.0 f2= 169.0\n", "Epsilon 168.64\n", "Sol vars - it:36 x1= 15.0 x2= 31.0\n", "Sol FO - it:36 f1= 15.0 f2= 169.0\n", "Epsilon 168.88\n", "Sol vars - it:37 x1= 15.0 x2= 31.0\n", "Sol FO - it:37 f1= 15.0 f2= 169.0\n", "Epsilon 169.12\n", "Sol vars - it:38 x1= 14.0 x2= 32.0\n", "Sol FO - it:38 f1= 14.0 f2= 170.0\n", "Epsilon 169.36\n", "Sol vars - it:39 x1= 14.0 x2= 32.0\n", "Sol FO - it:39 f1= 14.0 f2= 170.0\n", "Epsilon 169.6\n", "Sol vars - it:40 x1= 14.0 x2= 32.0\n", "Sol FO - it:40 f1= 14.0 f2= 170.0\n", "Epsilon 169.84\n", "Sol vars - it:41 x1= 14.0 x2= 32.0\n", "Sol FO - it:41 f1= 14.0 f2= 170.0\n", "Epsilon 170.08\n", "Sol vars - it:42 x1= 13.0 x2= 33.0\n", "Sol FO - it:42 f1= 13.0 f2= 171.0\n", "Epsilon 170.32\n", "Sol vars - it:43 x1= 13.0 x2= 33.0\n", "Sol FO - it:43 f1= 13.0 f2= 171.0\n", "Epsilon 170.56\n", "Sol vars - it:44 x1= 13.0 x2= 33.0\n", "Sol FO - it:44 f1= 13.0 f2= 171.0\n", "Epsilon 170.8\n", "Sol vars - it:45 x1= 13.0 x2= 33.0\n", "Sol FO - it:45 f1= 13.0 f2= 171.0\n", "Epsilon 171.04\n", "Sol vars - it:46 x1= 12.0 x2= 34.0\n", "Sol FO - it:46 f1= 12.0 f2= 172.0\n", "Epsilon 171.28\n", "Sol vars - it:47 x1= 12.0 x2= 34.0\n", "Sol FO - it:47 f1= 12.0 f2= 172.0\n", "Epsilon 171.52\n", "Sol vars - it:48 x1= 12.0 x2= 34.0\n", "Sol FO - it:48 f1= 12.0 f2= 172.0\n", "Epsilon 171.76\n", "Sol vars - it:49 x1= 12.0 x2= 34.0\n", "Sol FO - it:49 f1= 12.0 f2= 172.0\n", "Epsilon 172.0\n", "Sol vars - it:50 x1= 12.0 x2= 35.0\n", "Sol FO - it:50 f1= 12.0 f2= 176.0\n", "Epsilon 172.24\n", "Sol vars - it:51 x1= 12.0 x2= 35.0\n", "Sol FO - it:51 f1= 12.0 f2= 176.0\n", "Epsilon 172.48\n", "Sol vars - it:52 x1= 12.0 x2= 35.0\n", "Sol FO - it:52 f1= 12.0 f2= 176.0\n", "Epsilon 172.72\n", "Sol vars - it:53 x1= 12.0 x2= 35.0\n", "Sol FO - it:53 f1= 12.0 f2= 176.0\n", "Epsilon 172.96\n", "Sol vars - it:54 x1= 12.0 x2= 35.0\n", "Sol FO - it:54 f1= 12.0 f2= 176.0\n", "Epsilon 173.2\n", "Sol vars - it:55 x1= 12.0 x2= 35.0\n", "Sol FO - it:55 f1= 12.0 f2= 176.0\n", "Epsilon 173.44\n", "Sol vars - it:56 x1= 12.0 x2= 35.0\n", "Sol FO - it:56 f1= 12.0 f2= 176.0\n", "Epsilon 173.68\n", "Sol vars - it:57 x1= 12.0 x2= 35.0\n", "Sol FO - it:57 f1= 12.0 f2= 176.0\n", "Epsilon 173.92\n", "Sol vars - it:58 x1= 12.0 x2= 35.0\n", "Sol FO - it:58 f1= 12.0 f2= 176.0\n", "Epsilon 174.16\n", "Sol vars - it:59 x1= 12.0 x2= 35.0\n", "Sol FO - it:59 f1= 12.0 f2= 176.0\n", "Epsilon 174.4\n", "Sol vars - it:60 x1= 12.0 x2= 35.0\n", "Sol FO - it:60 f1= 12.0 f2= 176.0\n", "Epsilon 174.64\n", "Sol vars - it:61 x1= 12.0 x2= 35.0\n", "Sol FO - it:61 f1= 12.0 f2= 176.0\n", "Epsilon 174.88\n", "Sol vars - it:62 x1= 12.0 x2= 35.0\n", "Sol FO - it:62 f1= 12.0 f2= 176.0\n", "Epsilon 175.12\n", "Sol vars - it:63 x1= 12.0 x2= 35.0\n", "Sol FO - it:63 f1= 12.0 f2= 176.0\n", "Epsilon 175.36\n", "Sol vars - it:64 x1= 12.0 x2= 35.0\n", "Sol FO - it:64 f1= 12.0 f2= 176.0\n", "Epsilon 175.6\n", "Sol vars - it:65 x1= 12.0 x2= 35.0\n", "Sol FO - it:65 f1= 12.0 f2= 176.0\n", "Epsilon 175.84\n", "Sol vars - it:66 x1= 12.0 x2= 35.0\n", "Sol FO - it:66 f1= 12.0 f2= 176.0\n", "Epsilon 176.07999999999998\n", "Sol vars - it:67 x1= 11.0 x2= 36.0\n", "Sol FO - it:67 f1= 11.0 f2= 177.0\n", "Epsilon 176.32\n", "Sol vars - it:68 x1= 11.0 x2= 36.0\n", "Sol FO - it:68 f1= 11.0 f2= 177.0\n", "Epsilon 176.56\n", "Sol vars - it:69 x1= 11.0 x2= 36.0\n", "Sol FO - it:69 f1= 11.0 f2= 177.0\n", "Epsilon 176.8\n", "Sol vars - it:70 x1= 11.0 x2= 36.0\n", "Sol FO - it:70 f1= 11.0 f2= 177.0\n", "Epsilon 177.04\n", "Sol vars - it:71 x1= 10.0 x2= 37.0\n", "Sol FO - it:71 f1= 10.0 f2= 178.0\n", "Epsilon 177.28\n", "Sol vars - it:72 x1= 10.0 x2= 37.0\n", "Sol FO - it:72 f1= 10.0 f2= 178.0\n", "Epsilon 177.52\n", "Sol vars - it:73 x1= 10.0 x2= 37.0\n", "Sol FO - it:73 f1= 10.0 f2= 178.0\n", "Epsilon 177.76\n", "Sol vars - it:74 x1= 10.0 x2= 37.0\n", "Sol FO - it:74 f1= 10.0 f2= 178.0\n", "Epsilon 178.0\n", "Sol vars - it:75 x1= 10.0 x2= 37.0\n", "Sol FO - it:75 f1= 10.0 f2= 178.0\n", "Epsilon 178.24\n", "Sol vars - it:76 x1= 9.0 x2= 38.0\n", "Sol FO - it:76 f1= 9.0 f2= 179.0\n", "Epsilon 178.48\n", "Sol vars - it:77 x1= 9.0 x2= 38.0\n", "Sol FO - it:77 f1= 9.0 f2= 179.0\n", "Epsilon 178.72\n", "Sol vars - it:78 x1= 9.0 x2= 38.0\n", "Sol FO - it:78 f1= 9.0 f2= 179.0\n", "Epsilon 178.96\n", "Sol vars - it:79 x1= 9.0 x2= 38.0\n", "Sol FO - it:79 f1= 9.0 f2= 179.0\n", "Epsilon 179.2\n", "Sol vars - it:80 x1= 8.0 x2= 39.0\n", "Sol FO - it:80 f1= 8.0 f2= 180.0\n", "Epsilon 179.44\n", "Sol vars - it:81 x1= 8.0 x2= 39.0\n", "Sol FO - it:81 f1= 8.0 f2= 180.0\n", "Epsilon 179.68\n", "Sol vars - it:82 x1= 8.0 x2= 39.0\n", "Sol FO - it:82 f1= 8.0 f2= 180.0\n", "Epsilon 179.92\n", "Sol vars - it:83 x1= 8.0 x2= 39.0\n", "Sol FO - it:83 f1= 8.0 f2= 180.0\n", "Epsilon 180.16\n", "Sol vars - it:84 x1= 8.0 x2= 40.0\n", "Sol FO - it:84 f1= 8.0 f2= 184.0\n", "Epsilon 180.4\n", "Sol vars - it:85 x1= 8.0 x2= 40.0\n", "Sol FO - it:85 f1= 8.0 f2= 184.0\n", "Epsilon 180.64\n", "Sol vars - it:86 x1= 8.0 x2= 40.0\n", "Sol FO - it:86 f1= 8.0 f2= 184.0\n", "Epsilon 180.88\n", "Sol vars - it:87 x1= 8.0 x2= 40.0\n", "Sol FO - it:87 f1= 8.0 f2= 184.0\n", "Epsilon 181.12\n", "Sol vars - it:88 x1= 8.0 x2= 40.0\n", "Sol FO - it:88 f1= 8.0 f2= 184.0\n", "Epsilon 181.36\n", "Sol vars - it:89 x1= 8.0 x2= 40.0\n", "Sol FO - it:89 f1= 8.0 f2= 184.0\n", "Epsilon 181.6\n", "Sol vars - it:90 x1= 8.0 x2= 40.0\n", "Sol FO - it:90 f1= 8.0 f2= 184.0\n", "Epsilon 181.84\n", "Sol vars - it:91 x1= 8.0 x2= 40.0\n", "Sol FO - it:91 f1= 8.0 f2= 184.0\n", "Epsilon 182.07999999999998\n", "Sol vars - it:92 x1= 8.0 x2= 40.0\n", "Sol FO - it:92 f1= 8.0 f2= 184.0\n", "Epsilon 182.32\n", "Sol vars - it:93 x1= 8.0 x2= 40.0\n", "Sol FO - it:93 f1= 8.0 f2= 184.0\n", "Epsilon 182.56\n", "Sol vars - it:94 x1= 8.0 x2= 40.0\n", "Sol FO - it:94 f1= 8.0 f2= 184.0\n", "Epsilon 182.8\n", "Sol vars - it:95 x1= 8.0 x2= 40.0\n", "Sol FO - it:95 f1= 8.0 f2= 184.0\n", "Epsilon 183.04\n", "Sol vars - it:96 x1= 8.0 x2= 40.0\n", "Sol FO - it:96 f1= 8.0 f2= 184.0\n", "Epsilon 183.28\n", "Sol vars - it:97 x1= 8.0 x2= 40.0\n", "Sol FO - it:97 f1= 8.0 f2= 184.0\n", "Epsilon 183.52\n", "Sol vars - it:98 x1= 8.0 x2= 40.0\n", "Sol FO - it:98 f1= 8.0 f2= 184.0\n", "Epsilon 183.76\n", "Sol vars - it:99 x1= 8.0 x2= 40.0\n", "Sol FO - it:99 f1= 8.0 f2= 184.0\n", "Epsilon 184.0\n", "Sol vars - it:100 x1= 8.0 x2= 40.0\n", "Sol FO - it:100 f1= 8.0 f2= 184.0\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEWCAYAAABhffzLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deZxU1Zn/8c8DDYI0q0DTIAoKURED2h00rt0oCmpc8ouOZsZIokEnY8ZETUKiGZkkTlwSTX7zixM1OpCMSRuNC2MARWxAE5eAQW1xQREXZFEBpRFle35/3NNYFFXVXd19q7r7ft+vV7367ufpe6ueOnXucszdERGR5OhU7ABERKSwlPhFRBJGiV9EJGGU+EVEEkaJX0QkYZT4RUQSRom/gzKz+WZ2YQHL28fM6s2sczHKbw/M7Bgze7nYcRSDmZWZ2UIz22hmPy92PEmnxN9MZrbCzNaaWY+UaRea2fwihlU07v6mu5e6+/a4yzKzrmY2zcyWmdmmcCzuMLNhMZY5zcz+pyXbcPfH3P2AJpZXZWZvN7LMdDPbEr5w15nZXDM7sCUxZilnspk93sLNTAHeA3q5++WtENYuwnvghCzzhpjZNjPbP8O8+8zsZ60dT1unxN8ynYFLW7oRi+hYNN09wGnAl4HewBhgMXB8sQIq4jG83t1Lgb2BtcD0fDdgZiWtHVQG+wJLPcsdo3HG4O4rgXnAeWll9gNOBmbks70C7a94ubtezXgBK4CpwDqgT5h2ITA/ZZkjgb8BH4S/R6bMmw9cA/wF2AyMABz4BrAM2Aj8GNgf+CvwIfBHoGtYvy/wIPAusD4M7522/QuzxN4pxP4a8H7Ybr8wb1iIYwrwDrAKuCJl3XHAohDPGuDGtPVK0ssP5V0FvEGUnH4L9E5b73zgTaJa4ZU59vsJYX8NzbHMYGBmODavAl9PmTct/L+/Dfv4BaAyZf73gJVh3stEXyYTgS3AVqAeeDbHMfwq8GJYfzlwUcq2q4C3095DVwDPhffIXUA3oEfY3o5QXj0wOMP/OR34Scr4KUB9GP4l8FY4TouBY9L2wT3A/4T5FxJ9gd4ejvdK4CdEFZuDgI+B7SGODWEbvcM+fDcc16uATlmOx/Sw77aEbZyQJYZmHTfgd2FfbQ7b/26GGL4MvJY27RvA38Nww+dhI7AUODNlucnhGN9E9Hn5STjWC8Jxew+4q9g5Ka/8VewA2usrfGhPAO5t+PCRkviBfkQJ+TygBDg3jO8V5s8nSnQHh/ldiBLgA0CvMP0ToprKfuGDthQ4P6y/F/B/gD2BnsDdwP0p8c0ne+K/FHiSqJa4B3AL8Icwb1iI4w9ECeiQ8OE+Icx/AjgvDJcCR6Stlynxfy18kPcL69wL/C5tvduA7kS190+Ag7LEfi2woJFjsxC4mSiJjg3xjw/zphElspOJEttPgSfDvAOIkuXglNj2T1nvf9LKyXQMTyH6sjbgOOAj4LCwfBW7J/6niRJeP6IvjIszLZvl/5zOp++9UuD3wGNh/J/Ce6QEuBxYDXRL+V+2AmcQfSl3B+4L74MewMAQ10Vh+cnA42ll/5bovdoz7KdXgAuaEmuOGJp13FI/jznK706UpI9OmfYE8K0wfFY4Dp2AfwA2AeUp//824Jthf3Yn+nxcGZbvlrrd9vAqegDt9cWniX90eEMNYNfEfx7wdNo6TwCTw/B84Edp8x04KmV8MfC9lPGfA7/IEs9YYH3K+HyyJ/4XgeNTxsvDh7CETxPxgSnzrwduD8MLgX8H+qdts2G9TIl/HvCNlGUPyFBe6q+Vp4FzssR+G1CT47gMJaqd9kyZ9lNgehieBjySMm8UsDkMjyD6RXIC0CVtu9PInPh/lC2WsMz9wKVhuIrdE/8/pe3nX2daNsu2pxMlww1EiX0m4Ysqw7LrgTEp/8vClHllRF+23VOmnQvUhuHJpCR+osS7BRiVMu0iUn7tZok1PfGnxtDs45b6eWxkf/0GuDUMjwz/w8Asyy4BTk/5/99Mm/9b4NbU9217eqlduYXcvY6omWVq2qzBRD+BU70BDEkZfyvDJtekDG/OMF4KYGZ7mtktZvaGmX1IlJD7NFxV04h9gfvMbIOZbSD6IthOlAAyxfZG+H8ALgA+A7xkZn8zs1ObUF76vniDKOmnlrc6ZfgjPv0/61Ne+xD91C5vpKx17r4xrbzU/Z5eVjczK3H3V4FvESWZtWZWY2aDyW2XY2hmk8zsyXCydQNRDbV/jvUz/t95+Jm793H3Qe5+mru/FuK4wsxeNLMPQhy90+JIjXtfol8rq1LeE7cQ1fwz6R+WTz+mQ0LZv045Zj/IEXtqDM0+bjm2n24GcJaZdSOqmD3k7mtDzF8xsyUp//9osu8vgO8S/ap72sxeMLOv5RFH0Snxt46rga+z65v0HaIPVKp9iNpPG3gLyrycqOZ8uLv3Ao4N060J674FTAoJo+HVzaOTYA2GpsX9DoC7L3P3c4mSwnXAPalXNmWRvi/2IfrpvCbz4p/y6EqhhtebwCPAODPbO0dZ/cysZ1p5K7Msn17e79396BCvE/2PkP1Y7ZxuZnsAfwJ+BpS5ex9gFk07Jlm3my8zO4YoMZ0N9A1xfJAWR+r23yKq8fdPeT/0cveDs8TyHtEvtvRjuhLA3S9OOWb/kSPU1O226LhliDGTx4nOH5xO1BQ2A8DM9iX6JXkJUVNsH6CO7PsLd1/t7l9398FEv3ZuNrMRTYy16JT4W0GoKd4F/GvK5FnAZ8zsy2ZWYmb/QPTz9MFWKrYn0S+ADeHqhKvzWPfXwDXhDY+ZDTCz09OW+WH4VXEw0QnLu8Ky/2RmA9x9B1ETA0Qn1nL5A/BtMxtuZqXAfxCdDNuWR8wAuPsjwFyiXywVYd/2NLOLzexr7v4W0cnwn5pZNzP7LNGvlEYvxTSzA8xsfEjgH/PpCVaIvqSGNXLlTleicybvAtvMbBJwYr7/Y0p5e5lZ72as25Poi/VdoMTM/o3ovFFG7r4KeBj4uZn1MrNOZra/mR2XEsveZtY1LL+d6ETrNWHf7wtcRhP2cY4Ymn3cUmLcr5EynKiJ5jqgD/C/YVYPosT+LoCZfZWoxp+VmZ2VUvlYH9Zv7HPQZijxt54fEb2BAHD394FTiWrm7xPVwE519/daqbxfEJ1keo/oRO2cPNb9JVF78MNmtjGsf3jaMguITsjOI2pOeDhMnwi8YGb1YTvnuPvmRsq7g+jKi4XA60RJ9Zt5xJvuS0RfrHcR1WTrgEqiXwMQtU8PI6pF3gdcHb4wGrMH0cnj94iaFQYC3w/z7g5/3zezZzKtHJop/pUoKa4nupJkZh7/V+q2XiL6wlwemh8aa3JK9RDR++EVouaSj8ncrJjqK0RfXEuJYr+HT5vUHiW6ima1mTW8f79JdAJ0OVFN+vdEx7klmnvcIDofcFXYV1fkWO63RL8k7nL3TwDcfSnR+bMniL5ADiG6iieXzwFPhc/BTKLzOMubGGvRWThRIQKARTdBvU50cjPvGrmItH2q8YuIJIwSv4hIwqipR0QkYVTjFxFJmHbxsKH+/fv7sGHDmrXupk2b6NGjscvMC09x5Udx5Udx5aetxgUti23x4sXvufuA3WYU+9bhprwqKiq8uWpra5u9bpwUV34UV34UV37aalzuLYsNWOR6ZIOIiCjxi4gkjBK/iEjCKPGLiCSMEr+ISMLEfjlneD78ImClu59qZsOBGqLegRYT9ea0Je44pGMaNvXPu01bce0pRYhEpP0oRI3/UqKOPhpcB9zk7iOIngJ4QQFikA4oU9LPNV1EIrEm/vC86lOIujzDzAwYT/TIV4g6QjgjzhhERGRXsT6rx8zuIXpOdk/gCqK+K58MtX3MbCgw29136/TAzKYAUwDKysoqampqmhVDfX09paX59mYXP8WVn0xxTZ6zKevy0ycW5i7M9rS/2gLFlb+WxFZdXb3Y3SvTp8fWxh/6Yl3r7ovNrCrf9d39VqLOjKmsrPSqqrw3AcD8+fNp7rpxUlz5yRjXnOxNOoX6H9rV/moDFFf+4ogtzpO7RwGnmdnJQDeirt9+SdQheIlHnXzsTdP71BQRkVYQWxu/u3/f3fd292HAOcCj7v6PQC1R13kA5wMPxBWDdGwjB2Zuzsk2XUQixbiO/3vAZWb2KtElnbcXIQbpAJatzdzGn226iEQK8lhmd58PzA/Dy4FxhShXkmvlhs0M6dO92GGItEnt4nn8Ivk66tpHGbN3byaOLmfS6EEM66/mH5EGSvzSbo0c2CNjs86+/bpzzrh9mVO3iuvmvMR1c17iwEE9mTS6nC+MKWe/AdGlcRNunL/L+iMH9mDuZVWFCl+kaPSsHmm35l5WtduJ3JEDe7Dgu+P556r9eeCSo/nL1PH88NRR9OxWwi/mvcLMZ98B4ISfz9/tS2PZ2k1MuHF+ocIXKRrV+KVda6yGPqRPdy44ejgXHD2ctR9+TKdOBsCr7+rEsCSXavySGAN7daN/6R6NLvfk8vfZviO+O9pFik01fpE059z6JP1Lu3LiwYOYNHoQR+y3F106q44kHYcSvyRSthPD+/ffk2+feACz61Zz/99X8vun3qR39y5MGFXGmYcO4agR/QE4/Jq5rNkYniY+58+U9ezKU1dOKOS/INJsSvySSHMvq8p5Vc+pnx3Mx1u3s/CVd5lTt5qHXljNHiWdOGpE/12TfrBm4xYOv2aukr+0C0r8kliNnRju1qUzJx48iBMPHsSWbTvY9Mk2gN2SfoNs00XaGjVcijRB15JO9O3RtdHl7l70Fhs+0heAtG2q8Yu0ou/c8xwlnYzP778XE0cP4sRRgxjQs/EriUQKSYlfJE9lPbtmbNYp69mVW7/yOWbXrWZO3SquvK+OH95fx+eG9eOMQ4dw7rh9di6ru4almNTUI5Knp66cQFnPXZt9Gq7qGTO0D1MnHUjtFVXMvvQYLhk/kvUfbaH2pbU7lx13zVzdNSxFpRq/SDM0XL2TrXckM+Og8l4cVN6LyyZ8hs1btgOw5sOPWZvlJLDuGpZCUY1fpAC6d+0MQFmvbjmXe3HVh8TZD7YIqMYv0qZM+uVjDNtrz52Pk/7s3r0xs2KHJR1MnJ2tdwMWAnuEcu5x96vNbDpwHPBBWHSyuy+JKw6RtibbXcPD9+rO148dwey6VfzmseX8esFrDOnTnZMPGcT3Jx208wFzw6bu3sn8imtPiT1u6TjirPF/Aox393oz6wI8bmazw7zvuPs9MZYt0mY1dtfwlw/fhw0fbWHu0jXMqVvN8ys/yJn0G6Yr+UtTxZb4PWqorA+jXcJLjZciNH7XcJ89u3JW5VDOqhzKjvCk0E+2bS9AZJIEFueJJDPrDCwGRgC/cvfvhaaezxP9IpgHTHX3TzKsOwWYAlBWVlZRU1PTrBjq6+spLS1t3j8QI8WVH8UVmTwn+5U/0yd+2imN9ld+2mpc0LLYqqurF7t7Zfr0WBP/zkLM+gD3Ad8E3gdWA12BW4HX3P1HudavrKz0RYsWNavsbJfbFZviyo/iimRr6oFd2/m1v/LTVuOClsVmZhkTf0Eu53T3DUAtMNHdV3nkE+C/gXGFiEFERCKxJX4zGxBq+phZd2AC8JKZlYdpBpwB1MUVg0hHk97HcGPTRTKJ86qecmBGaOfvBPzR3R80s0fNbABgwBLg4hhjEOlQst3dq7t+JR9xXtXzHHBohunj4ypTJMn+tPhtThhVRu/uXYodirRxemSDSAdx+d3P8vTr6wD4cIvzfv1uF8uJAHpkg0i7ku2u35EDenD9WWM4qLwXAPPe2MrlC+ax6KoJ9O7eha3bd9Clcyc9DloA1fhF2pW5l1XtdiJ35MAezL28ikP36Uu3LtHD4MaVl/Dvp43e2exz4YxFHHDln/U4aAFU4xdpd5pSQx9S2omqwz/t+OXw/fqx4JV3My6rE8PJoxq/SAJ8o2pEzvm/eOQVVrynL4CkUOIXEX45bxl/fe19ADZ8tIW6lR+oX4AOTE09IgmR9cTwwB7ceeEROzuLefC5VVx1fx0Pf/tYPlPWkw8/3kpp1xJO+sUCnRjuIFTjF0mIrCeGL6tiYK9u9OwWnQg+5ZByfnnOWEYOjB4MNm3mC+z/g1k6MdyBqMYvkiBNqaH37dGV08cO2Tl+4qgy7n1mZcZldWK4fVKNX0Rymji6POf8y//4LE8tf79A0UhrUOIXkRZ5eOlqnlwe3TH88dbtzH5+FR9t2VbkqCQXNfWISKNynRj+878ey5btOwB4bNl7/POdz/C7C8ZxzMgBrNu0hS6djS/e/JdP15/zZ50YLjLV+EWkUblODHct6UTpHlEdsvqAAfz+wsM5Yr+9ALhl4WscMu1hnRhuY1TjF5EmaUoNvaRzJ44c0X/n+Bc+O5hbFizPuKxODBePavwiEpvRQ3rnnH/2LU9wz+K3CxSNNFDiF5Gi2fDRFpa8tR6AHTucGX9dwaoPNhc5qo4vtqYeM+sGLAT2COXc4+5Xm9lwoAbYC1gMnOfuW+KKQ0SKK9eJ4Ye/fRxbtkUnhl9avZGrZ75Az24lfPGwvVm3aQvrNm1hxMDSjJ3Mp3YuL/mJs8b/CTDe3ccAY4GJZnYEcB1wk7uPANYDF8QYg4gUWa4TwwBdS6I0NGpwLx77bjUnHTwIgHufeZsTblyQMekDWadL4+LsetGB+jDaJbwcGA98OUyfAUwD/iuuOESk+BqS/Pz586mqqsq63NB+e+4c/sKYwZR0Mqb979KYo0sei/MJfKGj9cXACOBXwA3Ak6G2j5kNBWa7++gM604BpgCUlZVV1NTUNCuG+vp6SktLm/cPxEhx5Udx5acjxTV5Tvarf6ZP7JF1Xj7a6v6ClsVWXV292N0r06fHejmnu28HxppZH+A+4MA81r0VuBWgsrLSc9UScmmshlEsiis/iis/HSquOdmbdFrrf2yr+wviia0gV/W4+wagFvg80MfMGr5w9gYyP/1JRERiEVviN7MBoaaPmXUHJgAvEn0BfCksdj7wQFwxiEj7l35iuLHp0rg4m3rKgRmhnb8T8Ed3f9DMlgI1ZvYT4O/A7THGICLtXLY7fHXnb/PFeVXPc8ChGaYvB8bFVa6IJI+7Y2bFDqPd0LN6RKRd277DmXDTAj47pDcTR5dz3GcG7OxGUjJT4heRNi3Xnb8A9Z9so3Lfvjy8dA33L3mH7l06U33gACaOLmf8gQM581ePq6/gNEr8ItKmzb2sigk3zs+avHt378L1XxrDf2zfwVOvr2PW86t46IU1zHp+dcbtNTwSOsnJX4lfRNq8pj4S+qgR/TlqRH9+dPpoFr+xnrNveSLjskk/Maync4pIh9O5kzFueL+cy2wNvYZ9vHV7IUJqU1TjF5FE6tI5qveeefNf2bp5M692Xs5JBw/a5XlBuZqY2jPV+EWkw2rs5q/tO5yTRw9iy3b4yZ9f5Jjra/nCfz7Or2pf5bjrH+2wXUaqxi8iHVZjJ4Y7dzK+efxIDum8kuGHfI45dauZXbeaGx56Oes2O8L5ASV+EenQmto0s+9ePbjouP256Lj9eWfDZo689tGsy7b3G8bU1CMikmZwn+4557+/Keo0cN2mLezYEd+j7eOiGr+ISAbZbhwb3GsP+pfuAcClNX/nlTUbmXjwICaOLmfc8H507hT9EmjLJ4ZV4xcRySBbl5F//cEJO8fPrhzK2KF9qPnbW5x725OMu+YRvn/vcxz500fa9Ilh1fhFRLJorIb+hTGD+cKYwXy0ZRvzX36XWc+vYuaSd9i0JfO9AW3lxLASv4hIC+3ZtYSTDynn5EPK+Xjrdg784Zysy27esr3oD5FTU4+ISCvq1iV3Un9z3UcArPpgMx9+vLUQIe0mzh64hppZrZktNbMXzOzSMH2ama00syXhdXJcMYiIFEO2G8f27rMHnymLOk6/Yc7LVP74Eb7630/zx0VvsT5cKdTg/r+v5KhrH2XynE0cde2j3P/31uulNs6mnm3A5e7+jJn1BBab2dww7yZ3/1mMZYuIFE1jN44BfOXIYfTt0ZU5daupffk5OncyPr/fXkwcPYgd7vx01ktsDs8RWrlhM9+/93kAzjh0SIvji7MHrlXAqjC80cxeBFoesYhIO9DYieGxQ/swdmgfrjrlIJ5f+QGz61Yzp241V91fl3H5zVu3c8NDL7dK4jf3+G8+MLNhwEJgNHAZMBn4EFhE9KtgfYZ1pgBTAMrKyipqamqaVXZ9fT2lpaXNWjdOiis/iis/iis/bSUud+fteueHf9mcdZnpE5veyXx1dfVid69Mnx574jezUmABcI2732tmZcB7gAM/Bsrd/Wu5tlFZWemLFi1qVvnz58+nqqqqWevGSXHlR3HlR3Hlp63FddS1j7Jyw+7Jf0if7vxl6vgmb8fMMib+WK/qMbMuwJ+AO939XgB3X+Pu2919B3Ab6nhdRGQX3znpALqnXR3UvUtnvnPSAa2y/dja+C16gtHtwIvufmPK9PLQ/g9wJpC5QUtEJKEa2vFveOhlVm7YzJA+3fnOSQe0Svs+xHtVz1HAecDzZrYkTPsBcK6ZjSVq6lkBXBRjDCIi7dIZhw7hjEOHxNIMFedVPY8DmZ5bOiuuMkVEpHG6c1dEJGGU+EVEEkaJX0QkYZT4RUQSRolfRCRhlPhFRBJGiV9EJGGU+EVEEkaJX0QkYZT4RUQSRolfRCRhlPhFRBJGiV9EJGGU+EVEEkaJX0QkYZT4RUQSJmfiN7NeZrZ/humfbWzDZjbUzGrNbKmZvWBml4bp/cxsrpktC3/7Nj98ERHJV9bEb2ZnAy8BfwqJ+3Mps6c3YdvbgMvdfRRwBPAvZjYKmArMc/eRwLwwLiIiBZKrxv8DoMLdxwJfBX5nZmeGeZm6VNyFu69y92fC8EbgRWAIcDowIyw2AzijmbGLiEgzmLtnnmH2vLsfkjJeDjxIlKwnu/thTS7EbBiwEBgNvOnufcJ0A9Y3jKetMwWYAlBWVlZRU1PT1OJ2UV9fT2lpabPWjZPiyo/iyo/iyk9bjQtaFlt1dfVid6/cbYa7Z3wBfwX2T5vWk6h55pNs62XYTimwGPhiGN+QNn99Y9uoqKjw5qqtrW32unFSXPlRXPlRXPlpq3G5tyw2YJFnyKm5mnouJq1Jx6Mmm4nANU35tjGzLsCfgDvd/d4weU349dDwK2JtU7YlIiKtI1fivx/4opl1bphgZmXAfwOnNbbh0IxzO/Ciu9+YMmsmcH4YPh94IN+gRUSk+XIl/gpgP2CJmY0Pl2M+DTwBjGvCto8CzgPGm9mS8DoZuBaYYGbLgBPCuIiIFEhJthnuvh64OCT8R4B3gCPc/e2mbNjdHyf71T/H5xuoiIi0jlzX8fcxs1uILuWcCNwDzDaz8YUKTkREWl/WGj/wDHAz8C/uvg142MzGAjeb2Rvufm5BIhQRkVaVK/Efm96s4+5LgCPN7OvxhiUiInHJ2tSTqy3f3W+LJxwREYmbns4pIpIwSvwiIgmjxC8ikjBK/CIiCaPELyKSMEr8IiIJo8QvIpIwSvwiIgmjxC8ikjBK/CIiCaPELyKSMEr8IiIJE1viN7M7zGytmdWlTJtmZivTeuQSEZECirPGP52oA5d0N7n72PCaFWP5IiKSQWyJ390XAuvi2r6IiDSPuXt8GzcbBjzo7qPD+DRgMvAhsAi4PPTtm2ndKcAUgLKysoqamppmxVBfX09paWmz1o2T4sqP4sqP4spPW40LWhZbdXX1Ynev3G2Gu8f2AoYBdSnjZUBnol8a1wB3NGU7FRUV3ly1tbXNXjdOiis/iis/iis/bTUu95bFBizyDDm1oFf1uPsad9/u7juA24BxhSxfREQKfDmnmZWnjJ4J1GVbVkRE4pGrs/UWMbM/AFVAfzN7G7gaqDKzsYADK4CL4ipfREQyiy3xu/u5GSbfHld5IiLSNLpzV0QkYZT4RUQSRolfRCRhlPhFRBJGiV9EJGGU+EVEEkaJX0QkYZT4RUQSRolfRCRhlPhFRBJGiV9EJGGU+EVEEkaJX0QkYZT4RUQSRolfRCRhYkv8ZnaHma01s7qUaf3MbK6ZLQt/+8ZVvoiIZBZnjX86MDFt2lRgnruPBOaFcRERKaDYEr+7LwTWpU0+HZgRhmcAZ8RVvoiIZGbuHt/GzYYBD7r76DC+wd37hGED1jeMZ1h3CjAFoKysrKKmpqZZMdTX11NaWtqsdeOkuPKjuPKjuPLTVuOClsVWXV292N0rd5vh7rG9gGFAXcr4hrT565uynYqKCm+u2traZq8bJ8WVH8WVH8WVn7Yal3vLYgMWeYacWuiretaYWTlA+Lu2wOWLiCReoRP/TOD8MHw+8ECByxcRSbw4L+f8A/AEcICZvW1mFwDXAhPMbBlwQhgXEZECKolrw+5+bpZZx8dVpoiINE537oqIJIwSv4hIwijxi4gkjBK/iEjCKPGLiCSMEr+ISMIo8YuIJIwSv4hIwijxi4gkjBK/iEjCKPGLiCSMEr+ISMIo8YuIJIwSv4hIwijxi4gkjBK/iEjCxNYRSy5mtgLYCGwHtnmmXuBFRCQWRUn8QbW7v1fE8kVEEklNPSIiCWPuXvhCzV4H1gMO3OLut2ZYZgowBaCsrKyipqamWWXV19dTWlragmjjobjyo7jyo7jy01bjgpbFVl1dvThjU7q7F/wFDAl/BwLPAsfmWr6iosKbq7a2ttnrxklx5Udx5Udx5aetxuXestiARZ4hpxalqcfdV4a/a4H7gHHFiENEJIkKnvjNrIeZ9WwYBk4E6godh4hIUhXjqp4y4D4zayj/9+4+pwhxiIgkUsETv7svB8YUulwREYnock4RkYRR4hcRSRglfhGRhFHiFxFJGCV+EZGEUeIXEUkYJX4RkYRR4hcRSRglfhGRhFHiFxFJGCV+EZGEUeIXEUkYJX4RkYRR4hcRSRglfhGRhFHiFxFJmKIkfjObaGYvm9mrZja11Qt4/Bfw+sJdp72+MJouIpJwxehztzPwK2ASMAo418xGtWohQw6Duyd/mvxfXxiNDzmsVYsREWmPitHn7jjg1dAFI2ZWA5wOLG21EoYfC2dNh7snM2zA8fD0vGh8+LGtVoSISHtl7l7YAs2+BEx09wvD+HnA4UdvSWUAAAcMSURBVO5+SdpyU4ApAGVlZRU1NTV5lzXs9TsZ9sYfWbHv2awY/o8tD74V1dfXU1paWuwwdqO48qO48qO48teS2Kqrqxe7e+VuM9y9oC/gS8BvUsbPA/5frnUqKio8b8sXuF833F+/40L364ZH421IbW1tsUPISHHlR3HlR3HlryWxAYs8Q04txsndlcDQlPG9w7TW09Cmf9b0qKYfmn12O+ErIpJAxUj8fwNGmtlwM+sKnAPMbNUSVj6za5t+Q5v/ymdatRgRkfao4Cd33X2bmV0CPAR0Bu5w9xdatZCjv7X7tOHH6uSuiAjFuaoHd58FzCpG2SIiSac7d0VEEkaJX0QkYZT4RUQSRolfRCRhCn7nbnOY2bvAG81cvT/wXiuG01oUV34UV34UV37aalzQstj2dfcB6RPbReJvCTNb5JluWS4yxZUfxZUfxZWfthoXxBObmnpERBJGiV9EJGGSkPhvLXYAWSiu/Ciu/Ciu/LTVuCCG2Dp8G7+IiOwqCTV+ERFJocQvIpIwHSbxN9aBu5ntYWZ3hflPmdmwAsQ01MxqzWypmb1gZpdmWKbKzD4wsyXh9W9xxxXKXWFmz4cyF2WYb2b2f8P+es7MYu+w2MwOSNkPS8zsQzP7VtoyBdlfZnaHma01s7qUaf3MbK6ZLQt/+2ZZ9/ywzDIzO78Acd1gZi+F43SfmfXJsm7OYx5DXNPMbGXKsTo5y7o5P7sxxHVXSkwrzGxJlnXj3F8Zc0PB3mOZemdpby+ixzu/BuwHdAWeBUalLfMN4Ndh+BzgrgLEVQ4cFoZ7Aq9kiKsKeLAI+2wF0D/H/JOB2YABRwBPFeGYria6AaXg+ws4FjgMqEuZdj0wNQxPBa7LsF4/YHn42zcM9405rhOBkjB8Xaa4mnLMY4hrGnBFE45zzs9ua8eVNv/nwL8VYX9lzA2Feo91lBr/zg7c3X0L0NCBe6rTgRlh+B7geDOzOINy91Xu/kwY3gi8CAyJs8xWdDrwW488CfQxs/ICln888Jq7N/eO7RZx94XAurTJqe+hGcAZGVY9CZjr7uvcfT0wF5gYZ1zu/rC7bwujTxL1aldQWfZXUzTlsxtLXOHzfzbwh9Yqr6ly5IaCvMc6SuIfAryVMv42uyfYncuED8kHwF4FiQ4ITUuHAk9lmP15M3vWzGab2cEFCsmBh81ssUUd26dryj6N0zlk/0AWY38BlLn7qjC8GijLsEyx99vXiH6pZdLYMY/DJaEJ6o4szRbF3F/HAGvcfVmW+QXZX2m5oSDvsY6S+Ns0MysF/gR8y90/TJv9DFFzxhjgP4H7CxTW0e5+GDAJ+BczazPdk1nUJedpwN0ZZhdrf+3Co9/cbepaaDO7EtgG3JllkUIf8/8C9gfGAquImlXaknPJXduPfX/lyg1xvsc6SuJvSgfuO5cxsxKgN/B+3IGZWReiA3unu9+bPt/dP3T3+jA8C+hiZv3jjsvdV4a/a4H7iH5yp2rKPo3LJOAZd1+TPqNY+ytY09DcFf6uzbBMUfabmU0GTgX+MSSM3TThmLcqd1/j7tvdfQdwW5byirW/SoAvAndlWybu/ZUlNxTkPdZREn9TOnCfCTSc/f4S8Gi2D0hrCW2ItwMvuvuNWZYZ1HCuwczGER2TWL+QzKyHmfVsGCY6OViXtthM4CsWOQL4IOUnaNyy1sSKsb9SpL6HzgceyLDMQ8CJZtY3NG2cGKbFxswmAt8FTnP3j7Is05Rj3tpxpZ4TOjNLeU357MbhBOAld38708y491eO3FCY91gcZ6yL8SK6CuUVoisErgzTfkT0YQDoRtR08CrwNLBfAWI6muin2nPAkvA6GbgYuDgscwnwAtHVDE8CRxYgrv1Cec+Gshv2V2pcBvwq7M/ngcoCHcceRIm8d8q0gu8voi+eVcBWojbUC4jOCc0DlgGPAP3CspXAb1LW/Vp4n70KfLUAcb1K1Obb8B5ruHptMDAr1zGPOa7fhffOc0QJrTw9rjC+22c3zrjC9OkN76mUZQu5v7LlhoK8x/TIBhGRhOkoTT0iItJESvwiIgmjxC8ikjBK/CIiCaPELyKSMEr8Ik0Qnqb4upn1C+N9w/gwM5tjZhvM7MFixynSFEr8Ik3g7m8RPYLg2jDpWuBWd18B3ACcV6TQRPKmxC/SdDcBR1jUR8DRwM8A3H0esLGYgYnko6TYAYi0F+6+1cy+A8wBTnT3rcWOSaQ5VOMXyc8kokcAjC52ICLNpcQv0kRmNhaYQNQj2bcL3DGNSKtR4hdpgvA0xf8iem76m0QndH9W3KhEmkeJX6Rpvg686e5zw/jNwEFmdpyZPUb05NfjzextMzupaFGKNIGezikikjCq8YuIJIwSv4hIwijxi4gkjBK/iEjCKPGLiCSMEr+ISMIo8YuIJMz/B4KIdF9NCtrzAAAAAElFTkSuQmCC\n" }, "metadata": { "needs_background": "light" } }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEWCAYAAACJ0YulAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3de5xcdX3/8dc7yea6IUsIbiFEEmik3CqyKVoLNCuoAa0gtQhVBBUjP4vKT1DxUqG2tN5Aa7WKSBpRywblIsWABNwQsEZIIEC4JoRECCEhJJtkk4Vskk//OGcPk8nM7s7uzsxm9/18POaxc77n9tlzZs57zm1GEYGZmRnAkGoXYGZm/YdDwczMMg4FMzPLOBTMzCzjUDAzs4xDwczMMg4FQ9J8SedXcH6vl9QqaWg15r83kHSCpKeqXUc1SKqXtEDSFklXVruewcahUAGSVkpaJ2lMTtv5kuZXsayqiYg/RkRtROws97wkDZd0uaRlkram62KWpMllnOflkn7Wm2lExL0RcVg35zdd0vNdDDNb0vY0jDdImifpz3pTY5H5nCfpvl5OZiawHtgnIi7ug7J2k74GTu6k/3RJu9Jl1fH4n5z+R0i6VdKmNLiaJb21r+usFodC5QwFPt3biSjh9dZ9vwTeA/w9MA54I7AYOKlaBVVxHX4jImqBg4B1wOxSJyBpWF8XVcDBwONR5M7aCtXwQvrBpePxN+m8DwV+BzwKTAEOBG4G7pT0lxWoq/wiwo8yP4CVwKXABqAubTsfmJ8zzFuBB4BN6d+35vSbD1xB8mJsA/4UCOATwDJgC/DPwKHA/wKbgRuA4en4+wK3AS8BG9PnB+VN//witQ9Ja38GeDmd7vi03+S0jpnAC8Aa4JKccY8DFqX1rAWuyhtvWP780/l9GVhFsuG6DhiXN965wB9JPk1+qZPlfnK6vCZ1MsyBwK3pulkOfCyn3+Xp/3tduowfA6bl9P88sDrt9xRJ0MwAtgPtQCvwcCfr8MPAE+n4K4CP50x7OvB83mvoEuCR9DUyBxgJjEmntyudXytwYIH/czbwLznd7wJa0+f/DjyXrqfFwAl5y+CXwM/S/ueThOu16fpeDfwLyYeew4FXgJ1pHS3pNMaly/CldL1+GRhSZH3MTpfd9nQaJxepoUfrDfhpuqza0ul/rkANuy37vH4/BeYWaP8BsKDa25o+2V5Vu4DB8Ejf0CcDN3W8MckJBWA8ycb6HGAYcHbavV/afz7JRvDItH8NycbxV8A+afurwN3AIemb8HHg3HT8/YC/BUYDY4FfALfk1Def4qHwaWAhyafLEcDVwPVpv8lpHdeTbJyOTt/4J6f9fw+ckz6vBd6SN16hUPhI+iY/JB3nJuCneeNdA4wi+dT/KnB4kdq/BtzTxbpZAPwnyQb2mLT+t6X9LifZyJ1KstH7N2Bh2u8wkg3pgTm1HZoz3s/y5lNoHb6LJMgF/DWwDTg2HX46e4bC/SQbw/EkYXJBoWGL/J+zee21Vwv8N3Bv2v3B9DUyDLgYeBEYmfO/tAOnkwT2KJJPxlen6/x1aV0fT4c/D7gvb97XkbxWx6bL6Wngo92ptZMaerTect+Pncy/6PJMl82HC7Q3koThqGpvb3r78GGIyvoK8ElJ++e1vwtYFhE/jYgdEXE98CTwNznDzI6Ix9L+7WnbNyJic0Q8BiwF7oyIFRGxCbgdeBNARLwcETdGxLaI2ELyifWvu1nzBSSfxp+PiFdJ3nDvy9uF/6eI2BoRjwL/RRJqkLyR/1TShIhojYiF3ZjfB0j2KFZERCvwBeCsAvNri4iHgYdJwqGQ/Ug+zRYkaRLwV8DnI+KViFgC/Bj4UM5g90XE3EjOf/w0Z147SULyCEk1EbEyIp7p4n/bbR1GxK8j4plI3APcCZzQyfjfjYgXImID8D8kG8NSXCKphSR0a0k24ETEz9LXyI6IuDL9v3LPZ/w+Im6JiF0kH0JOBS5K1/k64NvAWYVmmF5McBbwhYjYEhErgStJPgCVIreGCfR8vXXXgZJach5npu0TKPyaWkMSWONLnE+/41CooIhYSnLo5tK8XgeS7FbnWgVMzOl+rsAk1+Y8byvQXQsgabSkqyWtkrSZ5FNWXcfVP104GLi5481B8gl1J1BfpLZV6f8D8FHgDcCTkh6Q9O5uzC9/Wawi+QSbO78Xc55v47X/M/fE4OtJDncd0MW8NqRBmTu/3OWeP6+RkoZFxHLgIpKQXCepSdKBdG63dSjpFEkL0xO/LSQb2wmdjF/w/y7BtyKiLiL+JCLe0xFiki6R9ER64rSFZE8zt47cug8m2ctZk/OauJpkj6GQCenw+et0YjrvH+assy92UntuDT1eb51MP98L6bLqeNyQtq+n8GvqAJLDUhtLmEe/5FCovMuAj7H7C/gFkjdbrteTHK/t0Juvs72Y5JPfmyNiH+DEtF3dGPc54JS8N8jIiMitbVJe3S8ARMSyiDibZIPxdeCXuVdgFZG/LF4P7GD3wCsodj8x+EfgLuA4SQd1Mq/xksbmzW91keHz5/ffEXF8Wm+Q/I9QfF1l7ZJGADcC3wLqI6IOmEv31knR6ZZK0gnA54AzgX3TOjbl1ZE7/edIDtlNyHk97BMRRxapZT3JHmP+Ol0NEBEX5Kyzf+2k1Nzp9mq9FaixFHcBf1eg/UySvZltvZh2v+BQqLD0E+Yc4FM5zXOBN0j6e0nDJL0fOIJkr6IvjCXZc2iRNJ4kmLrrh8AVkg4GkLS/pNPyhvnHdG/kSJKTp3PSYT8oaf90l78lHXZXF/O7Hvj/kqZIqgX+FZgTETtKqBmAiLgLmEeyp9OQLtuxki6Q9JGIeI7kxPy/SRop6c9J9m66vJxU0mGS3pZu3F/htZO9kATY5C6uMBpOcpjmJWCHpFOAd5T6P+bMbz9J43ow7liS0H0JGCbpKySHiAqKiDUkh7mulLSPpCGSDpXUcThyLXCQpOHp8DtJTvpekS77g4HP0I1l3EkNPV5vOTUe0sPZ/xPwVklXSBqf/k+fJDl09fkeTrNfcShUx1dJTtIByTF/4N0kn+hfJvnk9u6IWN9H8/sOycm59SQnje8oYdx/J7nK405JW9Lx35w3zD0kx6nvJjlEcWfaPgN4TFJrOp2zIqKti/nNIjkGvAB4lmSD+8kS6s33PpLQnUPyCXgpMI3kEx8k5z8mk3z6vBm4LA2TrowgOZG9nuRQxetIzn9AciIf4GVJDxYaOT308SmSDeZGkktmby3h/8qd1pMkYboiPaTT1WGsXL8heT08TXII5hUKH6rM9SGSUHucpPZf8tohld+SXO3zoqSO1+8nga0kV1jdR3KSe1YJNRbS0/UGyYnnL6fL6pJSZhoRy4DjSc5RrCQ5l/C3wDsj4nelTKu/UoR/ZMd6RskNYM8CNT35JG9m/Y/3FMzMLONQMDOzjA8fmZlZxnsKZmaWqcQXS5XNhAkTYvLkyT0ef+vWrYwZ09Vl85XnukrjukrjukozEOtavHjx+ojI/2aFRHe+C6O/PhoaGqI3mpubezV+ubiu0riu0riu0gzEuoBF4e8+MjOzrjgUzMws41AwM7OMQ8HMzDIOBTMzy+zVl6SaFTP50l/v0bbya++qQiVmexfvKdiAUygQOms3s9c4FMzMLONQMDOzjEPBzMwyDgUzM8v46iMbcKa+bgzL1m0t2N5db79q/m7TmPq6Mcz7zPS+KM+sX3Mo2IBTKBA62hv+eR7Nn53OPiNruHHx8/xu+XrGja6hbtRw6kbXUDe6hq/PfYIXNr+6x7hvv2p+t4LhzVfMY+2W7UnHHb+mfuxw/vClt/f23zKrCIeCDSozjvoTxgxPXvZrNrVx/8oNbNrWzpZXu/6J6WXrtvKBHy/k5+e/BYAbFj3H8xvbqBtVkwXKxXOWsLFt92mt3bKdN18xr1vB4D0UqzaHgg0qV7z36Oz5hW+byoVvmwpA+85dbG5rp6WtnZOuvKfo+PX7jMye3/X4WuY9sZbu/Hjh2i3buerOp2jfFXx+xp8BcMtDq2nfuYu60cleyiU3PMSqDa/sNl4peyi+Yc/6QtlCQdIs4N3Auog4Km2bAxyWDlIHtETEMZImA08AT6X9FkbEBeWqzQa2npxTqBk6hP1qR7Bf7YhOp33Vmcdkz3/0oWns3BVseaWdlm1JoJz+/d8VHfel1u2079yVdX/7rqdZ9fK2TucHrx0O+85dTzN5vzGc/qaJANz9xFrGjBhG3egaZnzn3oLjTr701w4GK0k59xRmA98DrutoiIj3dzyXdCWwKWf4ZyLiGMx6ad5npvfqMEwpoTJ0iNJP+sO7nO6/nXH0bt3/88nj2bStI1C2c86193c6/h1LX2Ta5H05/U0T2bUr+Nh1i9jln1i3Pla2UIiIBekewB4kCTgTeFu55m+DW2+Ow/cmVOrHDn/tJHNee759Rtawz8gaJo3vXl13XHTibt1ZqLS184mfP9i9iZh1QdGdA6I9nXgSCrd1HD7KaT8RuCoipuUM9xjwNLAZ+HJEFNwfljQTmAlQX1/f0NTU1OP6Wltbqa2t7fH45eK6StPf6rrot1tp2Q4QgKgbDt95W9eXw37x3q28UODCqQPHwL+e0Pn4591R+IorgNkzdh+3vy2vDq6rNL2pq7GxcXHH9jdftULhB8DyiLgy7R4B1EbEy5IagFuAIyNic2fTnzZtWixatKjH9c2fP5/p06f3ePxycV2lGUh19XQPpbMv+8s/p1Corv5w1dNAWo+V0Ju6JBUNhYpffSRpGHAG0NDRFhGvAq+mzxdLegZ4A9DzLb7ZXqhcG+KXW19lfet26kbXsH3n7h8E8wMBSrvqqdA0fCnt3qsal6SeDDwZEc93NEjaH9gQETslHQJMBVZUoTazAWnu0hf5x1uWZt0j59+e3bDX2c1+r7TvZGTNULa+ugMJRtUMJTkl+Jrehspu49/xawdKlZXzktTrgenABEnPA5dFxLXAWcD1eYOfCHxVUjuwC7ggIjaUqzazwWb6G/bn+39/LC1t23lo6VOMP2ASLdu207KtnSdf3FJ0vPaduxhZM5Tv3r2MqxesYPjQIYwbXcO+6V3g47oIla70NlB8b0bfK+fVR2cXaT+vQNuNwI3lqsVsoOvqMtpJ40czafxoACa2Pcv06Ydnw3R2PqJ2RLKJOOnwevYdM5yWbe1satvOxq3JZbTPbej6PguAT13/EP/7zHrGjapJLuEdVdNloGx+pZ19RtYUnWZnP6bkYOg539FsNgD05jLazgKl41DRcVPGc9yUwtfOducX7f7qT/ejduSw9BLa7by4+ZVO91AAPvjjP3DrhccDMPO6Razd8mq6h1LTrftCrGccCmYDRE+Pw1fiZr/3/8Xref9f7DluZ4HyiemHZs8n7juKtvadbNi6nRUvbaVl2573gljfcCiYWdVu9ussUGYcdUDWfdnfHLnHMP7N7fJwKJhZr1VrL8X6nkPBzKqqIwBKvRmrtz+m5DAqzKFgZnulzq5cOu+/7s9OSNflnJwelz6/qOkhVm1o22O8Ht1bwcAKFIeCmQ04HSekN27bzpZXuv4BpQ7L1m1l8aoN/GrJC+lls8N5cXU7O59YS93oGsaNGs7M6+5nxfqeBwr071BxKJjZgNNxKSvAjp272PzKjuRmvbZ2Nm1r58OzHyg67qqXt3Hrwy+wqa09+wGlax7t+ht3Ojbyv3/mZZau3pTtleTurYwbXcO7v3tvr27Yu+Wh1XzzN0+xuqWNiQt/y2ffeVj2Gxt9waFgZnul7p5TGDZ0COPHDGf8mO7d23DGsQdxxrEHsWtXsOWVHfxm/r0cdvSxtLS107JtO59uWtLp+L99ci3X3Pts9/+RVMf/8ocVL7Nx23bG5fxueN2o4YysGcKvlrzAF256lLb2nQCsbmnjCzc9CtBnweBQMLO9Urkuhe0wZIgYN7qG140ewhsn1WXtXYXCF089nE+dNDW9+/u1H1Fq2ZaEyrfufLrT8a+971nufHztHu3Dhw1hx85de/ywUlv7Tr75m6ccCmZm1bgUtqtAkcTYkTWMHVnDpALjdxUKV7z3aC46+Q20tG3PfkSpI1iuvqfw94S+0NJWsL0nHApmNij11zvA9x87gv3HFv6t8NseXsPqAgFwYN2obs27OxwKZmYlqtYd4J9952G7nVOA5OvMP/vOw3pcTz6HgplZhfU0VDrOG2RXH9WN8tVHZmaD2elvmsjpb5pYtp8JHdLnUzQzs72WQ8HMzDIOBTMzy5QtFCTNkrRO0tKctsslrZa0JH2cmtPvC5KWS3pK0jvLVZeZmRVXzj2F2cCMAu3fjohj0sdcAElHAGcBR6bj/KekoWWszczMCihbKETEAmBDNwc/DWiKiFcj4llgOXBcuWozM7PCFBFdD9XTiUuTgdsi4qi0+3LgPGAzsAi4OCI2SvoesDAifpYOdy1we0T8ssA0ZwIzAerr6xuampp6XF9rayu1tbU9Hr9cXFdpXFdpXFdpBmJdjY2NiyNiWsGeEVG2BzAZWJrTXQ8MJdlDuQKYlbZ/D/hgznDXAu/ravoNDQ3RG83Nzb0av1xcV2lcV2lcV2kGYl3AoiiyXa3o1UcRsTYidkbELuAaXjtEtBp2++6og9I2MzOroIqGgqQDcjrfC3RcmXQrcJakEZKmAFOB+ytZm5mZlfFrLiRdD0wHJkh6HrgMmC7pGCCAlcDHASLiMUk3AI8DO4B/iIidhaZrZmblU7ZQiIizCzRf28nwV5CcZzAzsyrxHc1mZpZxKJiZWcahYGZmGYeCmZllHApmZpZxKJiZWcahYGZmGYeCmZllHApmZpZxKJiZWcahYGZmGYeCmZllHApmZpZxKJiZWcahYGZmGYeCmZllHApmZpYpWyhImiVpnaSlOW3flPSkpEck3SypLm2fLKlN0pL08cNy1WVmZsWVc09hNjAjr20ecFRE/DnwNPCFnH7PRMQx6eOCMtZlZmZFlC0UImIBsCGv7c6I2JF2LgQOKtf8zcysdNU8p/AR4Pac7imSHpJ0j6QTqlWUmdlgpogo38SlycBtEXFUXvuXgGnAGRERkkYAtRHxsqQG4BbgyIjYXGCaM4GZAPX19Q1NTU09rq+1tZXa2toej18urqs0rqs0rqs0A7GuxsbGxRExrWDPiCjbA5gMLM1rOw/4PTC6k/HmA9O6mn5DQ0P0RnNzc6/GLxfXVRrXVRrXVZqBWBewKIpsVyt6+EjSDOBzwHsiYltO+/6ShqbPDwGmAisqWZuZmcGwck1Y0vXAdGCCpOeBy0iuNhoBzJMEsDCSK41OBL4qqR3YBVwQERsKTtjMzMqmbKEQEWcXaL62yLA3AjeWqxYzM+se39FsZmYZh4KZmWUcCmZmlnEomJlZxqFgZmYZh4KZmWUcCmZmlnEomJlZxqFgZmYZh4KZmWUcCmZmlnEomJlZxqFgZmYZh4KZmWUcCmZmlnEomJlZxqFgZmYZh4KZmWXKGgqSZklaJ2lpTtt4SfMkLUv/7pu2S9J3JS2X9IikY8tZm5mZ7ancewqzgRl5bZcCd0fEVODutBvgFGBq+pgJ/KDMtZmZWZ6yhkJELAA25DWfBvwkff4T4PSc9usisRCok3RAOeszM7PdKSLKOwNpMnBbRByVdrdERF36XMDGiKiTdBvwtYi4L+13N/D5iFiUN72ZJHsS1NfXNzQ1NfW4ttbWVmpra3s8frm4rtK4rtK4rtIMxLoaGxsXR8S0gj0joqwPYDKwNKe7Ja//xvTvbcDxOe13A9M6m3ZDQ0P0RnNzc6/GLxfXVRrXVRrXVZqBWBewKIpsV6tx9dHajsNC6d91aftqYFLOcAelbWZmViHVCIVbgXPT5+cCv8pp/1B6FdJbgE0RsaYK9ZmZDVrDyjlxSdcD04EJkp4HLgO+Btwg6aPAKuDMdPC5wKnAcmAb8OFy1mZmZnsqayhExNlFep1UYNgA/qGc9ZiZWed8R7OZmWUcCmZmlikaCpKOlrRQ0nOSftTxdRRpv/srU56ZmVVSZ3sKPwAuB44Gngbuk3Ro2q+mzHWZmVkVdHaieZ+IuCN9/i1Ji4E7JJ0DlPc2aDMzq4rOQmGXpHERsQkgIpol/S1wIzC+ItWZmVlFdXb46GjgcEmf7miIiEdILie9qdyFmZlZ5XUWCk8BfwQ+Imnf9HcQxgOtwOcrUp2ZmVVUZ4ePfkDypXSHAIsB5fSLtN3MzAaQonsKEfEfEXE4MCsiDomIKTkPB4KZ2QDU5c1rEfH/KlGImZlVn+9oNjOzjEPBzMwyDgUzM8s4FMzMLONQMDOzjEPBzMwyDgUzM8uU9ec4C5F0GDAnp+kQ4CtAHfAx4KW0/YsRMbfC5ZmZDWoVD4WIeAo4BkDSUGA1cDPwYeDbEfGtStdkZmaJah8+Ogl4JiJWVbkOMzMDFFG938uRNAt4MCK+J+ly4DxgM7AIuDgiNhYYZyYwE6C+vr6hqampx/NvbW2ltra2x+OXi+sqjesqjesqzUCsq7GxcXFETCvYMyKq8gCGA+uB+rS7HhhKsvdyBckX8XU6jYaGhuiN5ubmXo1fLq6rNK6rNK6rNAOxLmBRFNmuVvPw0SkkewlrASJibUTsjIhdwDXAcVWszcxsUKpmKJwNXN/RIemAnH7vBZZWvCIzs0Gu4lcfAUgaA7wd+HhO8zckHUPyAz4r8/qZmVkFVCUUImIrsF9e2znVqMXMzF5T7UtSzcysH3EomJlZxqFgZmYZh4KZmWUcCmZmlnEomJlZxqFgZmYZh4KZmWUcCmZmlnEomJlZxqFgZmYZh4KZmWUcCmZmlnEomJlZxqFgZmYZh4KZmWUcCmZmlnEomJlZpio/xwkgaSWwBdgJ7IiIaZLGA3OAySS/03xmRGysVo1mZoNNtfcUGiPimIiYlnZfCtwdEVOBu9NuMzOrkGqHQr7TgJ+kz38CnF7FWszMBh1FRHVmLD0LbAQCuDoifiSpJSLq0v4CNnZ054w3E5gJUF9f39DU1NTjGlpbW6mtre3x+OXiukrjukrjukozEOtqbGxcnHOEZncRUZUHMDH9+zrgYeBEoCVvmI2dTaOhoSF6o7m5uVfjl4vrKo3rKo3rKs1ArAtYFEW2q1U7fBQRq9O/64CbgeOAtZIOAEj/rqtWfWZmg1FVQkHSGEljO54D7wCWArcC56aDnQv8qhr1mZkNVtW6JLUeuDk5bcAw4L8j4g5JDwA3SPoosAo4s0r1mZkNSlUJhYhYAbyxQPvLwEmVr8jMzKD/XZJqZmZV5FAwM7OMQ8HMzDIOBTMzyzgUzMws41AwM7OMQ8HMzDIOBTMzyzgUzMws41AwM7OMQ8HMzDIOBTMzyzgUzMws41AwM7OMQ8HMzDIOBTMzyzgUzMws41AwM7NMxUNB0iRJzZIel/SYpE+n7ZdLWi1pSfo4tdK1mZkNdtX4jeYdwMUR8aCkscBiSfPSft+OiG9VoSYzM6MKoRARa4A16fMtkp4AJla6DjMz25MionozlyYDC4CjgM8A5wGbgUUkexMbC4wzE5gJUF9f39DU1NTj+be2tlJbW9vj8cvFdZXGdZXGdZVmINbV2Ni4OCKmFewZEVV5ALXAYuCMtLseGEpynuMKYFZX02hoaIjeaG5u7tX45eK6SuO6SuO6SjMQ6wIWRZHtalWuPpJUA9wI/DwibgKIiLURsTMidgHXAMdVozYzs8GsGlcfCbgWeCIirsppPyBnsPcCSytdm5nZYFeNq4/+CjgHeFTSkrTti8DZko4BAlgJfLwKtZmZDWrVuProPkAFes2tdC1mZrY739FsZmYZh4KZmWUcCmZmlnEomJlZxqFgZmYZh4KZmWUcCmZmlnEomJlZxqFgZmYZh4KZmWUcCmZmlnEomJlZxqFgZmYZh4KZmWUcCmZmlnEomJlZxqFgZmYZh4KZmWX6XShImiHpKUnLJV3a5zO47zvw7ILd255dkLSbmQ1y/SoUJA0Fvg+cAhwBnC3piD6dycRj4RfnvRYMzy5Iuice26ezMTPbGw2rdgF5jgOWR8QKAElNwGnA4302hyknwt/Nhl+cx+T9T4L77066p5zYZ7MwM9tbKSKqXUNG0vuAGRFxftp9DvDmiLgwZ5iZwEyA+vr6hqamph7Na/KzP2fyqhtYefCZrJzygd4X34daW1upra2tdhl7cF2lcV2lcV2l6U1djY2NiyNiWsGeEdFvHsD7gB/ndJ8DfK/Y8A0NDdEjK+6J+PqUeHbW+RFfn5J09yPNzc3VLqEg11Ua11Ua11Wa3tQFLIoi29V+dU4BWA1Myuk+KG3rOx3nEP5udrKHkB5K2uPks5nZINTfQuEBYKqkKZKGA2cBt/bpHFY/uPs5hI5zDKsf7NPZmJntjfrVieaI2CHpQuA3wFBgVkQ81qczOf6iPdumnOgTzWZm9LNQAIiIucDcatdhZjYY9bfDR2ZmVkUOBTMzyzgUzMws41AwM7NMv7qjuVSSXgJW9WISE4D1fVROX3JdpXFdpXFdpRmIdR0cEfsX6rFXh0JvSVoUxW71riLXVRrXVRrXVZrBVpcPH5mZWcahYGZmmcEeCj+qdgFFuK7SuK7SuK7SDKq6BvU5BTMz291g31MwM7McDgUzM8sM+FCQNEPSU5KWS7q0QP8Rkuak/f8gaXIFapokqVnS45Iek/TpAsNMl7RJ0pL08ZVy15Uz75WSHk3nu6hAf0n6brrMHpFU1h+4lnRYznJYImmzpIvyhqnY8pI0S9I6SUtz2sZLmidpWfp33yLjnpsOs0zSuRWo65uSnkzX082S6oqM2+k6L0Ndl0tanbO+Ti0ybqfv3zLUNSenppWSlhQZt5zLq+D2oWKvsWK/vjMQHiRfv/0McAgwHHgYOCJvmE8AP0yfnwXMqUBdBwDHps/HAk8XqGs6cFuVlttKYEIn/U8FbgcEvAX4Q4XX6YskN99UZXkBJwLHAktz2r4BXJo+vxT4eoHxxgMr0r/7ps/3LXNd7wCGpc+/Xqiu7qzzMtR1OXBJN9Z1p+/fvq4rr/+VwFeqsLwKbh8q9Rob6HsKxwHLI2JFRGwHmoDT8oY5DfhJ+vyXwEmSVM6iImJNRDyYPt8CPAFMLOc8+9hpwHWRWAjUSTqgQvM+CWUl97YAAAPjSURBVHgmInpzJ3uvRMQCYENec+7r6CfA6QVGfScwLyI2RMRGYB4wo5x1RcSdEbEj7VxI8muGFVVkeXVHd96/Zakr3QacCVzfV/Prrk62DxV5jQ30UJgIPJfT/Tx7bnyzYdI3zyZgv4pUB6SHq94E/KFA77+U9LCk2yUdWamagADulLRY0swC/buzXMvlLIq/Uau1vADqI2JN+vxFoL7AMNVcbgAfIdnDK6SrdV4OF6aHtWYVORRSzeV1ArA2IpYV6V+R5ZW3fajIa2ygh0K/JqkWuBG4KCI25/V+kOQQyRuB/wBuqWBpx0fEscApwD9I6hc/S6fkJ1rfA/yiQO9qLq/dRLIf36+u9Zb0JWAH8PMig1R6nf8AOBQ4BlhDcqimPzmbzvcSyr68Ots+lPM1NtBDYTUwKaf7oLSt4DCShgHjgJfLXZikGpIV/vOIuCm/f0RsjojW9PlcoEbShHLXlc5vdfp3HXAzyW58ru4s13I4BXgwItbm96jm8kqt7TiElv5dV2CYqiw3SecB7wY+kG5M9tCNdd6nImJtROyMiF3ANUXmV63lNQw4A5hTbJhyL68i24eKvMYGeig8AEyVNCX9lHkWcGveMLcCHWfo3wf8ttgbp6+kxyuvBZ6IiKuKDPMnHec2JB1Hsq4qEVZjJI3teE5yonJp3mC3Ah9S4i3Appzd2nIq+umtWssrR+7r6FzgVwWG+Q3wDkn7podL3pG2lY2kGcDngPdExLYiw3Rnnfd1XbnnoN5bZH7def+Ww8nAkxHxfKGe5V5enWwfKvMaK8fZ8/70ILlS5mmSqxi+lLZ9leRNAjCS5HDEcuB+4JAK1HQ8ya7fI8CS9HEqcAFwQTrMhcBjJFdcLATeWqHldUg6z4fT+Xcss9zaBHw/XaaPAtMqUNcYko38uJy2qiwvkmBaA7STHLP9KMl5qLuBZcBdwPh02GnAj3PG/Uj6WlsOfLgCdS0nOcbc8TrruNLuQGBuZ+u8zHX9NH3tPEKysTsgv660e4/3bznrSttnd7yucoat5PIqtn2oyGvMX3NhZmaZgX74yMzMSuBQMDOzjEPBzMwyDgUzM8s4FMzMLONQMOsjkj4l6QlJN0r6vaRXJV1S7brMSjGs2gWYDSCfILnxaTtwMIW/sMysX/OeglkfkPRDkpuabif5OokHSG6KMtureE/BrA9ExAXpV0o0RsT6atdj1lPeUzAzs4xDwczMMg4FMzPL+AvxzPqIpJUk31g5DFgE7APsAlpJfls4/4eUzPodh4KZmWV8+MjMzDIOBTMzyzgUzMws41AwM7OMQ8HMzDIOBTMzyzgUzMws838TAB9GS7Zl9AAAAABJRU5ErkJggg==\n" }, "metadata": { "needs_background": "light" } } ] }, { "cell_type": "code", "source": [ "def applyAugmentedEpsilonConstraint(model, f2_min, f2_max, solver, n):\n", "\n", " # Aplico epsilon-restricciones aumentado\n", "\n", " model.O_f1.deactivate()\n", " model.O_f2.deactivate()\n", " \n", " # Creo el parámetro de epsilon y traslado al objetivo f2 a las restricciones.\n", " model.e = Param(initialize=0, mutable=True)\n", " model.C_e = Constraint(expr = model.f2 - model.s == model.e) \n", "\n", " # Creo la variable de holgura de la restricción asociada a f2 y arma la nueva función objetivo.\n", " model.s = Var(within=NonNegativeReals)\n", " model.delta = Param(initialize=0.00001)\n", " model.O_f = Objective(expr = model.f1 + model.delta * model.s / (f2_max - f2_min), sense=maximize)\n", " \n", " x1_l = []\n", " x2_l = []\n", " f1_l = []\n", " f2_l = []\n", "\n", " # Creo el paso que uso para variar los epsilon\n", " step = (f2_max - f2_min)/n\n", " \n", " # Aplico el proceso iterativo para realizar la búsqueda de las n + 1 soluciones\n", " i = 0\n", " redundant_it = 0\n", " while i < n + 1:\n", " # Varío el valor de epsilon\n", " e_ = f2_min + i * step\n", " model.e = f2_min + i * step\n", "\n", " solver.solve(model)\n", "\n", " x1_l.append(value(model.X1))\n", " x2_l.append(value(model.X2))\n", " f1_l.append(value(model.f1))\n", " f2_l.append(value(model.f2))\n", "\n", " print(\"Epsilon \" + str(e_))\n", " print(\"Sol vars - it:\" + str(i) + \" x1= \" + str(x1_l[len(x1_l)-1]) + \" x2= \" + str(x2_l[len(x2_l)-1]))\n", " print(\"Sol FO - it:\" + str(i) + \" f1= \" + str(f1_l[len(f1_l)-1]) + \" f2= \" + str(f2_l[len(f2_l)-1]))\n", "\n", " # Chequeo si la siguiente iteración proporcionaría la misma solución ya hallada\n", " # comparando la varbiable de holgura del objetivo f2 con el paso.\n", " b = floor(value(model.s)/step)\n", " # Si la siguiente iteración proporcionará la misma solución ya hallada, la salteo (b > 0). Sino b = 0 y el contador se incrementa sólo en 1\n", " if b > 0:\n", " redundant_it += 1\n", " i = i + b + 1\n", "\n", " # Para graficar el frente de Pareto hallado en el espacio de decisiones o variables\n", " plt.plot(x1_l,x2_l,'o-.')\n", " plt.plot(0,0,'x-.')\n", " plt.title('Augmented epsilon-Constraint Pareto-front Vars')\n", " plt.xlabel(\"X1\", fontsize = 10)\n", " plt.ylabel(\"X2\", fontsize = 10) \n", " plt.grid(True)\n", " #plt.savefig(\"Augmented epsilon-Constraint - Vars\", dpi = 600, bbox_inches=\"tight\")\n", " plt.show()\n", " plt.close()\n", "\n", " # Para graficar el frente de Pareto hallado en el espacio de búsqueda o de objetivos\n", " plt.plot(f1_l,f2_l,'o-.')\n", " plt.plot(0,0,'x-.')\n", " plt.title('Augmented epsilon-Constraint Pareto-front FO')\n", " plt.xlabel(\"f1\", fontsize = 10)\n", " plt.ylabel(\"f2\", fontsize = 10) \n", " plt.grid(True)\n", " #plt.savefig(\"Augmented epsilon-Constraint - FO\", dpi = 600, bbox_inches=\"tight\") \n", " plt.show()\n", " plt.close()\n", "\n", " # Vuelvo el modelo a su estado original\n", " model.del_component(model.O_f)\n", " model.del_component(model.delta)\n", " model.del_component(model.e)\n", " model.del_component(model.s)\n", " model.del_component(model.C_e)" ], "metadata": { "id": "fOIHwsEBueuw" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "#model = cargarModelo()\n", "model = cargarModelo_int()\n", "f2_min, f2_max, f1_min, f1_max, solver = encontrarExtremosLexicographic(model)\n", "n = 100\n", "applyAugmentedEpsilonConstraint(model, f2_min, f2_max, solver, n)" ], "metadata": { "id": "y-QJwlpmu_tM", "colab": { "base_uri": "https://localhost:8080/", "height": 1000 }, "outputId": "ba948342-571c-4fc2-ff83-8a81fb99b743" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Extremo 1\n", "Primer paso\n", "( X1 , X2 ) = ( 20.0 , 0.0 )\n", "f1 = 20.0\n", "f2 = 60.0\n", "Segundo paso\n", "( X1 , X2 ) = ( 20.0 , 25.0 )\n", "f1 = 20.0\n", "f2 = 160.0\n", "Extremo 2\n", "Primer paso\n", "( X1 , X2 ) = ( 8.0 , 40.0 )\n", "f1 = 8.0\n", "f2 = 184.0\n", "Segundo paso\n", "( X1 , X2 ) = ( 8.0 , 40.0 )\n", "f1 = 8.0\n", "f2 = 184.0\n", "Epsilon 160.0\n", "Sol vars - it:0 x1= 20.0 x2= 25.0\n", "Sol FO - it:0 f1= 20.0 f2= 160.0\n", "Epsilon 160.24\n", "Sol vars - it:1 x1= 19.0 x2= 26.0\n", "Sol FO - it:1 f1= 19.0 f2= 161.0\n", "Epsilon 161.2\n", "Sol vars - it:5 x1= 18.0 x2= 27.0\n", "Sol FO - it:5 f1= 18.0 f2= 162.0\n", "Epsilon 162.16\n", "Sol vars - it:9 x1= 17.0 x2= 28.0\n", "Sol FO - it:9 f1= 17.0 f2= 163.0\n", "Epsilon 163.12\n", "Sol vars - it:13 x1= 16.0 x2= 30.0\n", "Sol FO - it:13 f1= 16.0 f2= 168.0\n", "Epsilon 168.16\n", "Sol vars - it:34 x1= 15.0 x2= 31.0\n", "Sol FO - it:34 f1= 15.0 f2= 169.0\n", "Epsilon 169.12\n", "Sol vars - it:38 x1= 14.0 x2= 32.0\n", "Sol FO - it:38 f1= 14.0 f2= 170.0\n", "Epsilon 170.08\n", "Sol vars - it:42 x1= 13.0 x2= 33.0\n", "Sol FO - it:42 f1= 13.0 f2= 171.0\n", "Epsilon 171.04\n", "Sol vars - it:46 x1= 12.0 x2= 35.0\n", "Sol FO - it:46 f1= 12.0 f2= 176.0\n", "Epsilon 176.07999999999998\n", "Sol vars - it:67 x1= 11.0 x2= 36.0\n", "Sol FO - it:67 f1= 11.0 f2= 177.0\n", "Epsilon 177.04\n", "Sol vars - it:71 x1= 10.0 x2= 37.0\n", "Sol FO - it:71 f1= 10.0 f2= 178.0\n", "Epsilon 178.24\n", "Sol vars - it:76 x1= 9.0 x2= 38.0\n", "Sol FO - it:76 f1= 9.0 f2= 179.0\n", "Epsilon 179.2\n", "Sol vars - it:80 x1= 8.0 x2= 40.0\n", "Sol FO - it:80 f1= 8.0 f2= 184.0\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": { "needs_background": "light" } }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": { "needs_background": "light" } } ] }, { "cell_type": "code", "source": [ "def goalProgramming(model, f2_max, f1_max, solver, goals_, pesosPos_, pesosNeg_):\n", "\n", " # Aplico programación por metas e incorporo algunas cuestiones para generar modelos en pyomo \n", "\n", " model.O_f1.deactivate()\n", " model.O_f2.deactivate()\n", " \n", " # Generación de conjunto de los objetivos\n", " model.M = Set(initialize = range(2)) \n", "\n", " # Generación de parámetros indexados en el conjunto de los objetivos previamente creado.\n", " # Tomo las metas y los pesos (goals_, pesosPos_, pesosNeg_) que están en estructuras de Python plano (listas) y los paso a estructuras de Pyomo\n", " # Parámetro de metas\n", " def goals_rule(model,m):\n", " return goals_[m]\n", " model.goals = Param(model.M, initialize=goals_rule, within=NonNegativeReals)\n", " # Parámetro de pesos asignado a la desviación positiva\n", " def pesosPos_rule(model,m):\n", " return pesosPos_[m]\n", " model.pesosPos = Param(model.M, initialize=pesosPos_rule, within=NonNegativeReals)\n", " # Parámetro de pesos asignado a la desviación negativa\n", " def pesosNeg_rule(model,m):\n", " return pesosNeg_[m]\n", " model.pesosNeg = Param(model.M, initialize=pesosNeg_rule, within=NonNegativeReals)\n", "\n", " # Generación de variables indexadas en el conjunto de los objetivos previamente creado.\n", " # Variable de desviación positiva\n", " model.devPos = Var(model.M, within=NonNegativeReals)\n", " # Variable de desviación negativa\n", " model.devNeg = Var(model.M, within=NonNegativeReals)\n", "\n", " # Creo objetivo a através de una función\n", " def Objective_rule(model):\n", " return sum(model.devPos[m] * model.pesosPos[m] + model.devNeg[m] * model.pesosNeg[m] for m in model.M)\n", " model.O_f = Objective(rule=Objective_rule , sense=minimize)\n", "\n", " # Creo restricciones para las metas\n", " def goalsConstraint_rule(model,m):\n", " if m == model.M.first():\n", " return model.f1/f1_max + model.devNeg[m] - model.devPos[m] == model.goals[m]/f1_max\n", " if m == model.M.last():\n", " return model.f2/f2_max + model.devNeg[m] - model.devPos[m] == model.goals[m]/f2_max\n", " model.goalsConstraint = Constraint(model.M, rule=goalsConstraint_rule)\n", " \n", " solver.solve(model)\n", "\n", " x1_l = []\n", " x2_l = []\n", " f1_l = []\n", " f2_l = []\n", "\n", " x1_l.append(value(model.X1))\n", " x2_l.append(value(model.X2))\n", " f1_l.append(value(model.f1))\n", " f2_l.append(value(model.f2))\n", " \n", " print(\"Sol vars \" + str(x1_l[len(x1_l)-1]) + \" \" + str(x2_l[len(x2_l)-1]))\n", " print(\"Sol FO \" + str(f1_l[len(f1_l)-1]) + \" \" + str(f2_l[len(f2_l)-1]))\n", " \n", " # Para graficar la solución hallada en el espacio de decisiones o variables\n", " plt.plot(x1_l,x2_l,'o-.')\n", " plt.title('Goal Programming solution Vars')\n", " plt.xlabel(\"X1\", fontsize = 10)\n", " plt.ylabel(\"X2\", fontsize = 10) \n", " plt.grid(True)\n", " #files.download(\"Goal Programming solution Vars.png\") \n", " plt.show()\n", " plt.close()\n", "\n", " # Para graficar la solución hallada en el espacio de búsqueda o de objetivos\n", " plt.plot(f1_l,f2_l,'o-.')\n", " plt.title('Goal Programming solution FO')\n", " plt.xlabel(\"f1\", fontsize = 10)\n", " plt.ylabel(\"f2\", fontsize = 10) \n", " plt.grid(True)\n", " #files.download(\"Goal Programming solution FO.png\") \n", " plt.show()\n", " plt.close()\n", "\n", " # Vuelvo el modelo a su estado original\n", " model.del_component(model.O_f)\n", " model.del_component(model.goalsConstraint)\n", " model.del_component(model.goals)\n", " model.del_component(model.pesosNeg)\n", " model.del_component(model.pesosPos)\n", " model.del_component(model.devPos)\n", " model.del_component(model.devNeg)\n", " model.del_component(model.M)" ], "metadata": { "id": "FaiLi68Nyc-F" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "model = cargarModelo()\n", "f2_min, f2_max, f1_min, f1_max, solver = encontrarExtremosLexicographic(model)\n", "goals_ = [20,175]\n", "pesosPos_ = [0.1,0.9]\n", "pesosNeg_ = [0.1,0.9]\n", "goalProgramming(model, f2_max, f1_max, solver, goals_, pesosPos_, pesosNeg_)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 920 }, "id": "dI2AtdW8zZ7n", "outputId": "b1dd7525-6ab5-4e75-ba16-b99a137788ad" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Extremo 1\n", "Primer paso\n", "( X1 , X2 ) = ( 20.000000199990012 , 4.779338185084407 )\n", "f1 = 20.000000199990012\n", "f2 = 79.11735334030767\n", "Segundo paso\n", "( X1 , X2 ) = ( 20.000000000472365 , 25.000000499164017 )\n", "f1 = 20.000000000472365\n", "f2 = 160.00000199807317\n", "Extremo 2\n", "Primer paso\n", "( X1 , X2 ) = ( 8.000000080001664 , 40.000000399993745 )\n", "f1 = 8.000000080001664\n", "f2 = 184.00000183997997\n", "Segundo paso\n", "( X1 , X2 ) = ( 8.000000999990018 , 39.99999925000748 )\n", "f1 = 8.000000999990018\n", "f2 = 183.99999999999997\n", "Sol vars 12.500000999412185 34.374999249734664\n", "Sol FO 12.500000999412185 174.9999999971752\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": { "needs_background": "light" } }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": { "needs_background": "light" } } ] } ] }