Método_Simplex_revisado.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "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/silviootero/Trabajo-de-Programacion-Lineal/blob/main/M%C3%A9todo_Simplex_revisado.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**ESTRUCTURA MEJOR ESTABLECIDA**"
      ],
      "metadata": {
        "id": "CHyigfhZMtsO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Solicitar al usuario que ingrese los datos\n",
        "def obtener_datos():\n",
        "    num_variables = int(input(\"Ingrese el número de variables en la función objetivo: \"))\n",
        "    num_restricciones = int(input(\"Ingrese el número de restricciones: \"))\n",
        "\n",
        "    c = np.array([float(x) for x in input(\"Ingrese los coeficientes de la función objetivo separados por espacios: \").split()])\n",
        "    A = np.array([[float(x) for x in input(f\"Ingrese los coeficientes de la restricción {i+1} separados por espacios: \").split()] for i in range(num_restricciones)])\n",
        "    b = np.array([float(x) for x in input(\"Ingrese los términos independientes de las restricciones separados por espacios: \").split()])\n",
        "\n",
        "    return c, A, b\n",
        "\n",
        "# Obtener los datos del usuario\n",
        "c, A, b = obtener_datos()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "P5atp9KkTXBC",
        "outputId": "eabb21f5-f410-44ec-deef-e679e243e66c"
      },
      "execution_count": 23,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Ingrese el número de variables en la función objetivo: 2\n",
            "Ingrese el número de restricciones: 4\n",
            "Ingrese los coeficientes de la función objetivo separados por espacios: 5 4\n",
            "Ingrese los coeficientes de la restricción 1 separados por espacios: 6 4\n",
            "Ingrese los coeficientes de la restricción 2 separados por espacios: 1 2\n",
            "Ingrese los coeficientes de la restricción 3 separados por espacios: -1 1\n",
            "Ingrese los coeficientes de la restricción 4 separados por espacios: 0 1\n",
            "Ingrese los términos independientes de las restricciones separados por espacios: 24 6 1 2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "# Coeficientes de la función objetivo\n",
        "c = np.array([3, 2])\n",
        "\n",
        "# Matriz de coeficientes de las restricciones\n",
        "A = np.array([[2, 1], [1, 2]])\n",
        "\n",
        "# Términos independientes de las restricciones\n",
        "b = np.array([4, 6])"
      ],
      "metadata": {
        "id": "laApujO_Lzwy"
      },
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "def crear_matriz_simplex(A, b, c):\n",
        "    \"\"\"\n",
        "    Crea la matriz simplex inicial a partir de los coeficientes de la función objetivo,\n",
        "    las restricciones y las variables.\n",
        "\n",
        "    Args:\n",
        "        A: Matriz de coeficientes de las restricciones (m x n).\n",
        "        b: Vector de términos independientes de las restricciones (m x 1).\n",
        "        c: Vector de coeficientes de la función objetivo (n x 1).\n",
        "\n",
        "    Returns:\n",
        "        matriz_simplex: Matriz simplex inicial aumentada (m x n+m+1).\n",
        "    \"\"\"\n",
        "    n = A.shape[1]  # Número de variables\n",
        "    m = A.shape[0]  # Número de restricciones\n",
        "\n",
        "    # Crea la matriz simplex aumentada con variables de holgura\n",
        "    matriz_simplex = np.zeros((m + 1, n + m + 1))\n",
        "    matriz_simplex[:m, :n] = A\n",
        "    matriz_simplex[:m, n:n+m] = np.eye(m)\n",
        "    matriz_simplex[:m, -1] = b\n",
        "    matriz_simplex[-1, :n] = -c\n",
        "\n",
        "    return matriz_simplex"
      ],
      "metadata": {
        "id": "0w0r-JcvGlz7"
      },
      "execution_count": 30,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def identificar_variable_pivote(matriz_simplex):\n",
        "    \"\"\"\n",
        "    Identifica la variable de entrada básica que debe salir de la base y la variable\n",
        "    de no-entrada básica que debe entrar.\n",
        "\n",
        "    Args:\n",
        "        matriz_simplex: Matriz simplex actual (m x n+1).\n",
        "\n",
        "    Returns:\n",
        "        var_entrada: Índice de la variable de entrada básica que debe salir de la base.\n",
        "        var_no_entrada: Índice de la variable de no-entrada básica que debe entrar.\n",
        "    \"\"\"\n",
        "    # Obtiene el índice de la columna con el costo reducido más negativo\n",
        "    var_no_entrada = np.argmin(matriz_simplex[-1, :-1])\n",
        "\n",
        "    # Si todos los costos reducidos son no negativos, ya se encontró la solución óptima\n",
        "    if matriz_simplex[-1, var_no_entrada] >= 0:\n",
        "        return None, None\n",
        "\n",
        "    # Identifica la variable de entrada básica que debe salir de la base\n",
        "    ratio_min = np.inf\n",
        "    var_entrada = None\n",
        "    for i in range(matriz_simplex.shape[0] - 1):\n",
        "        if matriz_simplex[i, var_no_entrada] > 0:\n",
        "            ratio = matriz_simplex[i, -1] / matriz_simplex[i, var_no_entrada]\n",
        "            if ratio < ratio_min:\n",
        "                ratio_min = ratio\n",
        "                var_entrada = i\n",
        "\n",
        "    return var_entrada, var_no_entrada"
      ],
      "metadata": {
        "id": "XpbSXOGdKiUa"
      },
      "execution_count": 31,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def verificar_optimalidad(matriz_simplex):\n",
        "    \"\"\"\n",
        "    Verifica si la solución actual es óptima.\n",
        "\n",
        "    Args:\n",
        "        matriz_simplex: Matriz simplex actual (m x n+1).\n",
        "\n",
        "    Returns:\n",
        "        True si la solución es óptima, False en caso contrario.\n",
        "    \"\"\"\n",
        "    # Si todos los costos reducidos son no negativos, ya se encontró la solución óptima\n",
        "    if np.all(matriz_simplex[-1, :-1] >= 0):\n",
        "        return True\n",
        "    else:\n",
        "        return False"
      ],
      "metadata": {
        "id": "eztczwxOKjxm"
      },
      "execution_count": 32,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def realizar_pivotacion(matriz_simplex, var_entrada, var_no_entrada):\n",
        "    \"\"\"\n",
        "    Realiza la operación de pivotación en el método simplex.\n",
        "\n",
        "    Args:\n",
        "        matriz_simplex: Matriz simplex actual (m x n+1).\n",
        "        var_entrada: Índice de la variable de entrada básica que debe salir de la base.\n",
        "        var_no_entrada: Índice de la variable de no-entrada básica que debe entrar en la base.\n",
        "    \"\"\"\n",
        "    # Normaliza la fila del pivote (divide la fila por el elemento pivote)\n",
        "    matriz_simplex[var_entrada] /= matriz_simplex[var_entrada, var_no_entrada]\n",
        "\n",
        "    # Elimina los demás elementos en la columna de la variable de entrada\n",
        "    for i in range(matriz_simplex.shape[0]):\n",
        "        if i != var_entrada:\n",
        "            matriz_simplex[i] -= matriz_simplex[i, var_no_entrada] * matriz_simplex[var_entrada]"
      ],
      "metadata": {
        "id": "v7gSUcGUKuig"
      },
      "execution_count": 33,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def mostrar_solucion(matriz_simplex):\n",
        "    \"\"\"\n",
        "    Muestra la solución óptima del problema.\n",
        "\n",
        "    Args:\n",
        "        matriz_simplex: Matriz simplex final (m x n+1).\n",
        "    \"\"\"\n",
        "    n = matriz_simplex.shape[1] - 1  # Número de columnas (sin contar b)\n",
        "    m = matriz_simplex.shape[0] - 1  # Número de filas (sin contar la fila de costos)\n",
        "\n",
        "    variables_basicas = []\n",
        "    valores_basicos = []\n",
        "\n",
        "    # Identificar las variables básicas y sus valores\n",
        "    for j in range(n):\n",
        "        columna = matriz_simplex[:m, j]\n",
        "        if np.count_nonzero(columna) == 1 and np.isclose(np.max(columna), 1):\n",
        "            fila = np.where(columna == 1)[0][0]\n",
        "            variables_basicas.append(j)\n",
        "            valores_basicos.append(matriz_simplex[fila, -1])\n",
        "\n",
        "    # Mostrar la solución\n",
        "    print(\"Variables básicas:\", variables_basicas)\n",
        "    print(\"Valores básicos:\", valores_basicos)\n",
        "    print(\"Valor óptimo de Z:\", -matriz_simplex[-1, -1])"
      ],
      "metadata": {
        "id": "fIHZ6I_-LBtU"
      },
      "execution_count": 34,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Crear la matriz simplex inicial\n",
        "matriz_simplex = crear_matriz_simplex(A, b, c)\n",
        "\n",
        "# Lista para registrar los tableros simplex de cada iteración\n",
        "tableros_simplex = []\n",
        "\n",
        "# Ejecutar el método simplex revisado\n",
        "while True:\n",
        "    # Registrar el tablero actual\n",
        "    tableros_simplex.append(matriz_simplex.copy())\n",
        "\n",
        "    var_entrada, var_no_entrada = identificar_variable_pivote(matriz_simplex)\n",
        "\n",
        "    if var_entrada is None:\n",
        "        break\n",
        "\n",
        "    realizar_pivotacion(matriz_simplex, var_entrada, var_no_entrada)\n",
        "\n",
        "# Verificar la optimalidad\n",
        "if verificar_optimalidad(matriz_simplex):\n",
        "    print(\"Solución óptima encontrada.\")\n",
        "else:\n",
        "    print(\"No se encontró una solución óptima.\")\n",
        "\n",
        "# Mostrar la solución óptima\n",
        "mostrar_solucion(matriz_simplex)\n",
        "\n",
        "# Mostrar todos los tableros simplex registrados\n",
        "for i, tablero in enumerate(tableros_simplex):\n",
        "    print(f\"Tablero simplex de la iteración {i}:\")\n",
        "    print(tablero)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gL-YdW0SK1cT",
        "outputId": "41111beb-6d39-44a7-eb15-7c0e5ad28af0"
      },
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Solución óptima encontrada.\n",
            "Variables básicas: [0, 1, 4, 5]\n",
            "Valores básicos: [3.0, 1.4999999999999998, 2.5000000000000004, 0.5000000000000002]\n",
            "Valor óptimo de Z: -21.0\n",
            "Tablero simplex de la iteración 0:\n",
            "[[ 6.  4.  1.  0.  0.  0. 24.]\n",
            " [ 1.  2.  0.  1.  0.  0.  6.]\n",
            " [-1.  1.  0.  0.  1.  0.  1.]\n",
            " [ 0.  1.  0.  0.  0.  1.  2.]\n",
            " [-5. -4.  0.  0.  0.  0.  0.]]\n",
            "Tablero simplex de la iteración 1:\n",
            "[[ 1.          0.66666667  0.16666667  0.          0.          0.\n",
            "   4.        ]\n",
            " [ 0.          1.33333333 -0.16666667  1.          0.          0.\n",
            "   2.        ]\n",
            " [ 0.          1.66666667  0.16666667  0.          1.          0.\n",
            "   5.        ]\n",
            " [ 0.          1.          0.          0.          0.          1.\n",
            "   2.        ]\n",
            " [ 0.         -0.66666667  0.83333333  0.          0.          0.\n",
            "  20.        ]]\n",
            "Tablero simplex de la iteración 2:\n",
            "[[ 1.     0.     0.25  -0.5    0.     0.     3.   ]\n",
            " [ 0.     1.    -0.125  0.75   0.     0.     1.5  ]\n",
            " [ 0.     0.     0.375 -1.25   1.     0.     2.5  ]\n",
            " [ 0.     0.     0.125 -0.75   0.     1.     0.5  ]\n",
            " [ 0.     0.     0.75   0.5    0.     0.    21.   ]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**MÉTODO GRÁFICO**"
      ],
      "metadata": {
        "id": "OMc31pNQOpAz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from itertools import combinations\n",
        "\n",
        "def get_intersections(A, b):\n",
        "    points = []\n",
        "    num_constraints = len(A)\n",
        "\n",
        "    for i, j in combinations(range(num_constraints), 2):\n",
        "        A_sub = np.array([A[i], A[j]])\n",
        "        b_sub = np.array([b[i], b[j]])\n",
        "        try:\n",
        "            point = np.linalg.solve(A_sub, b_sub)\n",
        "            if all(point >= 0):  # Feasibility check: point must be non-negative\n",
        "                points.append(point)\n",
        "        except np.linalg.LinAlgError:\n",
        "            continue\n",
        "    return np.array(points)\n",
        "\n",
        "def is_feasible(point, A, b):\n",
        "    return np.all(A @ point <= b)\n",
        "\n",
        "def evaluate_objective(points, c):\n",
        "    return points @ c\n",
        "\n",
        "def find_optimal_point(points, c, maximize=True):\n",
        "    values = evaluate_objective(points, c)\n",
        "    if maximize:\n",
        "        optimal_index = np.argmax(values)\n",
        "    else:\n",
        "        optimal_index = np.argmin(values)\n",
        "    return points[optimal_index], values[optimal_index]\n",
        "\n",
        "def plot_feasible_region(A, b, intersection_points, optimal_point=None, x_limits=(0, 10), y_limits=(0, 10)):\n",
        "    fig, ax = plt.subplots()\n",
        "\n",
        "    x = np.linspace(x_limits[0], x_limits[1], 400)\n",
        "\n",
        "    for i in range(len(A)):\n",
        "        if A[i][0] != 0 and A[i][1] != 0:\n",
        "            y = (b[i] - A[i][0] * x) / A[i][1]\n",
        "            ax.plot(x, y, label=f\"Restriccion {A[i][0]}x + {A[i][1]}y = {b[i]}\")\n",
        "\n",
        "        elif A[i][0] == 0:\n",
        "            y = np.full_like(x, b[i] / A[i][1])\n",
        "            ax.plot(x, y, label=f\"Restriccion y = { b[i] / A[i][1]}\")\n",
        "\n",
        "        elif A[i][1] == 0:\n",
        "            xAlt = np.full_like(x, b[i] / A[i][0])\n",
        "            yAlt = np.linspace(y_limits[0], y_limits[1], 400)\n",
        "            ax.plot(xAlt, yAlt, label=f\"Restriccion x = {b[i] / A[i][0]}\")\n",
        "\n",
        "\n",
        "    # Plot the feasible region\n",
        "    feasible_points = np.array([p for p in intersection_points if is_feasible(p, A, b)])\n",
        "    if feasible_points.size > 0:\n",
        "        ax.scatter(feasible_points[:, 0], feasible_points[:, 1], color='green', label='Puntos Factibles')\n",
        "\n",
        "    if optimal_point is not None:\n",
        "        ax.scatter(optimal_point[0], optimal_point[1], color='red', label='Punto Optimo', zorder=5)\n",
        "\n",
        "\n",
        "    plotting_obj_function(x, ax, optimal_point, 18)\n",
        "    plt.xlim(x_limits)\n",
        "    plt.ylim(y_limits)\n",
        "    plt.xlabel('x1')\n",
        "    plt.ylabel('x2')\n",
        "    plt.legend()\n",
        "    plt.grid(True)\n",
        "    plt.title('Metodo grafico de la formula objetivo')\n",
        "    plt.show()\n",
        "\n",
        "def plotting_obj_function(x, ax, optimal_point, calibrator, maximize=True, cambio=0.5):\n",
        "  if maximize:\n",
        "    z = (calibrator - c[0] * x) / c[1]\n",
        "  else:\n",
        "    z = (calibrator + c[0] * x) / c[1]\n",
        "\n",
        "  while True:\n",
        "    if maximize:\n",
        "      ax.plot(x, z, color=\"black\")\n",
        "      z = z + cambio\n",
        "      if np.all(z > np.min(optimal_point)):\n",
        "          break\n",
        "\n",
        "    else:\n",
        "      z = z - cambio\n",
        "      ax.plot(x, z, color=\"black\")\n",
        "      if np.all(z < np.max(optimal_point)):\n",
        "          break\n",
        "\n"
      ],
      "metadata": {
        "id": "_WhNnWTpbOw6"
      },
      "execution_count": 41,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "if len(c) == 2:\n",
        " intersection_points = get_intersections(A, b)\n",
        "\n",
        " if intersection_points.size == 0:\n",
        "     print(\"No se encontro solucion factible.\")\n",
        " else:\n",
        "     feasible_points = np.array([p for p in intersection_points if is_feasible(p, A, b)])\n",
        "     if feasible_points.size == 0:\n",
        "         print(\"No se encontraron soluciones factibles.\")\n",
        "     else:\n",
        "         optimal_point, optimal_value = find_optimal_point(feasible_points, c, maximize=True)\n",
        "         plot_feasible_region(A, b, feasible_points, optimal_point, x_limits=(0, 10), y_limits=(0, 10))\n",
        "         print(\"El punto optimo encontrado, antes de salir de la region factible se encuentra en:\", optimal_point)\n",
        "         print(\"El valor optimo obtenido despues de reemplazar los valores es:\", optimal_value)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 507
        },
        "id": "wqclelLwaORl",
        "outputId": "2b7ea557-4bed-4308-818b-cd0d0f1f9454"
      },
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "El punto optimo encontrado, antes de salir de la region factible se encuentra en: [3.  1.5]\n",
            "El valor optimo obtenido despues de reemplazar los valores es: 21.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**ANÁLISIS DE SENSIBILIDAD**"
      ],
      "metadata": {
        "id": "kWf8Yi7wOuMb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def metodo_simplex(A, b, c):\n",
        "    matriz_simplex = crear_matriz_simplex(A, b, c)\n",
        "    while True:\n",
        "        var_entrada, var_no_entrada = identificar_variable_pivote(matriz_simplex)\n",
        "        if var_entrada is None:\n",
        "            break\n",
        "        realizar_pivotacion(matriz_simplex, var_entrada, var_no_entrada)\n",
        "    return matriz_simplex\n",
        "\n",
        "\n",
        "# Rango de variación del coeficiente de la primera variable\n",
        "coeficientes_variados = np.linspace(3, 7, 5)\n",
        "\n",
        "# Lista para almacenar los resultados\n",
        "resultados = []\n",
        "\n",
        "# Ejecutar el método simplex para cada coeficiente variado\n",
        "for coef_variado in coeficientes_variados:\n",
        "    c_variado = np.array([coef_variado, 4])  # Modificar solo el primer coeficiente\n",
        "    matriz_simplex = metodo_simplex(A, b, c_variado)\n",
        "    valor_optimo_z = -matriz_simplex[-1, -1]  # El valor de Z es el opuesto del valor en la tabla\n",
        "    variables_basicas = []\n",
        "    for i in range(len(A)):\n",
        "        fila_i = matriz_simplex[i, :]\n",
        "        indice_variable = np.nonzero(fila_i)[0][0]\n",
        "        variables_basicas.append((indice_variable, fila_i[-1]))\n",
        "    resultados.append({\n",
        "        \"Coeficiente Variado\": coef_variado,\n",
        "        \"Variables Básicas\": variables_basicas,\n",
        "        \"Valor Óptimo de Z\": valor_optimo_z\n",
        "    })\n",
        "\n",
        "# Mostrar los resultados en una tabla\n",
        "print(\"Tabla de Análisis de Sensibilidad:\")\n",
        "print(\"Coeficiente Variado | Variables Básicas | Valor Óptimo de Z\")\n",
        "for resultado in resultados:\n",
        "    print(\"{:.2f} | {} | {:.2f}\".format(\n",
        "        resultado[\"Coeficiente Variado\"],\n",
        "        resultado[\"Variables Básicas\"],\n",
        "        resultado[\"Valor Óptimo de Z\"]\n",
        "    ))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dBTd9u6qO3nw",
        "outputId": "fa074c29-26d9-40f3-af59-e98d081c15e2"
      },
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Tabla de Análisis de Sensibilidad:\n",
            "Coeficiente Variado | Variables Básicas | Valor Óptimo de Z\n",
            "3.00 | [(2, 0.5), (2, 2.5), (1, 1.5), (0, 3.0)] | -15.00\n",
            "4.00 | [(0, 3.0), (1, 1.4999999999999998), (2, 2.5000000000000004), (2, 0.5000000000000002)] | -18.00\n",
            "5.00 | [(0, 3.0), (1, 1.4999999999999998), (2, 2.5000000000000004), (2, 0.5000000000000002)] | -21.00\n",
            "6.00 | [(0, 4.0), (1, 2.0), (1, 5.0), (1, 2.0)] | -24.00\n",
            "7.00 | [(0, 4.0), (1, 2.0), (1, 5.0), (1, 2.0)] | -28.00\n"
          ]
        }
      ]
    }
  ]
}