{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Importar librerias para operar datos#\n",
    "\n",
    "import pandas as pd                     # Pandas para convertir tablas en matrices \n",
    "import numpy as np                      # Numpy para realizar operaciones con vectores y matrices\n",
    "import matplotlib.pyplot as plt         # Matplotlib para graficar los resutlados\n",
    "import math                             # Operaciones matematicas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Lectura de datos, Clientes, Matriz de distancia, Demandas#\n",
    "\n",
    "MatrizDis = pd.read_excel(\"Padres_MatrizDis.xlsx\", sheet_name= \"MatrizD\")    #Matriz de Distancia\n",
    "Individuos = pd.read_excel(\"Padres_MatrizDis.xlsx\", sheet_name= \"PadresM\")   #Solución inicial\n",
    "Demandas = pd.read_excel(\"Padres_MatrizDis.xlsx\", sheet_name= \"Demanda\")     #Demanda de cada cliente\n",
    "Ventanas= pd.read_excel(\"Padres_MatrizDis.xlsx\", sheet_name=\"Ventanas\")      #Ventanas de atención\n",
    "conver= pd.read_excel(\"GraficoConvergencia.xlsx\", sheet_name=\"1\")            #Datos de Convergencia   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Convertir hojas del Excel en Data Frame\"\n",
    "\n",
    "dfMatrizDis= pd.DataFrame(MatrizDis)           #Matriz de distancia\n",
    "dfIndividuos = pd.DataFrame(Individuos)        #Hoja de individuos\n",
    "dfDemandas = pd.DataFrame(Demandas)            #Hoja de demandas\n",
    "dfIndividuos = dfIndividuos.fillna(150)        #Convertir en 150 los valores nan de las listas\n",
    "dfVentanas=pd.DataFrame(Ventanas)\n",
    "dfconver=pd.DataFrame(conver)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Crear población inicial en Python, dar un valor inciial a todas las variables globales del sistema#\n",
    "\n",
    "Poblacion = dfIndividuos.to_numpy().transpose().tolist()            #Trasponer matriz a listas de listas\n",
    "PoblacionF=[]                                                       #Iniciar varibles globales\n",
    "hijos=[]                                                            #Iniciar listas para almacenar datos\n",
    "fitnessFF=[]\n",
    "fitnessF=[]\n",
    "CantidadUndVeh = []\n",
    "DistanciaTotalmodel=[]\n",
    "dismodel=[]\n",
    "generaciones=40000                                                  #Definir número de generaciones\n",
    "Prob_Mut=0.01                                                       #Probabilidad de mutación\n",
    "hijom=[]\n",
    "Poblacion_AG=[]\n",
    "por_mutados= int()                                                  #Contador de cantidad de individuos mutados\n",
    "Velocidad=37                                                        #Velociad media\n",
    "Cap_Vehi=93                                                         #Capacidad de cada vehículo#\n",
    "MatrizViajeF=[]\n",
    "for i in range(15):                                                 #Crear población inicial sin genes cero\n",
    "    a = [elemento for elemento in Poblacion[i] if elemento !=150]\n",
    "    PoblacionF.append(a)\n",
    "    list(PoblacionF)                                                #Convertir población inicial en una lista con listas\n",
    "dicVentanas=dict([(i,[a,b]) for i,a,b in zip(dfVentanas['Cliente'],dfVentanas['Ventana I'],dfVentanas['Ventana F'])])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Función de cruce a dos puntos#\n",
    "def reproducir():                                                                   #Función\n",
    "    convergencia(PoblacionF)\n",
    "    for x in range(generaciones):                                                   #3000 generaciones        \n",
    "        hijo1=[]                                                                    #Inicio de variables\n",
    "        hijo2=[]                                \n",
    "        hijos=[]\n",
    "        a=np.random.randint(0,14)                                                   #Padres aleatorios\n",
    "        b=np.random.randint(0,14)                                                   #Padres aleatorios\n",
    "        tam1=len(PoblacionF[a])\n",
    "        tam2=len(PoblacionF[b])\n",
    "        if tam1 <= tam2:\n",
    "            punto1=np.random.randint(1,math.ceil(tam1/2))                           #Procedimiento aleatorio \n",
    "            punto2=np.random.randint((punto1+1),tam1-1)                             #Procedimiento aleatorio\n",
    "        else:\n",
    "            punto1=np.random.randint(1,math.ceil(tam2/2))                           #Procedimiento aleatorio \n",
    "            punto2=np.random.randint((punto1+1),tam2-1)  \n",
    "        hijo1[:punto1]=PoblacionF[a][:punto1]                                       #Generación hijo1\n",
    "        hijo1[punto1:punto2]=PoblacionF[b][punto1:punto2]                               \n",
    "        hijo1[punto2:]=PoblacionF[a][punto2:]\n",
    "        hijo2[:punto1]=PoblacionF[b][:punto1]                                       #Generación hijo2\n",
    "        hijo2[punto1:punto2]=PoblacionF[a][punto1:punto2]\n",
    "        hijo2[punto2:]=PoblacionF[b][punto2:]\n",
    "        hijos.append(hijo1)                                                         #Generacíón variable hijos\n",
    "        hijos.append(hijo2)\n",
    "        reparacion(hijos)\n",
    "        adaptacion(hijos)                                                           #Evaluar adaptación\n",
    "        evaluar_aptitud(hijos)                                                      #Evaluar aptitud\n",
    "\n",
    "        if ((CantidadUndVeh[-2])<Cap_Vehi and (CantidadUndVeh[-1]) <Cap_Vehi        #Ingresar hijo adaptado \n",
    "            and ((fitnessFF[-2]) + (fitnessFF[-1])) <                               #Con mejor aptitud\n",
    "            ((fitnessF[a]) + (fitnessF[b]))):\n",
    "            PoblacionF[a]=hijo1\n",
    "            PoblacionF[b]=hijo2\n",
    "            convergencia(PoblacionF)\n",
    "        else:\n",
    "            convergencia(PoblacionF)\n",
    "        CantidadUndVeh.clear()                                                      #Reinciiar funciones\n",
    "        fitnessF.clear()                                                            #Reiniciar funciones\n",
    "        fitnessFF.clear()                                                           #Reiniciar funciones \n",
    "    mutacion(PoblacionF)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Generar función de adaptación#\n",
    "def adaptacion(hijos):                                                      #Función  \n",
    "    DemandaT_Clientes=[]                                                    #Inicio de varaibales\n",
    "    CapacidadT_veh=[]                                                       #Inicio de lista para almacenar datos      \n",
    "    a=0      \n",
    "    b=1\n",
    "    m=0\n",
    "    for y in range (len(hijos)):                                            #Evaluar hijos\n",
    "        for x in range(len(hijos[a])-2):\n",
    "            Demanda_Cliente= (dfDemandas.iloc[int(hijos[a][b]),1])        #Demanda de cada cliente\n",
    "            DemandaT_Clientes.append(Demanda_Cliente)                       #Lista con demandas\n",
    "            b+=1\n",
    "        CapacidadT_veh = sum(DemandaT_Clientes)                             #Demanda total a atender por vehículo\n",
    "        CantidadUndVeh.append(CapacidadT_veh)                               #Lista demandas totales para cada vehiculo\n",
    "        DemandaT_Clientes=[]                                                #Reinicio de variables\n",
    "        a+=1\n",
    "        b=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Evalular el individuo funcion fitness#\n",
    "\n",
    "def evaluar_aptitud(hijos):                         #Función\n",
    "    aptitud=[]                                      #Inicio de varaibales\n",
    "    aptitudf=[]                                     #Inicio de varaibales para almacenar datos en listas\n",
    "    a=0                                              \n",
    "    b=0                                              \n",
    "    c=0                                              \n",
    "    d=1\n",
    "                                           \n",
    "    for y in range (len(PoblacionF)):                #Calculo de aptitud para población inicial\n",
    "        for x in range(len(PoblacionF[a])-1):\n",
    "            i = PoblacionF[a][b]\n",
    "            j = PoblacionF[c][d]\n",
    "            b+=1 \n",
    "            d+=1\n",
    "            disTotal= (dfMatrizDis.loc[i,j]) \n",
    "            aptitud.append(disTotal)                 #Distancia a cada punto del total de individuo\n",
    "            fitness= (sum(aptitud))                  #Suma distancia total recorrida por el individuo\n",
    "        fitnessF.append(fitness)                     #Crea una lista con el valor de cada fitness\n",
    "        aptitud=[]                                   #Reinicia el valor de la lista de aptitud, no acumular distancia\n",
    "        b=0                                          #Reiniciar el valor de la posición de los genes en el cromosoma\n",
    "        d=1\n",
    "        a+=1\n",
    "        c+=1\n",
    "    a=0                                              \n",
    "    b=0                                              \n",
    "    c=0                                              \n",
    "    d=1\n",
    "    for y in range (len(hijos)):                      #Calculo de aptitud para los hijos generados\n",
    "        for x in range(len(hijos[a])-1):\n",
    "            i = hijos[a][b]\n",
    "            j = hijos[c][d]\n",
    "            b+=1 \n",
    "            d+=1\n",
    "            disTotalf= (dfMatrizDis.loc[i,j]) \n",
    "            aptitudf.append(disTotalf)                #Distancia a cada punto del total de hijos\n",
    "            fitnessf= (sum(aptitudf))                 #Suma distancia total recorrida por el hijo\n",
    "        fitnessFF.append(fitnessf)                    #Crea una lista con el valor de cada fitness para cada hijo\n",
    "        aptitudf=[]                                   #Reinicia el valor de la lista de aptitud, no acumular distancia\n",
    "        b=0                                           #Reiniciar el valor de la posición de los genes en el cromosoma\n",
    "        d=1\n",
    "        a+=1\n",
    "        c+=1\n",
    "    #print(fitnessF)\n",
    "    #print(sum(fitnessF))\n",
    "#evaluar_aptitud(PoblacionF)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Función para guardar distancia total del modelo#\n",
    "def convergencia(PoblacionF):                         #Función para guardar los mejores resultados\n",
    "    aptitudC=[]                                       #Inicio de varaibales\n",
    "    fitnessFC=[]                                      \n",
    "    a=0                                              \n",
    "    b=0                                              \n",
    "    c=0                                              \n",
    "    d=1\n",
    "                                           \n",
    "    for y in range (len(PoblacionF)):                 #Calculo de aptitud para población cruzada\n",
    "        for x in range(len(PoblacionF[a])-1):\n",
    "            i = PoblacionF[a][b]\n",
    "            j = PoblacionF[c][d]\n",
    "            b+=1 \n",
    "            d+=1\n",
    "            disTotalC= (dfMatrizDis.loc[i,j]) \n",
    "            aptitudC.append(disTotalC)                 #Distancia a cada punto del total de individuo cruzado\n",
    "            fitnessC= (sum(aptitudC))                  #Suma distancia total recorrida por el individuo cruzado\n",
    "        fitnessFC.append(fitnessC)                     #Crea una lista con el valor de cada fitness de los hijos\n",
    "        aptitudC=[]                                    #Reinicia el valor de la lista de aptitud, no acumular distancia\n",
    "        b=0                                            #Reiniciar el valor de la posición de los genes en el cromosoma\n",
    "        DistanciaTotalmodel = sum(fitnessFC)\n",
    "        d=1\n",
    "        a+=1\n",
    "        c+=1\n",
    "    dismodel.append(DistanciaTotalmodel)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Función de mutación#\n",
    "\n",
    "def mutacion(PoblacionF):                                             #Función de mutación \n",
    "    e=0                                                               #Inicio de variables a operar\n",
    "    f=1\n",
    "    a=0\n",
    "    por_mutados=0                                                     #Contador de individuos mutados\n",
    "    dis_mut=[]                                                        #Inicio de variables listas para almacenar datos\n",
    "    DisTM=[]\n",
    "    fitnessM=[]\n",
    "    hijom=[]\n",
    "    for i in range(len(PoblacionF)):                                  #Bucle para evaluar si un individuo muta o no\n",
    "        for j in range(200):\n",
    "            if np.random.random()<=Prob_Mut:                          #Generación de número aleatorio <0.01\n",
    "                evaluar_aptitud(PoblacionF)\n",
    "                fitnessF.clear()\n",
    "                evaluar_aptitud(PoblacionF)\n",
    "                puntoM1=np.random.randint(1,((int(len(PoblacionF[a]))-1)))   #Generación de número aleatorio para mutar\n",
    "                puntoM2=np.random.randint(1,((int(len(PoblacionF[a]))-1)))   #Generación de número aleatorio para mutar\n",
    "                hijom=[i for i in (PoblacionF[a])]\n",
    "                x=hijom[puntoM1]                                    \n",
    "                y=hijom[puntoM2]\n",
    "                hijom[puntoM1]=y                                      #Mutación\n",
    "                hijom[puntoM2]=x                                      #Mutación\n",
    "                for s in range(len(hijom)-1):\n",
    "                    m= (hijom[e])\n",
    "                    n= (hijom[f])\n",
    "                    dis_mut= (dfMatrizDis.loc[m,n])\n",
    "                    DisTM.append(dis_mut)\n",
    "                    fitnessM=sum(DisTM)\n",
    "                    e+=1\n",
    "                    f+=1\n",
    "                if int(fitnessM) < int(fitnessF[a]):                  #Ingreso del individuo mutado a la población\n",
    "                    por_mutados+=1\n",
    "                    PoblacionF[a]=hijom\n",
    "                    convergencia(PoblacionF)                          #Almacena datos de la solución final\n",
    "                else:\n",
    "                    convergencia(PoblacionF)\n",
    "            e=0                                                       #Reinicio de variables\n",
    "            f=1\n",
    "            DisTM=[] \n",
    "        a+=1\n",
    "    fitnessF.clear()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Función de reparación Ventanas de tiempo hijos no factibles#\n",
    "\n",
    "def reparacion(hijos):                                  #Función reparación hijos generados\n",
    "    distanciaspp=[]                                     #Inicio valores de la variables\n",
    "    distanciasppI=[]                                    \n",
    "    MatrizViaje=[]\n",
    "    MatrizViajeF=[]\n",
    "    a=0                                                 #Inicio valores de la variables                          \n",
    "    b=0                                              \n",
    "    c=0                                              \n",
    "    d=1\n",
    "    for y in range (len(hijos)):                        #Calculo matriz de tiempo de viaje de un nodo a otro\n",
    "        for x in range(len(hijos[a])-1):\n",
    "            i = hijos[a][b]\n",
    "            j = hijos[c][d]\n",
    "            b+=1 \n",
    "            d+=1\n",
    "            disTotal= (dfMatrizDis.loc[i,j])            #Calculo de distancia de un nodo a otro\n",
    "            distanciaspp.append(disTotal)               #Distancia a cada punto del total de individuo\n",
    "        distanciasppI.append(distanciaspp)\n",
    "        b=0                                             #Reiniciar el valor de la posición de los genes en el cromosoma\n",
    "        d=1                                             \n",
    "        a+=1\n",
    "        c+=1\n",
    "        distanciaspp=[]                                 #Reiniciar lista para no acumular distancias      \n",
    "    a=0                                              \n",
    "    b=0                                              \n",
    "    c=0                                              \n",
    "    d=1\n",
    "    for j in range(len(distanciasppI)):                 #Calculo matriz de tiempo de un nodo i a un nodo j\n",
    "        for i in distanciasppI[a]:\n",
    "            MatrizViaje.append((i/Velocidad))\n",
    "        MatrizViajeF.append(MatrizViaje)                #Realiza matriz de tiempos de viaje\n",
    "        MatrizViaje=[]        \n",
    "        a+=1\n",
    "    a=0\n",
    "    b=1\n",
    "    c=0\n",
    "    d=0\n",
    "    for y in range(len(hijos)):                         #Evalua cada hijo generado para ver si su solución es factible\n",
    "        for x in range(len(hijos[a])):\n",
    "            if ((dicVentanas[(hijos[a][b])][0]+0.25+MatrizViajeF[a][c])) > int(dicVentanas[(hijos[a][b+1])][1]):\n",
    "                hijos[a][b],hijos[a][b+1]=hijos[a][b+1],hijos[a][b]\n",
    "                reparacion(hijos)                       #Recalcula los tiempos de viaje luego de la agrupación\n",
    "            else:\n",
    "                (dicVentanas[(hijos[a][b+1])][0]) = int((dicVentanas[(hijos[a][b])][0]+0.25+MatrizViajeF[a][c]))\n",
    "            b+=1                                        #Coloca los tiempos de llegada a cada punto\n",
    "            c+=1                                        #Reinicio de variables para repetir el proceso\n",
    "        a+=1\n",
    "        b=1\n",
    "        c=0\n",
    "        d=0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Función para graficar los resultados en una grafica de convergencia#\n",
    "def grafico():                          #Función grafico\n",
    "    x=[]                                #Inicio de variables \n",
    "    for i in range(len(dismodel)):      #Creación eje X\n",
    "        x.append(i)\n",
    "    plt.plot(x,dismodel,linestyle='--',color= 'g') \n",
    "    plt.title(\"Convergencia AG\")\n",
    "    plt.xlabel('Número de Generaciones')\n",
    "    plt.ylabel('Aptitud de los mejores individuos')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.0, 51.0, 74.0, 36.0, 14.0, 15.0, 21.0, 98.0, 50.0, 45.0, 115.0, 65.0, 113.0, 16.0, 0.0], [0.0, 5.0, 139.0, 120.0, 7.0, 18.0, 114.0, 37.0, 131.0, 46.0, 0.0], [0.0, 52.0, 3.0, 63.0, 87.0, 26.0, 49.0, 73.0, 24.0, 103.0, 138.0, 72.0, 0.0], [0.0, 56.0, 44.0, 95.0, 53.0, 22.0, 71.0, 48.0, 11.0, 90.0, 122.0, 64.0, 0.0], [0.0, 137.0, 67.0, 134.0, 88.0, 124.0, 93.0, 19.0, 110.0, 136.0, 30.0, 112.0, 31.0, 81.0, 96.0, 0.0], [0.0, 135.0, 68.0, 89.0, 28.0, 109.0, 40.0, 76.0, 118.0, 0.0], [0.0, 91.0, 62.0, 117.0, 108.0, 104.0, 129.0, 107.0, 0.0], [0.0, 47.0, 25.0, 39.0, 85.0, 119.0, 80.0, 2.0, 0.0], [0.0, 6.0, 126.0, 105.0, 100.0, 128.0, 10.0, 27.0, 58.0, 82.0, 99.0, 111.0, 77.0, 0.0], [0.0, 94.0, 66.0, 92.0, 130.0, 0.0], [0.0, 132.0, 9.0, 60.0, 13.0, 35.0, 86.0, 57.0, 70.0, 123.0, 0.0], [0.0, 140.0, 127.0, 116.0, 55.0, 41.0, 43.0, 101.0, 133.0, 61.0, 38.0, 29.0, 59.0, 42.0, 106.0, 0.0], [0.0, 20.0, 12.0, 1.0, 83.0, 97.0, 4.0, 17.0, 69.0, 121.0, 79.0, 8.0, 102.0, 32.0, 0.0], [0.0, 34.0, 84.0, 125.0, 78.0, 0.0], [0.0, 23.0, 75.0, 54.0, 33.0, 0.0]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for x in range(30):\n",
    "    reproducir()\n",
    "grafico()\n",
    "print(PoblacionF)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "convergencia(PoblacionF)\n",
    "df = pd.DataFrame(dismodel)\n",
    "df.to_excel(\"GraficoConvergencia2.xlsx\", sheet_name=\"1\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax=plt.gca()\n",
    "dfconver.plot(kind='line',x='Generación',y='Corrida1',linestyle='--',ax=ax)\n",
    "dfconver.plot(kind='line',x='Generación',y='Corrida2',linestyle='--',color='red',ax=ax)\n",
    "dfconver.plot(kind='line',x='Generación',y='Corrida3',linestyle='--',color='blue',ax=ax)\n",
    "dfconver.plot(kind='line',x='Generación',y='Corrida4',linestyle='--',color='yellow',ax=ax)\n",
    "dfconver.plot(kind='line',x='Generación',y='Corrida5',linestyle='--',color='green',ax=ax)\n",
    "dfconver.plot(kind='line',x='Generación',y='Corrida6',linestyle='--',color='purple',ax=ax)\n",
    "plt.title(\"Convergencia AG\")\n",
    "plt.xlabel('Número de Generaciones')\n",
    "plt.ylabel('Aptitud de los mejores individuos')\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.5 64-bit (system)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.5"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "e48983a9409aade52637f4f4eb9a382f0829c7c69f70ce67049527baa6ab656f"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}