P5_OP_mejor.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyOppVFLyVJCyiu9eXkeluTN",
      "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/rociavl/UNI/blob/main/P5_OP_mejor.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Données d'entrée\n",
        "ubi_and_pesos = {\n",
        "    'A': [30, 20, 1], #---> A_peso\n",
        "    'B': [10, 10, 2],\n",
        "    'C': [40, 30, 4], # --> C_peso\n",
        "    'D': [60, 10, 3]\n",
        "}\n",
        "X = 20  # Coût en euros\n",
        "\n",
        "# Función para calcular el óptimo en una dimensión (X o Y)\n",
        "def rectangular(ubi_pesos, pesos):\n",
        "    ubi_pesos = np.array(ubi_pesos)\n",
        "    pesos = np.array(pesos)\n",
        "\n",
        "    # Encontrar las ubicaciones únicas y sus índices\n",
        "    ubi_pesos_uniques, indices = np.unique(ubi_pesos, return_inverse=True)\n",
        "    pesos_uniques = np.zeros_like(ubi_pesos_uniques, dtype=float)\n",
        "\n",
        "    # Sumar los pesos correspondientes a cada ubicación única\n",
        "    for i in range(len(pesos)):\n",
        "        pesos_uniques[indices[i]] += pesos[i]\n",
        "\n",
        "    # Calcular la acumulada y los puntos de las ubicaciones\n",
        "    peso_total = np.sum(pesos_uniques)\n",
        "    acumulada = [-peso_total]\n",
        "    ubicaciones_optimas = []\n",
        "\n",
        "    # Calcular la acumulada para cada ubicación\n",
        "    for i in range(len(pesos_uniques)):\n",
        "        acu = acumulada[i] + pesos_uniques[i] * 2\n",
        "        acumulada.append(acu)\n",
        "\n",
        "    # Encontrar las ubicaciones óptimas donde cambia el signo de la acumulada\n",
        "    for j in range(len(acumulada) - 1):\n",
        "        if acumulada[j] * acumulada[j + 1] < 0:\n",
        "            ubicaciones_optimas.append(ubi_pesos_uniques[j])\n",
        "        elif acumulada[j] == 0:\n",
        "            ubicaciones_optimas.append(ubi_pesos_uniques[j-1])\n",
        "            ubicaciones_optimas.append(ubi_pesos_uniques[j])\n",
        "\n",
        "    return ubicaciones_optimas, acumulada, ubi_pesos_uniques\n",
        "\n",
        "# Función para calcular el óptimo en X e Y\n",
        "def rectangular_x_y(ubi_and_pesos):\n",
        "    ubi_pesos_x = []\n",
        "    ubi_pesos_y = []\n",
        "    pesos = []\n",
        "\n",
        "    # Extraer los valores de X, Y y pesos de cada entrada\n",
        "    for key, value in ubi_and_pesos.items():\n",
        "        ubi_pesos_x.append(value[0])  # X\n",
        "        ubi_pesos_y.append(value[1])  # Y\n",
        "        pesos.append(value[2])  # Peso\n",
        "\n",
        "    # Calcular las ubicaciones óptimas y acumuladas para X e Y\n",
        "    ubicacion_optima_x, acumulada_x, eje_x = rectangular(ubi_pesos_x, pesos)\n",
        "    ubicacion_optima_y, acumulada_y, eje_y = rectangular(ubi_pesos_y, pesos)\n",
        "\n",
        "    return ubicacion_optima_x, acumulada_x, eje_x, ubicacion_optima_y, acumulada_y, eje_y\n",
        "\n",
        "# Obtener las posiciones óptimas, acumuladas y los ejes\n",
        "ubicacion_optima_x, acumulada_x, eje_x, ubicacion_optima_y, acumulada_y, eje_y = rectangular_x_y(ubi_and_pesos)\n",
        "print(acumulada_x, eje_x)\n",
        "print(f\"1. Emplacement optimal en X et Y: {ubicacion_optima_x, ubicacion_optima_y}\")\n",
        "\n",
        "# Stocker les emplacements optimaux\n",
        "ubi_optimas = {'rectangular': [ubicacion_optima_x, ubicacion_optima_y]}\n",
        "# Fonction pour calculer le coût rectangulaire (basé sur la somme des valeurs absolues)\n",
        "def coste_rectangular(ubi_op, ubi_and_pesos,cost_unitari):\n",
        "    ubi_pesos_x = np.array([value[0] for value in ubi_and_pesos.values()])  # Coordonnées X\n",
        "    ubi_pesos_y = np.array([value[1] for value in ubi_and_pesos.values()])  # Coordonnées Y\n",
        "    pesos = np.array([value[2] for value in ubi_and_pesos.values()])  # Poids\n",
        "    # Coût pour X basé sur l'approche rectangulaire (valeur absolue)\n",
        "    coste_x_rect = np.sum(np.abs(ubi_pesos_x - ubi_op['rectangular'][0][0]) * pesos)\n",
        "    # Coût pour Y\n",
        "    coste_y_rect = np.sum(np.abs(ubi_pesos_y - ubi_op['rectangular'][1][0]) * pesos)\n",
        "    # Retourner la somme des coûts X et Y\n",
        "    return (coste_x_rect + coste_y_rect)*cost_unitari, coste_x_rect ,coste_y_rect\n",
        "\n",
        "# Calcul des coûts\n",
        "coste_rect, coste_x_rect ,coste_y_rect = coste_rectangular(ubi_optimas, ubi_and_pesos,X)\n",
        "# Affichage des résultats\n",
        "print(f\"    \\033[1mCoût rectangulaire: {coste_rect} € \\033[0m\")\n",
        "print(f\"      Coût X: {coste_x_rect}\")\n",
        "print(f\"      Coût Y: {coste_y_rect}\")\n",
        "\n",
        "\n",
        "# Función para calcular la distancia euclidiana\n",
        "def distancia_euclidiana(p1, p2):\n",
        "    return np.sqrt((p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2)\n",
        "\n",
        "# Generar puntos cercanos al óptimo para dibujar las líneas isocoste\n",
        "def generar_isocoste(ubicacion_optima_x, ubicacion_optima_y, intersecciones):\n",
        "    # Inicializar variables para encontrar el punto más cercano\n",
        "    distancias_min = np.inf\n",
        "    punto_optimo = None\n",
        "\n",
        "    # Si la ubicación óptima X es un rango (lista o array)\n",
        "    if isinstance(ubicacion_optima_x, (list, np.ndarray)):\n",
        "        # Obtener los extremos del rango\n",
        "        puntos_optimos_x = ubicacion_optima_x\n",
        "    else:\n",
        "        puntos_optimos_x = [ubicacion_optima_x]  # En caso de un solo punto\n",
        "\n",
        "    # Evaluar cada punto en el rango de X óptimos\n",
        "    for x in puntos_optimos_x:\n",
        "        # Crear el punto a evaluar\n",
        "        punto_a_evaluar = np.array([x, ubicacion_optima_y])\n",
        "\n",
        "        # Evaluar cada intersección\n",
        "        for interseccion in intersecciones:\n",
        "            distancia = distancia_euclidiana(punto_a_evaluar, interseccion)\n",
        "\n",
        "            # Actualizar el punto óptimo si encontramos una distancia menor\n",
        "            if distancia < distancias_min:\n",
        "                distancias_min = distancia\n",
        "                punto_optimo = interseccion\n",
        "\n",
        "    return punto_optimo\n",
        "\n",
        "# Función para generar las intersecciones con la línea y = x\n",
        "def generar_intersecciones(ubicaciones):\n",
        "    intersecciones = []\n",
        "    for key, value in ubicaciones.items():\n",
        "        h = value[0]  # X\n",
        "        v = value[1]  # Y\n",
        "        # Si la coordenada h o v puede estar en la línea y = x\n",
        "        if h == v:\n",
        "            intersecciones.append((h, v))  # Añadir punto (h, h) si h == v\n",
        "        else:\n",
        "            # Intersecciones potenciales (h, h) y (v, v)\n",
        "            intersecciones.append((h, h))\n",
        "            intersecciones.append((v, v))\n",
        "\n",
        "    # Eliminar duplicados de intersecciones\n",
        "    intersecciones = list(set(intersecciones))\n",
        "\n",
        "    return intersecciones\n",
        "\n",
        "# Corrigiendo la llamada a la función con el formato correcto\n",
        "ubicacion_optima_x_punto = ubi_optimas['rectangular'][0]  # Extraer el óptimo en X (puede ser un rango)\n",
        "ubicacion_optima_y_punto = ubi_optimas['rectangular'][1][0]  # Extraer el óptimo en Y\n",
        "\n",
        "# Generar las intersecciones posibles con la línea y = x\n",
        "intersecciones = generar_intersecciones(ubi_and_pesos)\n",
        "\n",
        "# Llamada a la función generar_isocoste\n",
        "punto_mas_cercano = generar_isocoste(ubicacion_optima_x_punto, ubicacion_optima_y_punto, intersecciones)\n",
        "\n",
        "# Mostrar el punto más cercano en la recta y=x\n",
        "print(f\"2. El punto más cercano en la recta y=x es: {punto_mas_cercano}\")\n",
        "\n",
        "# Crear matriz de pendientes entre acumuladas de X y Y\n",
        "def crear_matriz_pendientes(acumulada_x, acumulada_y):\n",
        "    matriz_pendientes = np.zeros((len(acumulada_x), len(acumulada_y)))\n",
        "    for i in range(len(acumulada_x)):\n",
        "        for j in range(len(acumulada_y)):\n",
        "            if acumulada_y[j] != 0:\n",
        "                matriz_pendientes[i, j] = -(acumulada_x[i] / acumulada_y[j])\n",
        "            else:\n",
        "                matriz_pendientes[i, j] = 0  # Evitar división por cero\n",
        "    return matriz_pendientes\n",
        "\n",
        "# Generar la matriz de pendientes\n",
        "matriz_pendientes = crear_matriz_pendientes(acumulada_x, acumulada_y)\n",
        "print(\"   Matriz de pendientes:\")\n",
        "print(matriz_pendientes.T[::-1])\n",
        "\n",
        "# Función para encontrar el punto más cercano en la lista de intersecciones,\n",
        "# ignorando el punto que ya se ha probado (evitar bucles infinitos)\n",
        "def encontrar_punto_mas_cercano(x_actual, y_actual, intersecciones, ignorar_punto=None):\n",
        "    distancia_min = float('inf')\n",
        "    punto_mas_cercano = (x_actual, y_actual)  # Valor por defecto\n",
        "\n",
        "    # Ordenar intersecciones por la distancia a (x_actual, y_actual)\n",
        "    intersecciones = sorted(intersecciones, key=lambda p: distancia_euclidiana((x_actual, y_actual), p))\n",
        "\n",
        "    # Iterar sobre las intersecciones para encontrar el punto más cercano\n",
        "    for punto in intersecciones:\n",
        "        x_inter, y_inter = punto\n",
        "        print(f\"Iterando sobre punto de intersección: X = {x_inter}, Y = {y_inter}\")  # Debug para mostrar los puntos\n",
        "\n",
        "        if ignorar_punto and (x_inter, y_inter) == ignorar_punto:\n",
        "            print(f\"Ignorando el punto: X = {x_inter}, Y = {y_inter}\")\n",
        "            continue  # Ignorar el punto que ya ha sido probado\n",
        "\n",
        "        # Verificar que x >= y para mantener la restricción\n",
        "        if x_inter >= y_inter:\n",
        "            print(f\"Seleccionando el punto más cercano: X = {x_inter}, Y = {y_inter}\")\n",
        "            punto_mas_cercano = (x_inter, y_inter)\n",
        "            break  # Seleccionar el primer punto válido\n",
        "\n",
        "    return punto_mas_cercano\n",
        "\n",
        "def mover(x_actual, y_actual, eje_x, eje_y, acumulada_x, acumulada_y, matriz_pendientes, intersecciones, punto_mas_cercano):\n",
        "    \"\"\"\n",
        "    Función que mueve en ambas direcciones (horario y antihorario) y ajusta el punto si es necesario.\n",
        "    Devuelve los resultados del movimiento en ambas direcciones.\n",
        "    \"\"\"\n",
        "\n",
        "    def mover_horario(x_actual, y_actual, eje_x, eje_y, acumulada_x, acumulada_y):\n",
        "        \"\"\"\n",
        "        Mueve en dirección horario y devuelve las nuevas coordenadas.\n",
        "        \"\"\"\n",
        "        print(f\"\\nMoviendo en dirección horario desde X = {x_actual}, Y = {y_actual}\")\n",
        "\n",
        "        # Buscar el índice del valor más cercano que sea menor o igual que x_actual\n",
        "        idx_x_actual = np.searchsorted(eje_x, x_actual, side='right') - 1\n",
        "        if idx_x_actual < 0:  # Si está fuera de rango, usar el primer índice\n",
        "            idx_x_actual = 0\n",
        "        elif idx_x_actual >= len(eje_x):  # Si está fuera de rango, usar el último índice\n",
        "            idx_x_actual = len(eje_x) - 1\n",
        "\n",
        "        # Buscar el índice del valor más cercano que sea menor o igual que y_actual\n",
        "        idx_y_actual = np.searchsorted(eje_y, y_actual, side='right') - 1\n",
        "        if idx_y_actual < 0:\n",
        "            idx_y_actual = 0\n",
        "        elif idx_y_actual >= len(eje_y):\n",
        "            idx_y_actual = len(eje_y) - 1\n",
        "\n",
        "        # Movimiento horario: buscamos el siguiente punto en el eje X hacia la derecha\n",
        "        if idx_x_actual < len(eje_x) - 1:\n",
        "            x_nueva = eje_x[idx_x_actual + 1]  # El siguiente punto en el eje X\n",
        "            acumulada_x_siguiente = acumulada_x[idx_x_actual+1]  # Acumulada en el siguiente punto\n",
        "\n",
        "            print(f\"Nuevo X: {x_nueva}, Acumulada siguiente en X: {acumulada_x_siguiente}, Acumulada en Y: {acumulada_y[idx_y_actual + 1]}\")\n",
        "\n",
        "            if acumulada_x_siguiente == 0:\n",
        "                y_nueva = y_actual  # No hay cambio en Y\n",
        "                print(\"Acumulada en el siguiente punto es 0, no hay cambio en Y.\")\n",
        "            else:\n",
        "                pendiente = -(acumulada_x_siguiente / acumulada_y[idx_y_actual + 1])  # Pendiente de la posición anterior\n",
        "                print(f\"Pendiente calculada: {pendiente}\")\n",
        "                # Actualizamos Y usando la fórmula\n",
        "                y_nueva = pendiente * (x_nueva - x_actual) + y_actual\n",
        "                print(f\"Y nueva calculada: {y_nueva}\")\n",
        "\n",
        "            print(f\"Punto válido encontrado: X = {x_nueva}, Y = {y_nueva}\")\n",
        "            return x_nueva, y_nueva\n",
        "\n",
        "        return x_actual, y_actual  # No hay movimiento posible\n",
        "\n",
        "    def mover_antihorario(x_actual, y_actual, eje_x, eje_y, acumulada_x, acumulada_y):\n",
        "        \"\"\"\n",
        "        Mueve en dirección antihorario y devuelve las nuevas coordenadas.\n",
        "        \"\"\"\n",
        "        print(f\"\\nMoviendo en dirección antihorario desde X = {x_actual}, Y = {y_actual}\")\n",
        "\n",
        "        idx_y_actual = np.searchsorted(eje_y, y_actual, side='left') - 1\n",
        "        if idx_y_actual < 0:\n",
        "            idx_y_actual = 0\n",
        "        elif idx_y_actual >= len(eje_y):\n",
        "            idx_y_actual = len(eje_y) - 1\n",
        "\n",
        "        # Movimiento antihorario: buscamos el punto anterior en el eje Y hacia la izquierda\n",
        "        if idx_y_actual > 0:\n",
        "            y_nueva = eje_y[idx_y_actual]  # El punto anterior en el eje Y\n",
        "            acumulada_y_actual = acumulada_y[idx_y_actual+1]\n",
        "            acumulada_x_actual = acumulada_x[idx_y_actual]\n",
        "\n",
        "            print(f\"Nueva Y: {y_nueva}, Acumulada actual en Y: {acumulada_y_actual}, Acumulada en X: {acumulada_x_actual}\")\n",
        "\n",
        "            if acumulada_y_actual == 0:\n",
        "                x_nueva = x_actual  # No hay cambio en X\n",
        "                print(\"Acumulada en el siguiente punto en Y es 0, no hay cambio en X.\")\n",
        "            else:\n",
        "                pendiente = -acumulada_x_actual / acumulada_y_actual\n",
        "                x_nueva = (y_nueva - y_actual) / pendiente + x_actual\n",
        "                print(f\"X nueva calculada: {x_nueva}\")\n",
        "\n",
        "            # Verificar si el nuevo punto es válido\n",
        "            if x_nueva > np.max(eje_x) or x_nueva < np.min(eje_x) or x_nueva < y_nueva:\n",
        "                print(f\"Punto inválido: X = {x_nueva}, Y = {y_nueva}\")\n",
        "                return None, None  # Indica que el punto es inválido\n",
        "            else:\n",
        "                print(f\"Punto válido encontrado: X = {x_nueva}, Y = {y_nueva}\")\n",
        "                return x_nueva, y_nueva\n",
        "\n",
        "        print(\"No hay más puntos hacia la izquierda para el movimiento antihorario.\")\n",
        "        y_nueva_mal = eje_y[0]\n",
        "        x_nueva_mal = eje_x[0]\n",
        "        return x_nueva_mal, y_nueva_mal  # No hay movimiento posible\n",
        "\n",
        "    # Intentar mover en ambas direcciones\n",
        "    x_nueva, y_nueva = mover_horario(x_actual, y_actual, eje_x, eje_y, acumulada_x, acumulada_y)\n",
        "    x_nueva_anti, y_nueva_anti = mover_antihorario(x_actual, y_actual, eje_x, eje_y, acumulada_x, acumulada_y)\n",
        "\n",
        "    # Si el movimiento no fue válido en ambas direcciones, buscar el punto más cercano\n",
        "    if (x_nueva is None or y_nueva is None) or (x_nueva_anti is None or y_nueva_anti is None):\n",
        "        print(\"Movimiento inválido en ambas direcciones: se buscará un nuevo punto.\")\n",
        "        punto_mas_cercano_nuevo = encontrar_punto_mas_cercano(x_actual, y_actual, intersecciones, ignorar_punto=punto_mas_cercano)\n",
        "        punto_mas_cercano = punto_mas_cercano_nuevo\n",
        "        # Actualizar x_actual e y_actual con el nuevo punto más cercano\n",
        "        x_actual, y_actual = punto_mas_cercano_nuevo\n",
        "        print(f\"Nuevo punto más cercano encontrado: X = {x_actual}, Y = {y_actual}\")\n",
        "\n",
        "        # Intentar nuevamente el movimiento en ambas direcciones\n",
        "        x_nueva, y_nueva = mover_horario(x_actual, y_actual, eje_x, eje_y, acumulada_x, acumulada_y)\n",
        "        x_nueva_anti, y_nueva_anti = mover_antihorario(x_actual, y_actual, eje_x, eje_y, acumulada_x, acumulada_y)\n",
        "\n",
        "    # Retornar los nuevos puntos\n",
        "    return (punto_mas_cercano, x_nueva if x_nueva is not None else x_actual,\n",
        "            y_nueva if y_nueva is not None else y_actual,\n",
        "            x_nueva_anti if x_nueva_anti is not None else x_actual,\n",
        "            y_nueva_anti if y_nueva_anti is not None else y_actual,\n",
        ")\n",
        "\n",
        "# Ejemplo de uso\n",
        "punto_mas_cercano, x_nueva, y_nueva, x_nueva_anti, y_nueva_anti = mover(\n",
        "    punto_mas_cercano[0],\n",
        "    punto_mas_cercano[1],\n",
        "    eje_x,\n",
        "    eje_y,\n",
        "    acumulada_x,\n",
        "    acumulada_y,\n",
        "    matriz_pendientes,\n",
        "    intersecciones,\n",
        "    punto_mas_cercano\n",
        ")\n",
        "\n",
        "print(f\"Resultados del movimiento:\")\n",
        "print(f\"Punto más cercano en recta: X = {punto_mas_cercano[0]}, Y = {punto_mas_cercano[1]}\")\n",
        "print(f\"Movimiento horario: X = {x_nueva}, Y = {y_nueva}\")\n",
        "print(f\"Movimiento antihorario: X = {x_nueva_anti}, Y = {y_nueva_anti}\")\n",
        "print(f'A partir de aquí decide si es óptimo XD')\n",
        "\n",
        "ubi_opti_recta = {'rectangular': [[punto_mas_cercano[0]], [punto_mas_cercano[1]]]}\n",
        "\n",
        "coste_opti = coste_rectangular( ubi_opti_recta, ubi_and_pesos,X)\n",
        "print(f'    Coste punto óptimo: {coste_opti[0]} euritos')\n",
        "ahorro = (coste_opti[0] - coste_rect)*230\n",
        "print(f'    Ahorro: {ahorro} pavets')\n",
        "years = 4\n",
        "interest_rate = 0.1\n",
        "def inversion(ahorro, years, interest_rate):\n",
        "  inv = 0\n",
        "  for year in range(1,years+1):\n",
        "    inv+= ahorro/(1+interest_rate)**year\n",
        "  return inv\n",
        "\n",
        "print(f'    \\033[1mInversion: {inversion(ahorro, years, interest_rate)} euritos\\033[0m')\n",
        "\n",
        "# Graficar los puntos y las conexiones\n",
        "def graficar_pendientes_isocoste(matriz_pendientes, acumulada_x, acumulada_y, ubicacion_optima_x, ubicacion_optima_y, eje_x, eje_y, punto_inicial, punto_horario, punto_antihorario):\n",
        "    fig, ax = plt.subplots(figsize=(10, 8))\n",
        "\n",
        "    # Encontrar los máximos valores de X e Y para los límites de los ejes\n",
        "    X_max = max(eje_x) + 10  # Añadimos un margen extra para mejor visualización\n",
        "    Y_max = max(eje_y) + 10\n",
        "\n",
        "    # Crear el gráfico de cuadrícula (sin color)\n",
        "    ax.set_xticks(eje_x)  # Establecer las marcas en el eje X\n",
        "    ax.set_yticks(eje_y)  # Establecer las marcas en el eje Y\n",
        "\n",
        "    # Mostrar los valores acumulados y los puntos del eje en X e Y\n",
        "    for i, acu in enumerate(acumulada_x):\n",
        "        if i < len(eje_x):  # Asegurarnos de no exceder los índices\n",
        "            # Ajuste en la posición X para centrar la acumulada\n",
        "            ax.text(eje_x[i] - 5, -4, f\"{acu:.1f}\", ha='center', va='center', color='blue')  # Desplazamos a la izquierda\n",
        "    for j, acu in enumerate(acumulada_y):\n",
        "        if j < len(eje_y):\n",
        "            # Ajuste en la posición Y para centrar la acumulada\n",
        "            ax.text(-3, eje_y[j] - 3, f\"{acu:.1f}\", ha='center', va='center', color='blue')  # Desplazamos hacia arriba\n",
        "\n",
        "    # Mostrar las pendientes dentro de cada celda (como texto)\n",
        "    for i in range(matriz_pendientes.shape[0]):\n",
        "        for j in range(matriz_pendientes.shape[1]):\n",
        "            ax.text(i * (X_max / matriz_pendientes.shape[0]) + 5, j * (Y_max / matriz_pendientes.shape[1]) + 5,\n",
        "                    f\"{matriz_pendientes[i, j]:.2f}\", ha='center', va='center', color='black')\n",
        "\n",
        "    # Graficar el rango de puntos óptimos en X con un único valor de Y\n",
        "    if len(ubicacion_optima_x) > 1:  # Si hay un rango de valores óptimos en X\n",
        "        plt.plot(ubicacion_optima_x, [ubicacion_optima_y[0]] * len(ubicacion_optima_x), c='green', linewidth=4)\n",
        "    else:\n",
        "        plt.scatter(ubicacion_optima_x[0], ubicacion_optima_y[0], c='green', s=100, label = 'Punto rectangular')\n",
        "\n",
        "    # Graficar el rango de puntos óptimos en Y si hay más de un valor\n",
        "    if len(ubicacion_optima_y) > 1:  # Si hay un rango de valores óptimos en Y\n",
        "        plt.plot([ubicacion_optima_x[0]] * len(ubicacion_optima_y), ubicacion_optima_y, c='green', linewidth=4)\n",
        "    else:\n",
        "        plt.scatter(ubicacion_optima_x[0], ubicacion_optima_y[0], c='green', s=100)\n",
        "    # Graficar la línea y = x simple\n",
        "    x_line = np.linspace(0, min(X_max, Y_max), 100)  # Crear la línea para valores desde 0 hasta el mínimo de X_max e Y_max\n",
        "    plt.plot(x_line, x_line, 'm--', label='y = x')   # La línea y = x\n",
        "\n",
        "    # Añadir las líneas que pasan por los puntos (verticales y horizontales)\n",
        "    for key, value in ubi_and_pesos.items():\n",
        "        x, y, peso = value\n",
        "        ax.axvline(x=x, linestyle='--', color='black', alpha=0.7)  # Línea vertical en x\n",
        "        ax.axhline(y=y, linestyle='--', color='black', alpha=0.7)  # Línea horizontal en y\n",
        "\n",
        "    # Graficar los puntos inicial y nuevos\n",
        "    ax.scatter(punto_inicial[0], punto_inicial[1], c='red', s=100, label='Punto Inicial')\n",
        "    ax.scatter(punto_horario[0], punto_horario[1], c='orange', s=100, label='Punto Horario')\n",
        "    ax.scatter(punto_antihorario[0], punto_antihorario[1], c='orange', s=100, label='Punto Antihorario')\n",
        "\n",
        "    # Dibujar líneas hacia los nuevos puntos\n",
        "    ax.plot([punto_inicial[0], punto_horario[0]], [punto_inicial[1], punto_horario[1]], 'orange', linestyle='-', linewidth=2)\n",
        "    ax.plot([punto_inicial[0], punto_antihorario[0]], [punto_inicial[1], punto_antihorario[1]], 'orange', linestyle='-', linewidth=2)\n",
        "\n",
        "    # Añadir título y etiquetas\n",
        "    plt.title('Matriz de Pendientes, Acumuladas y Líneas Isocoste')\n",
        "    plt.xlabel('Posición X')\n",
        "    plt.ylabel('Posición Y')\n",
        "\n",
        "    # Configurar la leyenda fuera de la gráfica\n",
        "    plt.legend(loc='upper left', bbox_to_anchor=(1, 1))\n",
        "\n",
        "    plt.grid(True)\n",
        "    plt.xlim(0, X_max)\n",
        "    plt.ylim(0, Y_max)\n",
        "\n",
        "    # Graficar las ubicaciones de los puntos con sus pesos\n",
        "    for key, value in ubi_and_pesos.items():\n",
        "        x, y, peso = value\n",
        "        ax.scatter(x, y, s=peso * 100, label=f'{key}({peso})', color='blue')  # Tamaño proporcional al peso\n",
        "        ax.text(x + 2, y, f'{key}({peso})', fontsize=12, color='blue')  # Texto al lado del punto\n",
        "\n",
        "    plt.show()\n",
        "\n",
        "# Ejemplo de datos para probar la función\n",
        "# Matriz de pendientes (usamos la función crear_matriz_pendientes previamente definida)\n",
        "matriz_pendientes = crear_matriz_pendientes(acumulada_x, acumulada_y)\n",
        "\n",
        "# Calcular X_max e Y_max basados en los ejes de ubicaciones\n",
        "X_max = max(eje_x) + 10\n",
        "Y_max = max(eje_y) + 10\n",
        "\n",
        "# Graficar con los ajustes corregidos\n",
        "graficar_pendientes_isocoste(matriz_pendientes, acumulada_x, acumulada_y, ubicacion_optima_x, ubicacion_optima_y, eje_x, eje_y, (punto_mas_cercano[0], punto_mas_cercano[1]), (x_nueva, y_nueva), (x_nueva_anti, y_nueva_anti))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "SqQ_bGzWU6EN",
        "outputId": "ee5f9dcd-ef2e-4c9b-ddae-66a9e8f5df95"
      },
      "execution_count": 86,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[-10.0, -6.0, -4.0, 4.0, 10.0] [10 30 40 60]\n",
            "1. Emplacement optimal en X et Y: ([40], [10, 20])\n",
            "    \u001b[1mCoût rectangulaire: 4400 € \u001b[0m\n",
            "      Coût X: 130\n",
            "      Coût Y: 90\n",
            "2. El punto más cercano en la recta y=x es: (30, 30)\n",
            "   Matriz de pendientes:\n",
            "[[ 1.   0.6  0.4 -0.4 -1. ]\n",
            " [ 5.   3.   2.  -2.  -5. ]\n",
            " [ 0.   0.   0.   0.   0. ]\n",
            " [-1.  -0.6 -0.4  0.4  1. ]]\n",
            "\n",
            "Moviendo en dirección horario desde X = 30, Y = 30\n",
            "Nuevo X: 40, Acumulada siguiente en X: -4.0, Acumulada en Y: 10.0\n",
            "Pendiente calculada: 0.4\n",
            "Y nueva calculada: 34.0\n",
            "Punto válido encontrado: X = 40, Y = 34.0\n",
            "\n",
            "Moviendo en dirección antihorario desde X = 30, Y = 30\n",
            "Nueva Y: 20, Acumulada actual en Y: 2.0, Acumulada en X: -6.0\n",
            "X nueva calculada: 26.666666666666668\n",
            "Punto válido encontrado: X = 26.666666666666668, Y = 20\n",
            "Resultados del movimiento:\n",
            "Punto más cercano en recta: X = 30, Y = 30\n",
            "Movimiento horario: X = 40, Y = 34.0\n",
            "Movimiento antihorario: X = 26.666666666666668, Y = 20\n",
            "A partir de aquí decide si es óptimo XD\n",
            "    Coste punto óptimo: 5600 euritos\n",
            "    Ahorro: 276000 pavets\n",
            "    \u001b[1mInversion: 874882.8631924047 euritos\u001b[0m\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x800 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    }
  ]
}