Taller_15_CVXPY_solvers_Branch_and_Bound.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyPpiCBlN6Bding46LE4fUqV",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/gabrielawad/talleresGoogleColab/blob/main/Taller_15_CVXPY_solvers_Branch_and_Bound.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## «*Hay personas que tienen la memoria muy llena, pero el juicio muy vacío y hueco*».\n",
        "### [Miguel de Montaigne](https://es.wikipedia.org/wiki/Michel_de_Montaigne)"
      ],
      "metadata": {
        "id": "VLMDjD3tAVeA"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Taller 15 CVXPY solvers y Branch and Bound\n",
        "\n"
      ],
      "metadata": {
        "id": "bx-omGjwAXa3"
      }
    },
    {
      "metadata": {
        "id": "TgMEgpBeAJDW"
      },
      "cell_type": "markdown",
      "source": [
        "# Características generales de CVXPY\n",
        "\n",
        "CVXPY  es un lenguaje de modelado para [optimización de problemas convexos](https://web.stanford.edu/~boyd/cvxbook/), que funciona como una librería de Python.\n",
        "\n",
        "Su principal ventaja es que permite la formulación de problemas por medio de expresiones algebraicas o matriciales. CVXPY automáticamente transforma el problema a su forma estándar, lo resuelve por medio de un  [solvers](https://en.wikipedia.org/wiki/Solver), y entrega los resultados.\n",
        "\n",
        "Es decir, simplifica el proceso de optimización computacional ya que es capaz de resolver el problema sin necesidad de convertirlo a las formas estándares requeridas por los [solvers](https://en.wikipedia.org/wiki/Solver).\n",
        "\n",
        "## Página oficial\n",
        "La información oficial de CVXPY puede ser consultada en [www.cvxpy.org](http://www.cvxpy.org)"
      ]
    },
    {
      "metadata": {
        "id": "Triiphpbl1WE"
      },
      "cell_type": "markdown",
      "source": [
        "# Estados de un problema\n",
        "\n",
        "CVXPY identifica los siguientes estados en la solución de un problema:\n",
        "* OPTIMAL  (se encontró al menos una solución óptima)\n",
        "* INFEASIBLE (no se encontraron soluciones factibles)\n",
        "* UNBOUNDED (se encontró una solución indeterminada)\n",
        "* OPTIMAL_INACCURATE (se encontró al menos una solución óptima, **pero el nivel de precisión es inferior al deseado**)\n",
        "* INFEASIBLE_INACCURATE (no se encontraron soluciones factibles **y el nivel de precisión es inferior al deseado**)\n",
        "* UNBOUNDED_INACCURATE  (se encontró una solución indeterminada **y el nivel de precisión es inferior al deseado**)\n",
        "\n",
        "En los casos diferentes a estados **OPTIMAL** se sugiere revisar la formulación del problema y los valores de los parámetros.\n",
        "\n",
        "En los casos de estados **INACCURATE** de la solución se recomienda ensayar a resolver el problema utilizando otro solver.\n"
      ]
    },
    {
      "metadata": {
        "id": "PmRGg5-LrauO"
      },
      "cell_type": "markdown",
      "source": [
        "# Gestión de solvers\n",
        "\n",
        "CVXPY utiliza open source solvers como [OSQP](https://osqp.org), [ECOS](https://www.embotech.com/ECOS), [ECOS_BB](https://github.com/embotech/ecos#mixed-integer-socps-ecos_bb) y [SCS](https://github.com/cvxgrp/scs). Si se desea utilizar otros solvers ([CVXOPT](http://cvxopt.org), [GLPK](https://www.gnu.org/software/glpk/),  [CBC](https://projects.coin-or.org/Cbc),  [MOSEK](https://www.mosek.com),  [GUROBI](http://www.gurobi.com)) se debe instalar cada uno de ellos de manera adicional.\n",
        "El código que se presenta a continuación  resuelve el mismo ejercicio utilizando cuatro solvers diferentes. Analice los valores obtenidos tanto para la solución óptima como para las variables de decisión."
      ]
    },
    {
      "metadata": {
        "id": "CalVP518ri5g",
        "outputId": "8c097daa-7565-43ac-a47a-fc6931faf73b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "cell_type": "code",
      "source": [
        "# Este programa presenta la solución de un ejercicio de optimización\n",
        "# utilizando cuatro solvers\n",
        "\n",
        "# Importar la librería que se va a utilizar\n",
        "import cvxpy as cvx\n",
        "\n",
        "# Crear las variables a optimizar\n",
        "x = cvx.Variable()\n",
        "y = cvx.Variable()\n",
        "\n",
        "# Definir la función objetivo\n",
        "obj = cvx.Minimize(3*x + 8*y)\n",
        "\n",
        "# Establecer las restricciones\n",
        "constraints = [\n",
        "x + y >= 50,\n",
        "x - y <= 20,\n",
        "x >= 0,\n",
        "y >= 0\n",
        "]\n",
        "\n",
        "# Configurar el problema\n",
        "prob_ej = cvx.Problem(obj, constraints)\n",
        "\n",
        "# Obtener el valor óptimo, actualizar el estado del problema y los valores\n",
        "# de todas las variables del problema\n",
        "prob_ej.solve()\n",
        "\n",
        "print (\"Soluciones sin especificar el solver\")\n",
        "\n",
        "# Mostrar el estado de la solución sin especificar el solver\n",
        "print(\"Estado de la solución sin especificar el solver:\", prob_ej.status)\n",
        "\n",
        "# Mostrar el valor óptimo de la función objetivo sin especificar el solver\n",
        "print(\"Valor óptimo de la función objetivo sin especificar el solver:\",\n",
        "      prob_ej.value)\n",
        "\n",
        "# Mostrar los valores óptimos de las variables de decisión sin especificar\n",
        "# el solver\n",
        "print(\"Valores óptimos de las variables de decisión sin especificar el solver:\",\n",
        "      x.value, y.value, \"\\n\")\n",
        "\n",
        "# Soluciones con OSQP\n",
        "print (\"Soluciones con OSQP\")\n",
        "\n",
        "# Resolver con OSQP\n",
        "prob_ej.solve(solver=cvx.OSQP)\n",
        "\n",
        "# Mostrar el estado de la solución con OSQP\n",
        "print(\"Estado de la solución con OSQP:\", prob_ej.status)\n",
        "\n",
        "print(\"Valor óptimo de la función objetivo con OSQP:\", prob_ej.value)\n",
        "\n",
        "# Mostrar los valores óptimos de las variables de decisión con OSQP\n",
        "print(\"Valores óptimos de las variables de decisión con OSQP:\",\n",
        "      x.value, y.value, \"\\n\")\n",
        "\n",
        "# Soluciones con ECOS\n",
        "print (\"Soluciones con ECOS\")\n",
        "\n",
        "# Resolver con ECOS\n",
        "prob_ej.solve(solver=cvx.ECOS)\n",
        "\n",
        "# Mostrar el estado de la solución con ECOS\n",
        "print(\"Estado de la solución con ECOS:\", prob_ej.status)\n",
        "\n",
        "print(\"Valor óptimo de la función objetivo con ECOS:\", prob_ej.value)\n",
        "\n",
        "# Mostrar los valores óptimos de las variables de decisión con ECOS\n",
        "print(\"Valores óptimos de las variables de decisión con ECOS:\",\n",
        "      x.value, y.value, \"\\n\")\n",
        "\n",
        "# Soluciones con ECOS_BB\n",
        "print (\"Soluciones con ECOS_BB\")\n",
        "\n",
        "# Resolver con ECOS_BB\n",
        "prob_ej.solve(solver=cvx.ECOS_BB)\n",
        "\n",
        "# Mostrar el estado de la solución  con ECOS_BB\n",
        "print(\"Estado de la solución con ECOS_BB:\", prob_ej.status)\n",
        "\n",
        "print(\"Valor óptimo de la función objetivo con ECOS_BB:\", prob_ej.value)\n",
        "\n",
        "# Mostrar los valores óptimos de las variables de decisión con ECOS_BB\n",
        "print(\"Valores óptimos de las variables de decisión con ECOS_BB:\",\n",
        "      x.value, y.value, \"\\n\")\n",
        "\n",
        "# Soluciones con SCS\n",
        "print (\"Soluciones con SCS\")\n",
        "\n",
        "# Resolver con SCS\n",
        "prob_ej.solve(solver=cvx.SCS)\n",
        "\n",
        "# Mostrar el estado de la solución  con SCS\n",
        "print(\"Estado de la solución con SCS:\", prob_ej.status)\n",
        "\n",
        "print(\"Valor óptimo de la función objetivo con SCS:\", prob_ej.value)\n",
        "\n",
        "# Mostrar los valores óptimos de las variables de decisión con SCS\n",
        "print(\"Valores óptimos de las variables de decisión con SCS:\",\n",
        "      x.value, y.value, \"\\n\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Soluciones sin especificar el solver\n",
            "Estado de la solución sin especificar el solver: optimal\n",
            "Valor óptimo de la función objetivo sin especificar el solver: 224.99999999004348\n",
            "Valores óptimos de las variables de decisión sin especificar el solver: 34.99999999851025 14.999999999314094 \n",
            "\n",
            "Soluciones con OSQP\n",
            "Estado de la solución con OSQP: optimal\n",
            "Valor óptimo de la función objetivo con OSQP: 225.0\n",
            "Valores óptimos de las variables de decisión con OSQP: 35.0 15.0 \n",
            "\n",
            "Soluciones con ECOS\n",
            "Estado de la solución con ECOS: optimal\n",
            "Valor óptimo de la función objetivo con ECOS: 224.9999996816037\n",
            "Valores óptimos de las variables de decisión con ECOS: 35.00000000022704 14.999999960115321 \n",
            "\n",
            "Soluciones con ECOS_BB\n",
            "Estado de la solución con ECOS_BB: optimal\n",
            "Valor óptimo de la función objetivo con ECOS_BB: 224.9999996816037\n",
            "Valores óptimos de las variables de decisión con ECOS_BB: 35.00000000022704 14.999999960115321 \n",
            "\n",
            "Soluciones con SCS\n",
            "Estado de la solución con SCS: optimal\n",
            "Valor óptimo de la función objetivo con SCS: 225.00005534246475\n",
            "Valores óptimos de las variables de decisión con SCS: 35.00001549417793 15.000001107491368 \n",
            "\n"
          ]
        }
      ]
    },
    {
      "metadata": {
        "id": "eSNwg7sahcHz"
      },
      "cell_type": "markdown",
      "source": [
        "# Branch and Bound\n",
        "\n",
        "Ejemplo de la solución  paso a paso de un problema de programación entera utilizando la heurística Branch and Bound."
      ]
    },
    {
      "metadata": {
        "id": "8CjzKIJR41ww"
      },
      "cell_type": "markdown",
      "source": [
        "## Problema inicial: problema00\n",
        "\n",
        "Max Z = 8\\* x + 5\\* y\n",
        "\n",
        "   x   +   y    <=  6\n",
        "   \n",
        "   9 \\* x       + 5\\* y        < =  45\n",
        "\n",
        "   x   > = 0      \n",
        "\n",
        "   y   >=  0\n",
        "\n",
        "**x, y enteros**\n"
      ]
    },
    {
      "metadata": {
        "id": "dckEhC5G42Zl",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "33bee477-d992-4d0e-a5f0-ee6882344218"
      },
      "cell_type": "code",
      "source": [
        "# Importar la librería que se va a utilizar\n",
        "import cvxpy as cvx\n",
        "\n",
        "# Crear las variables a optimizar\n",
        "x = cvx.Variable()\n",
        "y = cvx.Variable()\n",
        "\n",
        "# Definir la función objetivo para maximizar el ingreso\n",
        "obj = cvx.Maximize(8*x + 5*y)\n",
        "\n",
        "# Establecer las restricciones\n",
        "restricciones00 = [\n",
        "\n",
        "# Primera restricción\n",
        "x + y <= 6,\n",
        "\n",
        "# Segunda restricción\n",
        "9*x + 5*y <= 45,\n",
        "\n",
        "# Restricciones de no negatividad\n",
        "x >= 0,\n",
        "y >= 0\n",
        "]\n",
        "\n",
        "# Configurar el problema\n",
        "prob00 = cvx.Problem(obj, restricciones00)\n",
        "\n",
        "# Obtener el valor óptimo\n",
        "prob00.solve()\n",
        "\n",
        "# Mostrar el estado de la solución y el valor óptimo de la función objetivo\n",
        "print(\"Estado de la solución:\", prob00.status)\n",
        "print(\"Valor máximo:\", \"%.2f\"% prob00.value)\n",
        "\n",
        "# Mostrar los valores óptimos de las variables de decisión\n",
        "print (\"Valor óptimo de x:\", \"%.2f\"% x.value)\n",
        "print(\"Valor óptimo de y:\", \"%.2f\"% y.value)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Estado de la solución: optimal\n",
            "Valor máximo: 41.25\n",
            "Valor óptimo de x: 3.75\n",
            "Valor óptimo de y: 2.25\n"
          ]
        }
      ]
    },
    {
      "metadata": {
        "id": "o514QsKI42Zj"
      },
      "cell_type": "markdown",
      "source": [
        "## subproblema01\n",
        "\n",
        "Max Z = 8\\* x + 5\\* y\n",
        "\n",
        "   x   +   y    <=  6\n",
        "   \n",
        "   9 \\* x       + 5\\* y        < =  45\n",
        "   \n",
        "   **x <= 3**\n",
        "\n",
        "   x   > = 0      \n",
        "\n",
        "   y   >=  0\n",
        "\n",
        "**x, y enteros**\n"
      ]
    },
    {
      "metadata": {
        "id": "3zMLv2FPAEh7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "38cd53a6-b0d5-4599-e762-ca75e8d8e47c"
      },
      "cell_type": "code",
      "source": [
        "# Importar la librería que se va a utilizar\n",
        "import cvxpy as cvx\n",
        "\n",
        "# Crear las variables a optimizar\n",
        "x = cvx.Variable()\n",
        "y = cvx.Variable()\n",
        "\n",
        "# Definir la función objetivo para maximizar el ingreso\n",
        "obj = cvx.Maximize(8*x + 5*y)\n",
        "\n",
        "# Establecer las restricciones\n",
        "restricciones01 = [\n",
        "\n",
        "# Primera restricción\n",
        "x + y <= 6,\n",
        "\n",
        "# Segunda restricción\n",
        "9*x + 5*y <= 45,\n",
        "\n",
        "# Restricciones subproblemas\n",
        "x <= 3,\n",
        "\n",
        "# Restricciones de no negatividad\n",
        "x >= 0,\n",
        "y >= 0\n",
        "]\n",
        "\n",
        "# Configurar el problema\n",
        "prob01 = cvx.Problem(obj, restricciones01)\n",
        "\n",
        "# Obtener el valor óptimo\n",
        "prob01.solve()\n",
        "\n",
        "# Mostrar el estado de la solución y el valor óptimo de la función objetivo\n",
        "print(\"Estado de la solución:\", prob01.status)\n",
        "print(\"Valor máximo:\", \"%.2f\"% prob01.value)\n",
        "\n",
        "# Mostrar los valores óptimos de las variables de decisión\n",
        "print (\"Valor óptimo de x:\", \"%.2f\"% x.value)\n",
        "print(\"Valor óptimo de y:\", \"%.2f\"% y.value)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Estado de la solución: optimal\n",
            "Valor máximo: 39.00\n",
            "Valor óptimo de x: 3.00\n",
            "Valor óptimo de y: 3.00\n"
          ]
        }
      ]
    },
    {
      "metadata": {
        "id": "I0-WTP1R-VRn"
      },
      "cell_type": "markdown",
      "source": [
        "## subproblema02\n",
        "\n",
        "Max Z = 8\\* x + 5\\* y\n",
        "\n",
        "   x   +   y    <=  6\n",
        "   \n",
        "   9 \\* x       + 5\\* y        < =  45\n",
        "\n",
        "   **x >= 4**      \n",
        "\n",
        "   y   >=  0\n",
        "\n",
        "**x, y enteros**\n"
      ]
    },
    {
      "metadata": {
        "id": "ahtSo8F2-VRq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b41204a7-f38d-459f-849a-3a830948a636"
      },
      "cell_type": "code",
      "source": [
        "# Importar la librería que se va a utilizar\n",
        "import cvxpy as cvx\n",
        "\n",
        "# Crear las variables a optimizar\n",
        "x = cvx.Variable()\n",
        "y = cvx.Variable()\n",
        "\n",
        "# Definir la función objetivo para maximizar el ingreso\n",
        "obj = cvx.Maximize(8*x + 5*y)\n",
        "\n",
        "# Establecer las restricciones\n",
        "restricciones02 = [\n",
        "\n",
        "# Primera restricción\n",
        "x + y <= 6,\n",
        "\n",
        "# Segunda restricción\n",
        "9*x + 5*y <= 45,\n",
        "\n",
        "# Restricciones subproblemas\n",
        "x >= 4,\n",
        "\n",
        "# Restricciones de no negatividad\n",
        "y >= 0\n",
        "]\n",
        "\n",
        "# Configurar el problema\n",
        "prob02 = cvx.Problem(obj, restricciones02)\n",
        "\n",
        "# Obtener el valor óptimo\n",
        "prob02.solve()\n",
        "\n",
        "# Mostrar el estado de la solución y el valor óptimo de la función objetivo\n",
        "print(\"Estado de la solución:\", prob02.status)\n",
        "print(\"Valor máximo:\", \"%.2f\"% prob02.value)\n",
        "\n",
        "# Mostrar los valores óptimos de las variables de decisión\n",
        "print (\"Valor óptimo de x:\", \"%.2f\"% x.value)\n",
        "print(\"Valor óptimo de y:\", \"%.2f\"% y.value)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Estado de la solución: optimal\n",
            "Valor máximo: 41.00\n",
            "Valor óptimo de x: 4.00\n",
            "Valor óptimo de y: 1.80\n"
          ]
        }
      ]
    },
    {
      "metadata": {
        "id": "W6AYK5EKu6Iq"
      },
      "cell_type": "markdown",
      "source": [
        "## subproblema03\n",
        "\n",
        "Max Z = 8\\* x + 5\\* y\n",
        "\n",
        "   x   +   y    <=  6\n",
        "   \n",
        "   9 \\* x       + 5\\* y        < =  45\n",
        "\n",
        "   **x >= 4**      \n",
        "\n",
        "  **y >= 2**\n",
        "\n",
        "**x, y enteros**\n"
      ]
    },
    {
      "metadata": {
        "id": "MMSmVuNCpwRI",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 262
        },
        "outputId": "8ae96676-7bc0-4ba8-ef73-e3a2670c73d5"
      },
      "cell_type": "code",
      "source": [
        "# Importar la librería que se va a utilizar\n",
        "import cvxpy as cvx\n",
        "\n",
        "# Crear las variables a optimizar\n",
        "x = cvx.Variable()\n",
        "y = cvx.Variable()\n",
        "\n",
        "# Definir la función objetivo para maximizar el ingreso\n",
        "obj = cvx.Maximize(8*x + 5*y)\n",
        "\n",
        "# Establecer las restricciones\n",
        "restricciones03 = [\n",
        "\n",
        "# Primera restricción\n",
        "x + y <= 6,\n",
        "\n",
        "# Segunda restricción\n",
        "9*x + 5*y <= 45,\n",
        "\n",
        "# Restricciones subproblemas\n",
        "x >= 4,\n",
        "y >= 2\n",
        "\n",
        "# Restricciones de no negatividad\n",
        "\n",
        "]\n",
        "\n",
        "# Configurar el problema\n",
        "prob03 = cvx.Problem(obj, restricciones03)\n",
        "\n",
        "# Obtener el valor óptimo\n",
        "prob03.solve()\n",
        "\n",
        "# Mostrar el estado de la solución y el valor óptimo de la función objetivo\n",
        "print(\"Estado de la solución:\", prob03.status)\n",
        "print(\"Valor máximo:\", \"%.2f\"% prob03.value)\n",
        "\n",
        "# Mostrar los valores óptimos de las variables de decisión\n",
        "print (\"Valor óptimo de x:\", \"%.2f\"% x.value)\n",
        "print(\"Valor óptimo de y:\", \"%.2f\"% y.value)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Estado de la solución: infeasible\n",
            "Valor máximo: -inf\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-24-bbd9047040f7>\u001b[0m in \u001b[0;36m<cell line: 39>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     37\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     38\u001b[0m \u001b[0;31m# Mostrar los valores óptimos de las variables de decisión\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 39\u001b[0;31m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"Valor óptimo de x:\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"%.2f\"\u001b[0m\u001b[0;34m%\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     40\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Valor óptimo de y:\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"%.2f\"\u001b[0m\u001b[0;34m%\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mTypeError\u001b[0m: must be real number, not NoneType"
          ]
        }
      ]
    },
    {
      "metadata": {
        "id": "j7qv3hapAEht"
      },
      "cell_type": "markdown",
      "source": [
        "## subproblema04\n",
        "\n",
        "Max Z = 8\\* x + 5\\* y\n",
        "\n",
        "   x   +   y    <=  6\n",
        "   \n",
        "   9 \\* x       + 5\\* y        < =  45\n",
        "\n",
        "   **x >= 4**      \n",
        "   \n",
        "   **y <= 1**\n",
        "\n",
        "   y   >=  0\n",
        "\n",
        "**x, y enteros**\n"
      ]
    },
    {
      "metadata": {
        "id": "d09TUiV5AEh0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0d501ba1-227c-4551-dc8e-c22a6937c18e"
      },
      "cell_type": "code",
      "source": [
        "# Importar la librería que se va a utilizar\n",
        "import cvxpy as cvx\n",
        "\n",
        "# Crear las variables a optimizar\n",
        "x = cvx.Variable()\n",
        "y = cvx.Variable()\n",
        "\n",
        "# Definir la función objetivo para maximizar el ingreso\n",
        "obj = cvx.Maximize(8*x + 5*y)\n",
        "\n",
        "# Establecer las restricciones\n",
        "restricciones04 = [\n",
        "\n",
        "# Primera restricción\n",
        "x + y <= 6,\n",
        "\n",
        "# Segunda restricción\n",
        "9*x + 5*y <= 45,\n",
        "\n",
        "# Restricciones subproblemas\n",
        "x >= 4,\n",
        "y <= 1,\n",
        "\n",
        "# Restricciones de no negatividad\n",
        "y >= 0\n",
        "]\n",
        "\n",
        "# Configurar el problema\n",
        "prob04 = cvx.Problem(obj, restricciones04)\n",
        "\n",
        "# Obtener el valor óptimo\n",
        "prob04.solve()\n",
        "\n",
        "# Mostrar el estado de la solución y el valor óptimo de la función objetivo\n",
        "print(\"Estado de la solución:\", prob04.status)\n",
        "print(\"Valor máximo:\", \"%.2f\"% prob04.value)\n",
        "\n",
        "# Mostrar los valores óptimos de las variables de decisión\n",
        "print (\"Valor óptimo de x:\", \"%.2f\"% x.value)\n",
        "print(\"Valor óptimo de y:\", \"%.2f\"% y.value)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Estado de la solución: optimal\n",
            "Valor máximo: 40.56\n",
            "Valor óptimo de x: 4.44\n",
            "Valor óptimo de y: 1.00\n"
          ]
        }
      ]
    },
    {
      "metadata": {
        "id": "KXEnpFs5F7CO"
      },
      "cell_type": "markdown",
      "source": [
        "## subproblema05\n",
        "\n",
        "Max Z = 8\\* x + 5\\* y\n",
        "\n",
        "   x   +   y    <=  6\n",
        "   \n",
        "   9 \\* x       + 5\\* y        < =  45\n",
        "\n",
        "   **x >= 5**      \n",
        "   \n",
        "   **y <= 1**\n",
        "\n",
        "   y   >=  0\n",
        "\n",
        "**x, y enteros**\n"
      ]
    },
    {
      "metadata": {
        "id": "DQ_yvjHcF7CR",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "75580aa1-9ba4-424e-d293-8b568c6a014c"
      },
      "cell_type": "code",
      "source": [
        "# Importar la librería que se va a utilizar\n",
        "import cvxpy as cvx\n",
        "\n",
        "# Crear las variables a optimizar\n",
        "x = cvx.Variable()\n",
        "y = cvx.Variable()\n",
        "\n",
        "# Definir la función objetivo para maximizar el ingreso\n",
        "obj = cvx.Maximize(8*x + 5*y)\n",
        "\n",
        "# Establecer las restricciones\n",
        "restricciones05 = [\n",
        "\n",
        "# Primera restricción\n",
        "x + y <= 6,\n",
        "\n",
        "# Segunda restricción\n",
        "9*x + 5*y <= 45,\n",
        "\n",
        "# Restricciones subproblemas\n",
        "x >= 5,\n",
        "y <= 1,\n",
        "\n",
        "# Restricciones de no negatividad\n",
        "y >= 0\n",
        "]\n",
        "\n",
        "# Configurar el problema\n",
        "prob05 = cvx.Problem(obj, restricciones05)\n",
        "\n",
        "# Obtener el valor óptimo\n",
        "prob05.solve()\n",
        "\n",
        "# Mostrar el estado de la solución y el valor óptimo de la función objetivo\n",
        "print(\"Estado de la solución:\", prob05.status)\n",
        "print(\"Valor máximo:\", \"%.2f\"% prob05.value)\n",
        "\n",
        "# Mostrar los valores óptimos de las variables de decisión\n",
        "print (\"Valor óptimo de x:\", \"%.2f\"% x.value)\n",
        "print(\"Valor óptimo de y:\", \"%.2f\"% y.value)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Estado de la solución: optimal\n",
            "Valor máximo: 40.00\n",
            "Valor óptimo de x: 5.00\n",
            "Valor óptimo de y: 0.00\n"
          ]
        }
      ]
    },
    {
      "metadata": {
        "id": "MBc9HTlxG6Yy"
      },
      "cell_type": "markdown",
      "source": [
        "## subproblema06\n",
        "\n",
        "Max Z = 8\\* x + 5\\* y\n",
        "\n",
        "   x   +   y    <=  6\n",
        "   \n",
        "   9 \\* x       + 5\\* y        < =  45\n",
        "\n",
        "   **x >= 4**      \n",
        "   \n",
        "   **x <= 4**\n",
        "   \n",
        "   **y <= 1**\n",
        "\n",
        "   y   >=  0\n",
        "\n",
        "**x, y enteros**\n"
      ]
    },
    {
      "metadata": {
        "id": "0OCj9mabG6Y1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "57d1cbc9-3109-49ce-9936-95c11caae0ca"
      },
      "cell_type": "code",
      "source": [
        "# Importar la librería que se va a utilizar\n",
        "import cvxpy as cvx\n",
        "\n",
        "# Crear la variable a optimizar\n",
        "x = cvx.Variable()\n",
        "y = cvx.Variable()\n",
        "\n",
        "# Definir la función objetivo para maximizar el ingreso\n",
        "obj = cvx.Maximize(8*x + 5*y)\n",
        "\n",
        "# Establecer las restricciones\n",
        "restricciones06 = [\n",
        "\n",
        "# Primera restricción\n",
        "x + y <= 6,\n",
        "\n",
        "# Segunda restricción\n",
        "9*x + 5*y <= 45,\n",
        "\n",
        "# Restricciones subproblemas\n",
        "x >= 4,\n",
        "x <=4,\n",
        "y <= 1,\n",
        "\n",
        "# Restricciones de no negatividad\n",
        "y >= 0\n",
        "]\n",
        "\n",
        "# Configurar el problema\n",
        "prob06 = cvx.Problem(obj, restricciones06)\n",
        "\n",
        "# Obtener el valor óptimo\n",
        "prob06.solve()\n",
        "\n",
        "# Mostrar el estado de la solución y el valor óptimo de la función objetivo\n",
        "print(\"Estado de la solución:\", prob06.status)\n",
        "print(\"Valor máximo:\", \"%.2f\"% prob06.value)\n",
        "\n",
        "# Mostrar los valores óptimos de las variables de decisión\n",
        "print (\"Valor óptimo de x:\", \"%.2f\"% x.value)\n",
        "print(\"Valor óptimo de y:\", \"%.2f\"% y.value)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Estado de la solución: optimal\n",
            "Valor máximo: 37.00\n",
            "Valor óptimo de x: 4.00\n",
            "Valor óptimo de y: 1.00\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Resumen del Branch and Bound\n",
        "## Problema inicial: problema00\n",
        "Restricciones: x>=0; y>=0     \n",
        "\n",
        "Resultados: valor óptimo: 41.25; x.value = 3.75; y.value = 2.25\n",
        "\n",
        "## subproblema01\n",
        "Restricciones: x>=0; **x<=3**; y>=0     \n",
        "\n",
        "Resultados: valor óptimo: 39.00; **x.value = 3.00**; **y.value = 3.00**\n",
        "\n",
        "## subproblema02\n",
        "Restricciones: **x>=4**; y>=0     \n",
        "\n",
        "Resultados: valor óptimo: 41.00; x.value = 4.00; y.value = 1.80\n",
        "\n",
        "## subproblema03\n",
        "Restricciones: **x>=4**; **y >=2**     \n",
        "\n",
        "Resultados: valor óptimo: infeasible; x.value = ???; y.value = ???\n",
        "\n",
        "## subproblema04\n",
        "Restricciones: **x>=4**; y>=0; **y <=1**     \n",
        "\n",
        "Resultados: valor óptimo: 40.56; x.value = 4.44; y.value = 1.00\n",
        "\n",
        "## subproblema05\n",
        "Restricciones: **x>=5**; y>=0; **y <=1**\n",
        "\n",
        "Resultados: valor óptimo: 40.00; **x.value = 5.00; y.value = 0.00**\n",
        "\n",
        "## subproblema06\n",
        "Restricciones: **x>=4**; **x<=4**; y>=0; **y <=1**     \n",
        "\n",
        "Resultados: valor óptimo: 37.00; **x.value = 4.0; y.value = 1.0**"
      ],
      "metadata": {
        "id": "qF3dsXtCa8LB"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Análisis de los resultados del Branch and Bound\n",
        "\n",
        "Los subproblemas 01, 05 y 06 tienen una solución óptima factible (soluciones enteras).\n",
        "\n",
        "## subproblema01\n",
        "Restricciones: x>=0; **x<=3**; y>=0\n",
        "\n",
        "Resultados: **valor óptimo: 39.00; x.value = 3.00; y.value = 3.00**\n",
        "\n",
        "## subproblema05\n",
        "Restricciones: **x>=5**; y>=0; **y <=1**\n",
        "\n",
        "Resultados: **valor óptimo: 40.00; x.value = 4.0; y.value = 1.0**\n",
        "\n",
        "## subproblema06\n",
        "Restricciones: x>=4; x<=4; y>=0; y <=1\n",
        "\n",
        "Resultados: **valor óptimo: 37.00; x.value = 4.0; y.value = 1.0**\n",
        "\n",
        "Se selecciona como solución optima la del subproblema 05, ya que satisface las restricciones de enteros y genera el mayor valor óptimo.\n"
      ],
      "metadata": {
        "id": "iM5ZOoR6dHBe"
      }
    },
    {
      "metadata": {
        "id": "39n80aHZ75WO"
      },
      "cell_type": "markdown",
      "source": [
        "# Problema inicial: problema00 resuelto directamente por CVXPY\n",
        "\n",
        "Max Z = 8\\* x + 5\\* y\n",
        "\n",
        "   x   +   y    <=  6\n",
        "   \n",
        "   9 \\* x       + 5\\* y        < =  45\n",
        "\n",
        "   x   > = 0      \n",
        "\n",
        "   y   >=  0\n",
        "\n",
        "**x, y enteros**\n"
      ]
    },
    {
      "metadata": {
        "id": "EPmwVAHU75WO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cb862347-75a9-49a1-dc4a-3c344030d25b"
      },
      "cell_type": "code",
      "source": [
        "# Importar la librería que se va a utilizar\n",
        "import cvxpy as cvx\n",
        "\n",
        "# Crear las variables a optimizar y establecerlas como enteros\n",
        "x = cvx.Variable(integer=True)\n",
        "y = cvx.Variable(integer=True)\n",
        "\n",
        "# Definir la función objetivo para maximizar el ingreso\n",
        "obj = cvx.Maximize(8*x + 5*y)\n",
        "\n",
        "# Establecer las restricciones\n",
        "restricciones_int = [\n",
        "\n",
        "# Primera restricción\n",
        "x + y <= 6,\n",
        "\n",
        "# Segunda restricción\n",
        "9*x + 5*y <= 45,\n",
        "\n",
        "# Restricciones de no negatividad\n",
        "x >= 0,\n",
        "y >= 0\n",
        "]\n",
        "\n",
        "# Configurar el problema\n",
        "prob_int = cvx.Problem(obj, restricciones_int)\n",
        "\n",
        "# Obtener el valor óptimo\n",
        "prob_int.solve()\n",
        "\n",
        "# Mostrar el estado de la solución y el valor óptimo de la función objetivo\n",
        "print(\"Estado de la solución:\", prob_int.status)\n",
        "print(\"Valor máximo:\", \"%.2f\"% prob_int.value)\n",
        "\n",
        "# Mostrar los valores óptimos de las variables de decisión\n",
        "print (\"Valor óptimo de x:\", \"%.2f\"% x.value)\n",
        "print(\"Valor óptimo de y:\", \"%.2f\"% y.value, \"\\n\")\n",
        "\n",
        "# Soluciones con ECOS_BB\n",
        "print (\"Soluciones con ECOS_BB\")\n",
        "\n",
        "# Resolver con ECOS_bb\n",
        "prob_int.solve(solver=cvx.ECOS_BB, mi_max_iters = 1000,\n",
        "               mi_abs_eps= 1e-6, mi_rel_eps = 1e-3, verbose = True)\n",
        "\n",
        "# prob_int.solve(solver=cvx.ECOS_BB, mi_max_iters = 1000,\n",
        "#               mi_abs_eps= 1e-6, mi_rel_eps = 1e-3)\n",
        "\n",
        "# Mostrar el estado de la solución  con ECOS_BB\n",
        "print(\"Estado de la solución con ECOS_BB:\", prob_int.status)\n",
        "\n",
        "print(\"Valor óptimo de la función objetivo con ECOS_BB:\", prob_int.value)\n",
        "\n",
        "# Mostrar los valores óptimos de las variables de decisión con ECOS_BB\n",
        "print(\"Valores óptimos de las variables de decisión con ECOS_BB:\",\n",
        "      x.value, y.value, \"\\n\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Estado de la solución: optimal\n",
            "Valor máximo: 40.00\n",
            "Valor óptimo de x: 5.00\n",
            "Valor óptimo de y: 0.00 \n",
            "\n",
            "Soluciones con ECOS_BB\n",
            "===============================================================================\n",
            "                                     CVXPY                                     \n",
            "                                     v1.3.2                                    \n",
            "===============================================================================\n",
            "(CVXPY) Oct 03 03:28:21 PM: Your problem has 2 variables, 4 constraints, and 0 parameters.\n",
            "(CVXPY) Oct 03 03:28:21 PM: It is compliant with the following grammars: DCP, DQCP\n",
            "(CVXPY) Oct 03 03:28:21 PM: (If you need to solve this problem multiple times, but with different data, consider using parameters.)\n",
            "(CVXPY) Oct 03 03:28:21 PM: CVXPY will first compile your problem; then, it will invoke a numerical solver to obtain a solution.\n",
            "-------------------------------------------------------------------------------\n",
            "                                  Compilation                                  \n",
            "-------------------------------------------------------------------------------\n",
            "(CVXPY) Oct 03 03:28:21 PM: Compiling problem (target solver=ECOS_BB).\n",
            "(CVXPY) Oct 03 03:28:21 PM: Reduction chain: FlipObjective -> Dcp2Cone -> CvxAttr2Constr -> ConeMatrixStuffing -> ECOS_BB\n",
            "(CVXPY) Oct 03 03:28:21 PM: Applying reduction FlipObjective\n",
            "(CVXPY) Oct 03 03:28:21 PM: Applying reduction Dcp2Cone\n",
            "(CVXPY) Oct 03 03:28:21 PM: Applying reduction CvxAttr2Constr\n",
            "(CVXPY) Oct 03 03:28:21 PM: Applying reduction ConeMatrixStuffing\n",
            "(CVXPY) Oct 03 03:28:21 PM: Applying reduction ECOS_BB\n",
            "(CVXPY) Oct 03 03:28:21 PM: Finished problem compilation (took 3.238e-02 seconds).\n",
            "-------------------------------------------------------------------------------\n",
            "                                Numerical solver                               \n",
            "-------------------------------------------------------------------------------\n",
            "(CVXPY) Oct 03 03:28:21 PM: Invoking solver ECOS_BB  to obtain a solution.\n",
            "-------------------------------------------------------------------------------\n",
            "                                    Summary                                    \n",
            "-------------------------------------------------------------------------------\n",
            "(CVXPY) Oct 03 03:28:21 PM: Problem status: optimal\n",
            "(CVXPY) Oct 03 03:28:21 PM: Optimal value: 4.000e+01\n",
            "(CVXPY) Oct 03 03:28:21 PM: Compilation took 3.238e-02 seconds\n",
            "(CVXPY) Oct 03 03:28:21 PM: Solver (including time spent in interface) took 4.286e-03 seconds\n",
            "Estado de la solución con ECOS_BB: optimal\n",
            "Valor óptimo de la función objetivo con ECOS_BB: 40.00000000257336\n",
            "Valores óptimos de las variables de decisión con ECOS_BB: 5.000000000095518 3.618420463843465e-10 \n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Problema inicial: problema00 resuelto con MOSEK\n",
        "\n",
        "Max Z = 8\\* x + 5\\* y\n",
        "\n",
        "   x   +   y    <=  6\n",
        "   \n",
        "   9 \\* x       + 5\\* y        < =  45\n",
        "\n",
        "   x   > = 0      \n",
        "\n",
        "   y   >=  0\n",
        "\n",
        "**x, y enteros**"
      ],
      "metadata": {
        "id": "UYsRyFLamBqQ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Instalar MOSEK"
      ],
      "metadata": {
        "id": "0XUIesHJmERV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Instalar MOSEK en Google Colab\n",
        "!pip install mosek"
      ],
      "metadata": {
        "id": "ooc0H5xOqtus",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6697091b-ef15-403b-ee0b-96603338265b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: mosek in /usr/local/lib/python3.10/dist-packages (10.1.12)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from mosek) (1.23.5)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Verificar la instalación de MOSEK"
      ],
      "metadata": {
        "id": "BhABHtg8LSet"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importar las librerías requeridas\n",
        "import cvxpy as cvx\n",
        "import mosek\n",
        "\n",
        "# Verificar los solvers disponibles\n",
        "print(cvx.installed_solvers())"
      ],
      "metadata": {
        "id": "KmlMNJ3Wp20y",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "faf6af1d-08e3-4135-c39b-8d9b007b6b33"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['CVXOPT', 'ECOS', 'ECOS_BB', 'GLPK', 'GLPK_MI', 'MOSEK', 'OSQP', 'SCIPY', 'SCS']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Aviso importante\n",
        "\n",
        "Antes de ejecutar cvxpy con el solver MOSEK es necesario subir el archivo con la licencia de MOSEK (mosek.lic) para crear la ruta /root/mosek/mosek.lic\n",
        "\n",
        "**Este paso hay que repetirlo cada vez que se vaya a utilizar MOSEK porque desaparece cuando se reinicia el entorno de ejecución**.\n",
        "\n",
        "En el siguiente enlace puede solicitar una licencia académica **gratuita** de MOSEK: [MOSEK Academic Licenses](https://www.mosek.com/products/academic-licenses/)"
      ],
      "metadata": {
        "id": "P6trz1A2G1DT"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Solución del problema00 con MOSEK"
      ],
      "metadata": {
        "id": "wzV4jJCWY9of"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importar las librerías que se van a utilizar\n",
        "import cvxpy as cvx\n",
        "from mosek.fusion import *\n",
        "\n",
        "# Crear las variables a optimizar y establecerlas como enteros\n",
        "x = cvx.Variable(integer=True)\n",
        "y = cvx.Variable(integer=True)\n",
        "\n",
        "# Definir la función objetivo para maximizar el ingreso\n",
        "obj = cvx.Maximize(8*x + 5*y)\n",
        "\n",
        "# Establecer las restricciones\n",
        "restricciones_msk = [\n",
        "\n",
        "# Primera restricción\n",
        "x + y <= 6,\n",
        "\n",
        "# Segunda restricción\n",
        "9*x + 5*y <= 45,\n",
        "\n",
        "# Restricciones de no negatividad\n",
        "x >= 0,\n",
        "y >= 0\n",
        "]\n",
        "\n",
        "# Configurar el problema\n",
        "prob_msk = cvx.Problem(obj, restricciones_msk)\n",
        "\n",
        "# Obtener el valor óptimo\n",
        "prob_msk.solve()\n",
        "\n",
        "# Resolver con MOSEK\n",
        "prob_msk.solve(solver=cvx.MOSEK)\n",
        "#prob_msk.solve(solver=cvx.MOSEK, verbose = True)\n",
        "\n",
        "# Mostrar el estado de la solución  con MOSEK\n",
        "print(\"Estado de la solución con MOSEK:\", prob_msk.status)\n",
        "\n",
        "print(\"Valor óptimo de la función objetivo con MOSEK:\", prob_msk.value)\n",
        "\n",
        "# Mostrar los valores óptimos de las variables de decisión con MOSEK\n",
        "print(\"Valores óptimos de las variables de decisión con \")\n",
        "print(\"Valor óptimo de x con MOSEK:\", x.value)\n",
        "print(\"Valor óptimo de y con MOSEK:\", y.value)"
      ],
      "metadata": {
        "id": "F2y6HzDNIXbK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a300ae64-2977-45b4-c5ee-e372c9207d12"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Estado de la solución con MOSEK: optimal\n",
            "Valor óptimo de la función objetivo con MOSEK: 40.0\n",
            "Valores óptimos de las variables de decisión con \n",
            "Valor óptimo de x con MOSEK: 5.0\n",
            "Valor óptimo de y con MOSEK: 0.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Ejercicios"
      ],
      "metadata": {
        "id": "ia3dw24BZHq6"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 00.\n",
        "Resuelva con el método **Branch and Bound**, utilizando CVXPY, el ejemplo 9.2-1 del libro de (TAHA, 2012) página 336."
      ],
      "metadata": {
        "id": "08XSuUcAZK2n"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "eR10BZQjaRjM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 01.\n",
        "Resuelva directamente, utilizando CVXPY, el ejemplo 9.2-1 del libro de (TAHA, 2012) página 336."
      ],
      "metadata": {
        "id": "D4vzr-ANcoUe"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "WbJOyqR7c4TM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 02.\n",
        "Resuelva con MOSEK, utilizando CVXPY, el ejemplo 9.2-1 del libro de (TAHA, 2012) página 336."
      ],
      "metadata": {
        "id": "TCCMOfTjc7n0"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "HV3a-DUldEJK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 03.\n",
        "Resuelva con el método **Branch and Bound**, utilizando CVXPY, **uno** de los cinco numerales del ejercicio 2 del conjunto de problemas 9.2a del libro de (TAHA, 2012) página 342."
      ],
      "metadata": {
        "id": "9Ei2tKLdas7d"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "CbtbB7TvbLCO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 04.\n",
        "Resuelva directamente, utilizando CVXPY, **uno** de los cinco numerales del ejercicio 2 del conjunto de problemas 9.2a del libro de (TAHA, 2012) página 342.\n",
        "\n",
        "Sugerencia: utilice el mismo numeral utilizado en el ejercicio 03."
      ],
      "metadata": {
        "id": "6JifXyZvdK5o"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "pM_qqkIIdm_e"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 05.\n",
        "Resuelva con MOSEK, utilizando CVXPY, **uno** de los cinco numerales del ejercicio 2 del conjunto de problemas 9.2a del libro de (TAHA, 2012) página 342.\n",
        "\n",
        "Sugerencia: utilice el mismo numeral utilizado en el ejercicio 03."
      ],
      "metadata": {
        "id": "IriDQJMzdnw6"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "X4mneG5Adz8O"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}