F1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from gurobipy import*\n",
    "from gurobipy import GRB\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import math\n",
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Función para generación aleatoria de hipergrafos\n",
    "def rand_hgraf(n,m,d):\n",
    "    E = np.random.randint(2,d+1,size=(m))\n",
    "    M = np.arange(m)\n",
    "    N = np.arange(n)\n",
    "    A = np.zeros((n,m))\n",
    "    for j in M:\n",
    "        t = 0\n",
    "        while t < E[j]:\n",
    "            s = int(np.random.choice(N,size=1))\n",
    "            A[s,j] = 1\n",
    "            t = np.sum(A[:,j])\n",
    "    return A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Tamaño promedio de las hiperaristas\n",
    "def prom(A):\n",
    "    m = A.shape[1]\n",
    "    P = []\n",
    "    for y in range(m):\n",
    "        P.append(sum(A[:,y]))\n",
    "    p = np.average(P)\n",
    "    return p\n",
    "#Tamaño máximo de las hiperaristas\n",
    "def tamax(A):\n",
    "    S = np.sum(A,axis=0)\n",
    "    m = int(np.max(S))\n",
    "    return m\n",
    "#Vértices cubiertos por conjunto de hiperaristas h\n",
    "def vert_cover(A,h):\n",
    "    n = A.shape[0]\n",
    "    S= np.zeros(n)\n",
    "    for j in h:\n",
    "        S += A[:,j]\n",
    "    vc = np.where(S!=0)[0]\n",
    "    return len(vc)\n",
    "#Vértices en la interesección de las hiperaristas\n",
    "def inter(A,e1,e2):\n",
    "    I = A[:,e1]+A[:,e2]\n",
    "    i = np.where(I>1)[0]\n",
    "    return i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Funciones para desigualdades válidas\n",
    "#Hiperaristas de vértices tipo hoja\n",
    "def hoja(A):\n",
    "    n = A.shape[0]\n",
    "    S = np.sum(A,axis=1)\n",
    "    h = []\n",
    "    for i in range(n):\n",
    "        if S[i]==1:\n",
    "            j = np.where(A[i,:]==1)[0][0]\n",
    "            h.append(j)\n",
    "    return h\n",
    "#Hiperaristas contenidas\n",
    "def cont(A):\n",
    "    m = A.shape[1]\n",
    "    tmax = tamax(A)\n",
    "    h = {}\n",
    "    for t in range(2,tmax+1):\n",
    "        E = []\n",
    "        for j in range(m):\n",
    "            if sum(A[:,j])==t:\n",
    "                E.append(j)\n",
    "        h.update({t: E})\n",
    "    C = {}\n",
    "    for c_out in range(tmax,2,-1):\n",
    "        for eo in h[c_out]:\n",
    "            L = []\n",
    "            for c_in in range(c_out-1,1,-1):\n",
    "                for ei in h[c_in]:\n",
    "                    d = A[:,ei]+A[:,eo]\n",
    "                    s = len(np.where(d==2)[0])\n",
    "                    if s == c_in:\n",
    "                        L.append(ei)\n",
    "            if len(L)>0:\n",
    "                C.update({eo:L})\n",
    "    return C\n",
    "#Conjuntos minimales de 3 elementos\n",
    "def minimal3(A,nk):\n",
    "    m = A.shape[1]\n",
    "    M = [x for x in range(m)]\n",
    "    S = []\n",
    "    for x in M:\n",
    "        s = []\n",
    "        i = M.index(x)\n",
    "        for y in M[i+1:]:\n",
    "            i = M.index(y)\n",
    "            for z in M[i+1:]:\n",
    "                if vert_cover(A,[x,y])<=nk and vert_cover(A,[x,z])<=nk and vert_cover(A,[y,z])<=nk and vert_cover(A,[x,y,z])>nk:\n",
    "                    S.append([x,y,z])\n",
    "                else:\n",
    "                    break\n",
    "    return S"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Formulación $\\mathcal{F}_1$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def F1(A,W,K):\n",
    "    #Parámetros\n",
    "    #A: matriz de incidencia del hipergrafo\n",
    "    #W: vector de pesos de las hiperaristas\n",
    "    #K: número de particionamiento\n",
    "    n = A.shape[0]   #Número de nodos\n",
    "    m = A.shape[1]   #Número de hiperaristas\n",
    "    nk = int(n/K)     #Tamaño de cada partición\n",
    "    #Listas de conjuntos para las variables\n",
    "    N = np.arange(n)\n",
    "    M = np.arange(m)\n",
    "    C = np.arange(K)\n",
    "    #Creación del modelo\n",
    "    modelo=Model()\n",
    "    modelo.Params.LogToConsole = 0\n",
    "    modelo.Params.timeLimit = 1800\n",
    "    modelo.Params.cuts = 0\n",
    "    modelo.Params.PreCrush = 1\n",
    "    #creación de variables\n",
    "    x = modelo.addVars(N,C,vtype=GRB.BINARY, name='x')\n",
    "    y = modelo.addVars(M,C,vtype=GRB.BINARY, name='y')\n",
    "    #Función objetivo\n",
    "    obj = quicksum(W[j]*y[j,k] for j in M for k in C)\n",
    "    modelo.setObjective(obj, GRB.MINIMIZE)\n",
    "    #Restricciones\n",
    "    modelo.addConstrs(quicksum(x[i,k] for k in C) == 1 for i in N) #(2.2)\n",
    "    modelo.addConstrs(quicksum(x[i,k] for i in N) == nk for k in C) #(2.3)\n",
    "    modelo.addConstrs(x[i,k] <= quicksum(A[i,j]*y[j,k] for j in M) for k in C for i in N) #(2.4)\n",
    "    modelo.addConstrs(quicksum(y[j,k] for k in C) <= 1 for j in M) #(2.5)\n",
    "    modelo.addConstrs(quicksum(A[i,j]*x[i,k] for i in N) >= sum(A[:,j])*y[j,k] for j in M for k in C) #(2.6)\n",
    "    modelo.update()\n",
    "    modelo.optimize()\n",
    "    #Recuperación de variables\n",
    "    V = []\n",
    "    E = []   \n",
    "    if modelo.SolCount == 0:\n",
    "        time_r = modelo.Runtime\n",
    "        sol = None\n",
    "        nods = None\n",
    "        g = None\n",
    "        return V,E,time_r,sol,nods,g\n",
    "    else:        \n",
    "        time_r = modelo.Runtime\n",
    "        sol = modelo.ObjVal\n",
    "        nods = modelo.NodeCount\n",
    "        g = 100*modelo.MIPGap\n",
    "    \n",
    "        for k in C:\n",
    "            X = []\n",
    "            for i in N:\n",
    "                if x[i,k].x != 0:\n",
    "                    X.append(i)\n",
    "            V.append(X)\n",
    "            Y = []\n",
    "            for j in M:\n",
    "                if y[j,k].x != 0:\n",
    "                    Y.append(j)\n",
    "            E.append(Y)\n",
    "    return V,E,time_r,sol,nods,g"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Formulación $\\mathcal{F}_1$ con planos cortantes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Restricción tipo hoja\n",
    "def F1_pc1(A,W,K):\n",
    "    #Parámetros\n",
    "    #A: matriz de incidencia del hipergrafo\n",
    "    #W: vector de pesos de las hiperaristas\n",
    "    #K: número de particionamiento\n",
    "    n = A.shape[0]   #Número de nodos\n",
    "    m = A.shape[1]   #Número de hiperaristas\n",
    "    nk = int(n/K)     #Tamaño de cada partición\n",
    "    #Listas de conjuntos para las variables\n",
    "    N = np.arange(n)\n",
    "    M = np.arange(m)\n",
    "    C = np.arange(K)\n",
    "    #Creación del modelo\n",
    "    modelo=Model()\n",
    "    modelo.Params.LogToConsole = 0\n",
    "    modelo.Params.timeLimit = 1800\n",
    "    modelo.Params.cuts = 0\n",
    "    modelo._cbCuts = 0\n",
    "    modelo.Params.PreCrush = 1\n",
    "    #creación de variables\n",
    "    x = modelo.addVars(N,C,vtype=GRB.BINARY, name='x')\n",
    "    y = modelo.addVars(M,C,vtype=GRB.BINARY, name='y')\n",
    "    #Función objetivo\n",
    "    obj = quicksum(W[j]*y[j,k] for j in M for k in C)\n",
    "    modelo.setObjective(obj, GRB.MINIMIZE)\n",
    "    #Restricciones\n",
    "    modelo.addConstrs(quicksum(x[i,k] for k in C) == 1 for i in N) #(2.2)\n",
    "    modelo.addConstrs(quicksum(x[i,k] for i in N) == nk for k in C) #(2.3)\n",
    "    modelo.addConstrs(x[i,k] <= quicksum(A[i,j]*y[j,k] for j in M) for k in C for i in N) #(2.4)\n",
    "    modelo.addConstrs(quicksum(y[j,k] for k in C) <= 1 for j in M) #(2.5)\n",
    "    modelo.addConstrs(quicksum(A[i,j]*x[i,k] for i in N) >= sum(A[:,j])*y[j,k] for j in M for k in C) #(2.6)\n",
    "    #Hiperaristas tipo hoja\n",
    "    for h in hoja(A):\n",
    "        modelo.addConstr(quicksum(y[h,k] for k in C) == 1)\n",
    "    modelo.update()\n",
    "    modelo.optimize()\n",
    "    #Recuperación de variables\n",
    "    V = []\n",
    "    E = []   \n",
    "    if modelo.SolCount == 0:\n",
    "        time_r = modelo.Runtime\n",
    "        sol = None\n",
    "        nods = None\n",
    "        g = None\n",
    "        return V,E,time_r,sol,nods,g\n",
    "    else:        \n",
    "        time_r = modelo.Runtime\n",
    "        sol = modelo.ObjVal\n",
    "        nods = modelo.NodeCount\n",
    "        g = 100*modelo.MIPGap\n",
    "        for k in C:\n",
    "            X = []\n",
    "            for i in N:\n",
    "                if x[i,k].x != 0:\n",
    "                    X.append(i)\n",
    "            V.append(X)\n",
    "            Y = []\n",
    "            for j in M:\n",
    "                if y[j,k].x != 0:\n",
    "                    Y.append(j)\n",
    "            E.append(Y)\n",
    "    return V,E,time_r,sol,nods,g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Eliminación de simetrías\n",
    "def F1_pc2(A,W,K):\n",
    "    #Parámetros\n",
    "    #A: matriz de incidencia del hipergrafo\n",
    "    #W: vector de pesos de las hiperaristas\n",
    "    #K: número de particionamiento\n",
    "    n = A.shape[0]   #Número de nodos\n",
    "    m = A.shape[1]   #Número de hiperaristas\n",
    "    nk = int(n/K)     #Tamaño de cada partición\n",
    "    #Listas de conjuntos para las variables\n",
    "    N = np.arange(n)\n",
    "    M = np.arange(m)\n",
    "    C = np.arange(K)\n",
    "    #Creación del modelo\n",
    "    modelo=Model()\n",
    "    modelo.Params.LogToConsole = 0\n",
    "    modelo.Params.timeLimit = 1800\n",
    "    modelo.Params.cuts = 0\n",
    "    modelo._cbCuts = 0\n",
    "    modelo.Params.PreCrush = 1\n",
    "    #creación de variables\n",
    "    x = modelo.addVars(N,C,vtype=GRB.BINARY, name='x')\n",
    "    y = modelo.addVars(M,C,vtype=GRB.BINARY, name='y')\n",
    "    #Función objetivo\n",
    "    obj = quicksum(W[j]*y[j,k] for j in M for k in C)\n",
    "    modelo.setObjective(obj, GRB.MINIMIZE)\n",
    "    #Restricciones\n",
    "    modelo.addConstrs(quicksum(x[i,k] for k in C) == 1 for i in N) #(2.2)\n",
    "    modelo.addConstrs(quicksum(x[i,k] for i in N) == nk for k in C) #(2.3)\n",
    "    modelo.addConstrs(x[i,k] <= quicksum(A[i,j]*y[j,k] for j in M) for k in C for i in N) #(2.4)\n",
    "    modelo.addConstrs(quicksum(y[j,k] for k in C) <= 1 for j in M) #(2.5)\n",
    "    modelo.addConstrs(quicksum(A[i,j]*x[i,k] for i in N) >= sum(A[:,j])*y[j,k] for j in M for k in C) #(2.6)\n",
    "    #Eliminación de simetrías\n",
    "    for c in C:\n",
    "        modelo.addConstr(quicksum(x[c,l] for l in range(c+1,K))==0)\n",
    "        modelo._cbCuts+=1\n",
    "    modelo.update()\n",
    "    modelo.optimize()\n",
    "    #Recuperación de variables\n",
    "    V = []\n",
    "    E = []   \n",
    "    if modelo.SolCount == 0:\n",
    "        time_r = modelo.Runtime\n",
    "        sol = None\n",
    "        nods = None\n",
    "        g = None\n",
    "        return V,E,time_r,sol,nods,g\n",
    "    else:        \n",
    "        time_r = modelo.Runtime\n",
    "        sol = modelo.ObjVal\n",
    "        nods = modelo.NodeCount\n",
    "        g = 100*modelo.MIPGap\n",
    "    \n",
    "        for k in C:\n",
    "            X = []\n",
    "            for i in N:\n",
    "                if x[i,k].x != 0:\n",
    "                    X.append(i)\n",
    "            V.append(X)\n",
    "            Y = []\n",
    "            for j in M:\n",
    "                if y[j,k].x != 0:\n",
    "                    Y.append(j)\n",
    "            E.append(Y)\n",
    "    return V,E,time_r,sol,[nods,modelo._cbCuts],g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Hiperaristas contenidas\n",
    "def F1_pc3(A,W,K):\n",
    "    #Parámetros\n",
    "    #A: matriz de incidencia del hipergrafo\n",
    "    #W: vector de pesos de las hiperaristas\n",
    "    #K: número de particionamiento\n",
    "    n = A.shape[0]   #Número de nodos\n",
    "    m = A.shape[1]   #Número de hiperaristas\n",
    "    nk = int(n/K)     #Tamaño de cada partición\n",
    "    #Listas de conjuntos para las variables\n",
    "    N = np.arange(n)\n",
    "    M = np.arange(m)\n",
    "    C = np.arange(K)\n",
    "    #Creación del modelo\n",
    "    modelo=Model()\n",
    "    modelo.Params.LogToConsole = 0\n",
    "    modelo.Params.timeLimit = 1800\n",
    "    modelo.Params.cuts = 0\n",
    "    modelo._cbCuts = 0\n",
    "    modelo.Params.PreCrush = 1\n",
    "    #creación de variables\n",
    "    x = modelo.addVars(N,C,vtype=GRB.BINARY, name='x')\n",
    "    y = modelo.addVars(M,C,vtype=GRB.BINARY, name='y')\n",
    "    #Función objetivo\n",
    "    obj = quicksum(W[j]*y[j,k] for j in M for k in C)\n",
    "    modelo.setObjective(obj, GRB.MINIMIZE)\n",
    "    #Restricciones\n",
    "    modelo.addConstrs(quicksum(x[i,k] for k in C) == 1 for i in N) #(2.2)\n",
    "    modelo.addConstrs(quicksum(x[i,k] for i in N) == nk for k in C) #(2.3)\n",
    "    modelo.addConstrs(x[i,k] <= quicksum(A[i,j]*y[j,k] for j in M) for k in C for i in N) #(2.4)\n",
    "    modelo.addConstrs(quicksum(y[j,k] for k in C) <= 1 for j in M) #(2.5)\n",
    "    modelo.addConstrs(quicksum(A[i,j]*x[i,k] for i in N) >= sum(A[:,j])*y[j,k] for j in M for k in C) #(2.6)\n",
    "    #Hiperaristas contenidas\n",
    "    y_node = {(j,k): 0 for j in M for k in C}\n",
    "    CONT = cont(A)\n",
    "    def mycallback(modelo,where):\n",
    "        if where == GRB.Callback.MIPNODE:\n",
    "            if modelo.cbGet(GRB.Callback.MIPNODE_STATUS) == GRB.OPTIMAL:\n",
    "                for k in C:\n",
    "                    for j in M:\n",
    "                        y_node[j,k] = modelo.cbGetNodeRel(y[j,k])\n",
    "                for p in CONT.keys():\n",
    "                    for q in CONT[p]:\n",
    "                        ds = quicksum(y_node[p,k]+y_node[q,k] for k in C)\n",
    "                        if  ds.getValue()>1:\n",
    "                            modelo.cbCut(quicksum(y[p,k]+y[q,k] for k in C) <= 1)\n",
    "                            modelo._cbCuts+=1\n",
    "                        else:\n",
    "                            pass\n",
    "    modelo.update()\n",
    "    modelo.optimize(mycallback)\n",
    "    #Recuperación de variables\n",
    "    V = []\n",
    "    E = []   \n",
    "    if modelo.SolCount == 0:\n",
    "        time_r = modelo.Runtime\n",
    "        sol = None\n",
    "        nods = None\n",
    "        g = None\n",
    "        return V,E,time_r,sol,nods,g\n",
    "    else:        \n",
    "        time_r = modelo.Runtime\n",
    "        sol = modelo.ObjVal\n",
    "        nods=modelo.NodeCount\n",
    "        g = 100*modelo.MIPGap\n",
    "        for k in C:\n",
    "            X = []\n",
    "            for i in N:\n",
    "                if x[i,k].x != 0:\n",
    "                    X.append(i)\n",
    "            V.append(X)\n",
    "            Y = []\n",
    "            for j in M:\n",
    "                if y[j,k].x != 0:\n",
    "                    Y.append(j)\n",
    "            E.append(Y)\n",
    "    return V,E,time_r,sol,[nods,modelo._cbCuts],g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Restricción tipo knapsack\n",
    "def F1_pc4(A,W,K):\n",
    "    #Parámetros\n",
    "    #A: matriz de incidencia del hipergrafo\n",
    "    #W: vector de pesos de las hiperaristas\n",
    "    #K: número de particionamiento\n",
    "    n = A.shape[0]   #Número de nodos\n",
    "    m = A.shape[1]   #Número de hiperaristas\n",
    "    nk = int(n/K)     #Tamaño de cada partición\n",
    "    #Listas de conjuntos para las variables\n",
    "    N = np.arange(n)\n",
    "    M = np.arange(m)\n",
    "    C = np.arange(K)\n",
    "    #Creación del modelo\n",
    "    modelo=Model()\n",
    "    modelo.Params.LogToConsole = 0\n",
    "    modelo.Params.timeLimit = 1800\n",
    "    modelo.Params.cuts = 0\n",
    "    modelo._cbCuts = 0\n",
    "    modelo.Params.PreCrush = 1\n",
    "    #creación de variables\n",
    "    x = modelo.addVars(N,C,vtype=GRB.BINARY, name='x')\n",
    "    y = modelo.addVars(M,C,vtype=GRB.BINARY, name='y')\n",
    "    #Función objetivo\n",
    "    obj = quicksum(W[j]*y[j,k] for j in M for k in C)\n",
    "    modelo.setObjective(obj, GRB.MINIMIZE)\n",
    "    #Restricciones\n",
    "    modelo.addConstrs(quicksum(x[i,k] for k in C) == 1 for i in N) #(2.2)\n",
    "    modelo.addConstrs(quicksum(x[i,k] for i in N) == nk for k in C) #(2.3)\n",
    "    modelo.addConstrs(x[i,k] <= quicksum(A[i,j]*y[j,k] for j in M) for k in C for i in N) #(2.4)\n",
    "    modelo.addConstrs(quicksum(y[j,k] for k in C) <= 1 for j in M) #(2.5)\n",
    "    modelo.addConstrs(quicksum(A[i,j]*x[i,k] for i in N) >= sum(A[:,j])*y[j,k] for j in M for k in C) #(2.6)\n",
    "    #Desigualdades tipo knapsack\n",
    "    y_node = {(j,k): 0 for j in M for k in C}\n",
    "    Min3 = minimal3(A,nk)\n",
    "    def mycallback(modelo,where):\n",
    "        if where == GRB.Callback.MIPNODE:\n",
    "            if modelo.cbGet(GRB.Callback.MIPNODE_STATUS) == GRB.OPTIMAL:\n",
    "                for k in C:\n",
    "                    for j in M:\n",
    "                        y_node[j,k] = modelo.cbGetNodeRel(y[j,k])\n",
    "                for s in Min3:\n",
    "                    for k in C:\n",
    "                        ds = quicksum(y_node[j,k] for j in s)\n",
    "                        if ds.getValue()>len(s)-1:\n",
    "                            modelo.cbCut(quicksum(y[j,k] for j in s) <= len(s)-1)\n",
    "                            modelo._cbCuts+=1\n",
    "                    else:\n",
    "                        pass\n",
    "    modelo.update()\n",
    "    modelo.optimize(mycallback)\n",
    "    #Recuperación de variables\n",
    "    V = []\n",
    "    E = []   \n",
    "    if modelo.SolCount == 0:\n",
    "        time_r = modelo.Runtime\n",
    "        sol = None\n",
    "        nods = None\n",
    "        g = None\n",
    "        return V,E,time_r,sol,nods,g\n",
    "    else:        \n",
    "        time_r = modelo.Runtime\n",
    "        sol = modelo.ObjVal\n",
    "        nods = modelo.NodeCount\n",
    "        g = 100*modelo.MIPGap\n",
    "        for k in C:\n",
    "            X = []\n",
    "            for i in N:\n",
    "                if x[i,k].x != 0:\n",
    "                    X.append(i)\n",
    "            V.append(X)\n",
    "            Y = []\n",
    "            for j in M:\n",
    "                if y[j,k].x != 0:\n",
    "                    Y.append(j)\n",
    "            E.append(Y)\n",
    "    return V,E,time_r,sol,[nods,modelo._cbCuts],g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Combinación ES+CO\n",
    "def F1_pc_23(A,W,K):\n",
    "    #Parámetros\n",
    "    #A: matriz de incidencia del hipergrafo\n",
    "    #W: vector de pesos de las hiperaristas\n",
    "    #K: número de particionamiento\n",
    "    n = A.shape[0]   #Número de nodos\n",
    "    m = A.shape[1]   #Número de hiperaristas\n",
    "    nk = int(n/K)     #Tamaño de cada partición\n",
    "    #Listas de conjuntos para las variables\n",
    "    N = np.arange(n)\n",
    "    M = np.arange(m)\n",
    "    C = np.arange(K)\n",
    "    #Creación del modelo\n",
    "    modelo=Model()\n",
    "    modelo.Params.LogToConsole = 0\n",
    "    modelo.Params.timeLimit = 1800\n",
    "    modelo.Params.cuts = 0\n",
    "    modelo._cbCuts = 0\n",
    "    modelo.Params.PreCrush = 1\n",
    "    #creación de variables\n",
    "    x = modelo.addVars(N,C,vtype=GRB.BINARY, name='x')\n",
    "    y = modelo.addVars(M,C,vtype=GRB.BINARY, name='y')\n",
    "    #Función objetivo\n",
    "    obj = quicksum(W[j]*y[j,k] for j in M for k in C)\n",
    "    modelo.setObjective(obj, GRB.MINIMIZE)\n",
    "    #Restricciones\n",
    "    modelo.addConstrs(quicksum(x[i,k] for k in C) == 1 for i in N) #(2.2)\n",
    "    modelo.addConstrs(quicksum(x[i,k] for i in N) == nk for k in C) #(2.3)\n",
    "    modelo.addConstrs(x[i,k] <= quicksum(A[i,j]*y[j,k] for j in M) for k in C for i in N) #(2.4)\n",
    "    modelo.addConstrs(quicksum(y[j,k] for k in C) <= 1 for j in M) #(2.5)\n",
    "    modelo.addConstrs(quicksum(A[i,j]*x[i,k] for i in N) >= sum(A[:,j])*y[j,k] for j in M for k in C) #(2.6)\n",
    "    #Eliminación de simetrías\n",
    "    for c in C:\n",
    "        modelo.addConstr(quicksum(x[c,l] for l in range(c+1,K))==0)\n",
    "        modelo._cbCuts+=1\n",
    "    #Hiperaristas contenidas\n",
    "    y_node = {(j,k): 0 for j in M for k in C}\n",
    "    CONT = cont(A)\n",
    "    def mycallback(modelo,where):\n",
    "        if where == GRB.Callback.MIPNODE:\n",
    "            if modelo.cbGet(GRB.Callback.MIPNODE_STATUS) == GRB.OPTIMAL:\n",
    "                for k in C:\n",
    "                    for j in M:\n",
    "                        y_node[j,k] = modelo.cbGetNodeRel(y[j,k])\n",
    "                for p in CONT.keys():\n",
    "                    for q in CONT[p]:\n",
    "                        ds = quicksum(y_node[p,k]+y_node[q,k] for k in C)\n",
    "                        if  ds.getValue()>1:\n",
    "                            modelo.cbCut(quicksum(y[p,k]+y[q,k] for k in C) <= 1)\n",
    "                            modelo._cbCuts+=1\n",
    "                        else:\n",
    "                            pass\n",
    "    modelo.update()\n",
    "    modelo.optimize(mycallback)\n",
    "    #Recuperación de variables\n",
    "    V = []\n",
    "    E = []   \n",
    "    if modelo.SolCount == 0:\n",
    "        time_r = modelo.Runtime\n",
    "        sol = None\n",
    "        nods = None\n",
    "        g = None\n",
    "        return V,E,time_r,sol,nods,g\n",
    "    else:        \n",
    "        time_r = modelo.Runtime\n",
    "        sol = modelo.ObjVal\n",
    "        nods = modelo.NodeCount\n",
    "        g = 100*modelo.MIPGap\n",
    "        for k in C:\n",
    "            X = []\n",
    "            for i in N:\n",
    "                if x[i,k].x != 0:\n",
    "                    X.append(i)\n",
    "            V.append(X)\n",
    "            Y = []\n",
    "            for j in M:\n",
    "                if y[j,k].x != 0:\n",
    "                    Y.append(j)\n",
    "            E.append(Y)\n",
    "    return V,E,time_r,sol,[nods,modelo._cbCuts],g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Combinación ES+KS\n",
    "def F1_pc_24(A,W,K):\n",
    "    #Parámetros\n",
    "    #A: matriz de incidencia del hipergrafo\n",
    "    #W: vector de pesos de las hiperaristas\n",
    "    #K: número de particionamiento\n",
    "    n = A.shape[0]   #Número de nodos\n",
    "    m = A.shape[1]   #Número de hiperaristas\n",
    "    nk = int(n/K)     #Tamaño de cada partición\n",
    "    #Listas de conjuntos para las variables\n",
    "    N = np.arange(n)\n",
    "    M = np.arange(m)\n",
    "    C = np.arange(K)\n",
    "    #Creación del modelo\n",
    "    modelo=Model()\n",
    "    modelo.Params.LogToConsole = 0\n",
    "    modelo.Params.timeLimit = 1800\n",
    "    modelo.Params.cuts = 0\n",
    "    modelo._cbCuts = 0\n",
    "    modelo.Params.PreCrush = 1\n",
    "    #creación de variables\n",
    "    x = modelo.addVars(N,C,vtype=GRB.BINARY, name='x')\n",
    "    y = modelo.addVars(M,C,vtype=GRB.BINARY, name='y')\n",
    "    #Función objetivo\n",
    "    obj = quicksum(W[j]*y[j,k] for j in M for k in C)\n",
    "    modelo.setObjective(obj, GRB.MINIMIZE)\n",
    "    #Restricciones\n",
    "    modelo.addConstrs(quicksum(x[i,k] for k in C) == 1 for i in N) #(2.2)\n",
    "    modelo.addConstrs(quicksum(x[i,k] for i in N) == nk for k in C) #(2.3)\n",
    "    modelo.addConstrs(x[i,k] <= quicksum(A[i,j]*y[j,k] for j in M) for k in C for i in N) #(2.4)\n",
    "    modelo.addConstrs(quicksum(y[j,k] for k in C) <= 1 for j in M) #(2.5)\n",
    "    modelo.addConstrs(quicksum(A[i,j]*x[i,k] for i in N) >= sum(A[:,j])*y[j,k] for j in M for k in C) #(2.6)\n",
    "    #Eliminación de simetrías\n",
    "    for c in C:\n",
    "        modelo.addConstr(quicksum(x[c,l] for l in range(c+1,K))==0)\n",
    "        modelo._cbCuts+=1\n",
    "    #Desigualdades tipo knapsack\n",
    "    y_node = {(j,k): 0 for j in M for k in C}\n",
    "    Min3 = minimal3(A,nk)\n",
    "    def mycallback(modelo,where):\n",
    "        if where == GRB.Callback.MIPNODE:\n",
    "            if modelo.cbGet(GRB.Callback.MIPNODE_STATUS) == GRB.OPTIMAL:\n",
    "                for k in C:\n",
    "                    for j in M:\n",
    "                        y_node[j,k] = modelo.cbGetNodeRel(y[j,k])\n",
    "                for s in Min3:\n",
    "                    for k in C:\n",
    "                        ds = quicksum(y_node[j,k] for j in s)\n",
    "                        if ds.getValue()>len(s)-1:\n",
    "                            modelo.cbCut(quicksum(y[j,k] for j in s) <= len(s)-1)\n",
    "                            modelo._cbCuts+=1\n",
    "                    else:\n",
    "                        pass\n",
    "    modelo.update()\n",
    "    modelo.optimize(mycallback)\n",
    "    #Recuperación de variables\n",
    "    V = []\n",
    "    E = []   \n",
    "    if modelo.SolCount == 0:\n",
    "        time_r = modelo.Runtime\n",
    "        sol = None\n",
    "        nods = None\n",
    "        g = None\n",
    "        return V,E,time_r,sol,nods,g\n",
    "    else:        \n",
    "        time_r = modelo.Runtime\n",
    "        sol = modelo.ObjVal\n",
    "        nods = modelo.NodeCount\n",
    "        g = 100*modelo.MIPGap\n",
    "        for k in C:\n",
    "            X = []\n",
    "            for i in N:\n",
    "                if x[i,k].x != 0:\n",
    "                    X.append(i)\n",
    "            V.append(X)\n",
    "            Y = []\n",
    "            for j in M:\n",
    "                if y[j,k].x != 0:\n",
    "                    Y.append(j)\n",
    "            E.append(Y)\n",
    "    return V,E,time_r,sol,[nods,modelo._cbCuts],g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Combinación CO+KS\n",
    "def F1_pc_34(A,W,K):\n",
    "    #Parámetros\n",
    "    #A: matriz de incidencia del hipergrafo\n",
    "    #W: vector de pesos de las hiperaristas\n",
    "    #K: número de particionamiento\n",
    "    n = A.shape[0]   #Número de nodos\n",
    "    m = A.shape[1]   #Número de hiperaristas\n",
    "    nk = int(n/K)     #Tamaño de cada partición\n",
    "    #Listas de conjuntos para las variables\n",
    "    N = np.arange(n)\n",
    "    M = np.arange(m)\n",
    "    C = np.arange(K)\n",
    "    #Creación del modelo\n",
    "    modelo=Model()\n",
    "    modelo.Params.LogToConsole = 0\n",
    "    modelo.Params.timeLimit = 1800\n",
    "    modelo.Params.cuts = 0\n",
    "    modelo._cbCuts = 0\n",
    "    modelo.Params.PreCrush = 1\n",
    "    #creación de variables\n",
    "    x = modelo.addVars(N,C,vtype=GRB.BINARY, name='x')\n",
    "    y = modelo.addVars(M,C,vtype=GRB.BINARY, name='y')\n",
    "    #Función objetivo\n",
    "    obj = quicksum(W[j]*y[j,k] for j in M for k in C)\n",
    "    modelo.setObjective(obj, GRB.MINIMIZE)\n",
    "    #Restricciones\n",
    "    modelo.addConstrs(quicksum(x[i,k] for k in C) == 1 for i in N) #(2.2)\n",
    "    modelo.addConstrs(quicksum(x[i,k] for i in N) == nk for k in C) #(2.3)\n",
    "    modelo.addConstrs(x[i,k] <= quicksum(A[i,j]*y[j,k] for j in M) for k in C for i in N) #(2.4)\n",
    "    modelo.addConstrs(quicksum(y[j,k] for k in C) <= 1 for j in M) #(2.5)\n",
    "    modelo.addConstrs(quicksum(A[i,j]*x[i,k] for i in N) >= sum(A[:,j])*y[j,k] for j in M for k in C) #(2.6)\n",
    "    #Hiperaristas contenidas y Desigualdades tipo knapsack\n",
    "    y_node = {(j,k): 0 for j in M for k in C}\n",
    "    CONT = cont(A)\n",
    "    Min3 = minimal3(A,nk)\n",
    "    def mycallback(modelo,where):\n",
    "        if where == GRB.Callback.MIPNODE:\n",
    "            if modelo.cbGet(GRB.Callback.MIPNODE_STATUS) == GRB.OPTIMAL:\n",
    "                for k in C:\n",
    "                    for j in M:\n",
    "                        y_node[j,k] = modelo.cbGetNodeRel(y[j,k])\n",
    "                for p in CONT.keys():\n",
    "                    for q in CONT[p]:\n",
    "                        ds = quicksum(y_node[p,k]+y_node[q,k] for k in C)\n",
    "                        if  ds.getValue()>1:\n",
    "                            modelo.cbCut(quicksum(y[p,k]+y[q,k] for k in C) <= 1)\n",
    "                            modelo._cbCuts += 1\n",
    "                        else:\n",
    "                            pass\n",
    "                for s in Min3:\n",
    "                    for k in C:\n",
    "                        ds = quicksum(y_node[j,k] for j in s)\n",
    "                        if ds.getValue()>len(s)-1:\n",
    "                            modelo.cbCut(quicksum(y[j,k] for j in s) <= len(s)-1)\n",
    "                            modelo._cbCuts += 1\n",
    "                    else:\n",
    "                        pass\n",
    "    modelo.update()\n",
    "    modelo.optimize(mycallback)\n",
    "    #Recuperación de variables\n",
    "    V = []\n",
    "    E = []   \n",
    "    if modelo.SolCount == 0:\n",
    "        time_r = modelo.Runtime\n",
    "        sol = None\n",
    "        nods = None\n",
    "        g = None\n",
    "        return V,E,time_r,sol,nods,g\n",
    "    else:        \n",
    "        time_r = modelo.Runtime\n",
    "        sol = modelo.ObjVal\n",
    "        nods = modelo.NodeCount\n",
    "        g = 100*modelo.MIPGap\n",
    "        for k in C:\n",
    "            X = []\n",
    "            for i in N:\n",
    "                if x[i,k].x != 0:\n",
    "                    X.append(i)\n",
    "            V.append(X)\n",
    "            Y = []\n",
    "            for j in M:\n",
    "                if y[j,k].x != 0:\n",
    "                    Y.append(j)\n",
    "            E.append(Y)\n",
    "    return V,E,time_r,sol,[nods,modelo._cbCuts],g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "P = np.array([[45,100],\n",
    "              [45,200],\n",
    "              [45,500],\n",
    "              [90,150],\n",
    "              [90,500],\n",
    "              [90,1000],\n",
    "              [150,300],\n",
    "              [150,800],\n",
    "              [150,1500],\n",
    "              [180,400],\n",
    "              [180,1000],\n",
    "              [180,2000]])\n",
    "tam = {45:[2,5,10],\n",
    "       90:[2,5,10,20],\n",
    "       150:[2,5,10,20],\n",
    "       180:[2,5,10,20]}\n",
    "R = []\n",
    "for p in P:\n",
    "    for t in tam[p[0]]:\n",
    "        n = p[0]\n",
    "        m = p[1]\n",
    "        K = 3\n",
    "        sol =None\n",
    "        tr=0\n",
    "        i=0\n",
    "        while sol==None and tr<1000:\n",
    "            A = rand_hgraf(n,m,t)\n",
    "            pr = prom(A)\n",
    "            W = np.random.randint(1,21,size=m)\n",
    "            if t==2 and m/n <3:\n",
    "                V,E,tr,sol,nod,g = F1(A,W,K)\n",
    "                V1,E1,tr1,sol1,nod1,g1 = F1_pc1(A,W,K)\n",
    "                V2,E2,tr2,sol2,nod2,g2 = F1_pc2(A,W,K)\n",
    "                V3,E3,tr3,sol3,nod3,g3 = None,None,None,None,None,None\n",
    "                V4,E4,tr4,sol4,nod4,g4 = F1_pc4(A,W,K)\n",
    "                V23,E23,tr23,sol23,nod23,g23 = F1_pc_23(A,W,K)\n",
    "                V24,E24,tr24,sol24,nod24,g24 = F1_pc_24(A,W,K)\n",
    "                V34,E34,tr34,sol34,nod34,g34 = F1_pc_34(A,W,K)\n",
    "            elif t==2 and m/n >3:\n",
    "                V,E,tr,sol,nod,g = F1(A,W,K)\n",
    "                V1,E1,tr1,sol1,nod1,g1 = None,None,None,None,None,None\n",
    "                V2,E2,tr2,sol2,nod2,g2 = F1_pc2(A,W,K)\n",
    "                V3,E3,tr3,sol3,nod3,g3 = None,None,None,None,None,None\n",
    "                V4,E4,tr4,sol4,nod4,g4 = F1_pc4(A,W,K)\n",
    "                V23,E23,tr23,sol23,nod23,g23 = F1_pc_23(A,W,K)\n",
    "                V24,E24,tr24,sol24,nod24,g24 = F1_pc_24(A,W,K)\n",
    "                V34,E34,tr34,sol34,nod34,g34 = F1_pc_34(A,W,K)\n",
    "            else:\n",
    "                V,E,tr,sol,nod,g = F1(A,W,K)\n",
    "                V1,E1,tr1,sol1,nod1,g1 = None,None,None,None,None,None\n",
    "                V2,E2,tr2,sol2,nod2,g2 = F1_pc2(A,W,K)\n",
    "                V3,E3,tr3,sol3,nod3,g3 = F1_pc3(A,W,K)\n",
    "                V4,E4,tr4,sol4,nod4,g4 = F1_pc4(A,W,K)\n",
    "                V23,E23,tr23,sol23,nod23,g23 = F1_pc_23(A,W,K)\n",
    "                V24,E24,tr24,sol24,nod24,g24 = F1_pc_24(A,W,K)\n",
    "                V34,E34,tr34,sol34,nod34,g34 = F1_pc_34(A,W,K)\n",
    "            i += 1\n",
    "            if i >=10:\n",
    "                break        \n",
    "        Tr=[tr,tr1,tr2,tr3,tr4,tr23,tr24,tr34]\n",
    "        S=[sol,sol1,sol2,sol3,sol4,sol23,sol24,sol34]\n",
    "        Nd=[nod,nod1,nod2,nod3,nod4,nod23,nod24,nod34]\n",
    "        G=[g,g1,g2,g3,g4,g23,g24,g34]\n",
    "        R.append([p,pr,t,Tr,S,Nd,G])\n",
    "        #print(Tr,S)\n",
    "        #print(Nd)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Df = pd.DataFrame(columns=['Instancia','Prom','Tam. max','Plano cortante','Valor Función Objetivo','GAP', 'Nodos','Tiempo [s]'],\n",
    "                 index=np.arange(len(R)*8))\n",
    "pc = ['NA','TH','ES','CO','KS','ES+CO','ES+KS','CO+KS']\n",
    "for x in range(len(R)):\n",
    "    for y in range(8):\n",
    "        Df.at[8*x+y,'Instancia']=R[x][0]\n",
    "        Df.at[8*x+y,'Prom']=R[x][1]\n",
    "        Df.at[8*x+y,'Tam. max']=R[x][2]\n",
    "        Df.at[8*x+y,'Plano cortante']=pc[y]\n",
    "        Df.at[8*x+y,'Valor Función Objetivo']=R[x][4][y]\n",
    "        Df.at[8*x+y,'GAP']=R[x][6][y]\n",
    "        Df.at[8*x+y,'Nodos']=R[x][5][y]\n",
    "        Df.at[8*x+y,'Tiempo [s]']=R[x][3][y]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Df.to_excel('pruebas_F1.xlsx')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_excel('pruebas_F1.xlsx') \n",
    "INST = df['Instancia'].tolist()\n",
    "Tiempo = df['Tiempo [s]'].tolist()\n",
    "Plano = df['Plano cortante'].tolist()\n",
    "GAP = df['GAP'].tolist()\n",
    "TAM = df['Tam. max'].tolist()\n",
    "P = list([[45,100],\n",
    "          [45,200],\n",
    "          [45,500],\n",
    "          [90,150],\n",
    "          [90,500],\n",
    "          [90,1000],\n",
    "          [150,300],\n",
    "          [150,800],\n",
    "          [150,1500],\n",
    "          [180,400],\n",
    "          [180,1000],\n",
    "          [180,2000]])\n",
    "pc = ['NA','TH','ES','CO','KS','ES+CO','ES+KS','CO+KS']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "I = []\n",
    "for x in P:\n",
    "    if x[0] == 45:\n",
    "        for y in [2,5,10]:\n",
    "            I.append([x,y])\n",
    "    elif x[0] == 90:\n",
    "        for y in [2,5,10,20]:\n",
    "            I.append([x,y])\n",
    "    elif x[0] == 150:\n",
    "        for y in [2,5,10,20]:\n",
    "            I.append([x,y])\n",
    "    elif x[0] == 180:\n",
    "        for y in [2,5,10,20]:\n",
    "            I.append([x,y])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "T_tam2 = []\n",
    "T_tam5  = []\n",
    "T_tam10  = []\n",
    "T_tam20  = []\n",
    "G_tam2  = []\n",
    "G_tam5  = []\n",
    "G_tam10  = []\n",
    "G_tam20  = []\n",
    "com2=[]\n",
    "com5=[]\n",
    "com10=[]\n",
    "com20=[]\n",
    "for x in range(len(I)):\n",
    "    tam = I[x][1]\n",
    "    if tam==2:\n",
    "        tiempo = [Tiempo[8*x+y] for y in range(8)]\n",
    "        T_tam2.append(tiempo)\n",
    "        g = [GAP[8*x+y] for y in range(8)]\n",
    "        G_tam2.append(g)\n",
    "        com2.append(str(I[x][0]))\n",
    "    elif tam==5:\n",
    "        tiempo = [Tiempo[8*x+y] for y in range(8)]\n",
    "        T_tam5.append(tiempo)\n",
    "        g = [GAP[8*x+y] for y in range(8)]\n",
    "        G_tam5.append(g)\n",
    "        com5.append(str(I[x][0]))\n",
    "    elif tam==10:\n",
    "        tiempo = [Tiempo[8*x+y] for y in range(8)]\n",
    "        T_tam10.append(tiempo)\n",
    "        g = [GAP[8*x+y] for y in range(8)]\n",
    "        G_tam10.append(g)\n",
    "        com10.append(str(I[x][0]))\n",
    "    elif tam==20:\n",
    "        tiempo = [Tiempo[8*x+y] for y in range(8)]\n",
    "        T_tam20.append(tiempo)\n",
    "        g = [GAP[8*x+y] for y in range(8)]\n",
    "        G_tam20.append(g)\n",
    "        com20.append(str(I[x][0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "fig1 ,axs1 = plt.subplots(1,2,figsize=(26,12)) #tam2\n",
    "fig2 ,axs2 = plt.subplots(1,2,figsize=(26,12)) #tam5\n",
    "fig3 ,axs3 = plt.subplots(1,2,figsize=(26,12)) #tam10\n",
    "fig4 ,axs4 = plt.subplots(1,2,figsize=(26,12)) #tam20\n",
    "x_offset=0.5\n",
    "import matplotlib.lines as mlines\n",
    "line_parm = {\n",
    "            0:{'color':'red', 'marker':'o', 'linestyle':'dashed','linewidth':2, 'markersize':5, 'label':'Ninguno'},\n",
    "            1:{'color':'green', 'marker':'x', 'linestyle':'-', 'linewidth':1,'markersize':5, 'label':'TH'},\n",
    "            2:{'color':'blue', 'marker':'v', 'linestyle':'-', 'linewidth':1,'markersize':5, 'label':'ES'},\n",
    "            3:{'color':'cyan', 'marker':'s', 'linestyle':'-', 'linewidth':1,'markersize':5, 'label':'CO'},\n",
    "            4:{'color':'orange', 'marker':'D', 'linestyle':'-', 'linewidth':1,'markersize':5, 'label':'KS'},\n",
    "            5:{'color':'purple', 'marker':'+', 'linestyle':'-', 'linewidth':1,'markersize':5, 'label':'ES+CO'},\n",
    "            6:{'color':'gray', 'marker':'^', 'linestyle':'-', 'linewidth':1,'markersize':5, 'label':'ES+KS'},\n",
    "            7:{'color':'magenta', 'marker':'<', 'linestyle':'-', 'linewidth':1,'markersize':5, 'label':'CO+KS'}\n",
    "}\n",
    "mod = [\n",
    "    mlines.Line2D([], [], color='red', marker='o', linestyle='None',\n",
    "                          markersize=5, label='Ninguno'),\n",
    "     mlines.Line2D([], [], color='green', marker='x', linestyle='None',\n",
    "                        markersize=5, label='TH'),\n",
    "     mlines.Line2D([], [], color='blue', marker='v', linestyle='None',\n",
    "                        markersize=5, label='ES'),\n",
    "     mlines.Line2D([], [], color='cyan', marker='s', linestyle='None',\n",
    "                        markersize=5, label='CO'),\n",
    "     mlines.Line2D([], [], color='orange', marker='D', linestyle='None',\n",
    "                        markersize=5, label='KS'),\n",
    "     mlines.Line2D([], [], color='purple', marker='+', linestyle='None',\n",
    "                        markersize=5, label='ES+CO'),\n",
    "     mlines.Line2D([], [], color='gray', marker='^', linestyle='None',\n",
    "                        markersize=5, label='ES+KS'),\n",
    "     mlines.Line2D([], [], color='magenta', marker='<', linestyle='None',\n",
    "                              markersize=5, label='CO+KS')]\n",
    "#TAM2\n",
    "axs1[0].set_xticklabels(com2,rotation=90,fontsize=20)\n",
    "axs1[0].tick_params(axis='y', labelsize=15)\n",
    "axs1[0].set_xlabel('[V E]',fontsize=15)\n",
    "axs1[0].set_yscale('log')\n",
    "axs1[0].set_ylabel('tiempo [s]',fontsize=15)\n",
    "axs1[0].plot(com2,[x[0] for x in T_tam2],**line_parm[0])\n",
    "axs1[0].plot(com2,[x[1] for x in T_tam2],**line_parm[1])\n",
    "axs1[0].plot(com2,[x[2] for x in T_tam2],**line_parm[2])\n",
    "axs1[0].plot(com2,[x[3] for x in T_tam2],**line_parm[3])\n",
    "axs1[0].plot(com2,[x[4] for x in T_tam2],**line_parm[4])\n",
    "axs1[0].plot(com2,[x[5] for x in T_tam2],**line_parm[5])\n",
    "axs1[0].plot(com2,[x[6] for x in T_tam2],**line_parm[6])\n",
    "axs1[0].plot(com2,[x[7] for x in T_tam2],**line_parm[7])\n",
    "axs1[0].legend(handles=mod,fontsize=15)\n",
    "axs1[0].grid(True)\n",
    "axs1[1].set_xticklabels(com2,rotation=90,fontsize=20)\n",
    "axs1[1].tick_params(axis='y', labelsize=15)\n",
    "axs1[1].set_xlabel('[V E]',fontsize=15)\n",
    "axs1[1].set_ylabel('GAP [%]',fontsize=15)\n",
    "axs1[1].set_ylim(-0.1)\n",
    "axs1[1].plot(com2,[x[0] for x in G_tam2],**line_parm[0])\n",
    "axs1[1].plot(com2,[x[1] for x in G_tam2],**line_parm[1])\n",
    "axs1[1].plot(com2,[x[2] for x in G_tam2],**line_parm[2])\n",
    "axs1[1].plot(com2,[x[3] for x in G_tam2],**line_parm[3])\n",
    "axs1[1].plot(com2,[x[4] for x in G_tam2],**line_parm[4])\n",
    "axs1[1].plot(com2,[x[5] for x in G_tam2],**line_parm[5])\n",
    "axs1[1].plot(com2,[x[6] for x in G_tam2],**line_parm[6])\n",
    "axs1[1].plot(com2,[x[7] for x in G_tam2],**line_parm[7])\n",
    "axs1[1].legend(handles=mod,fontsize=15)\n",
    "axs1[1].grid(True)\n",
    "fig1.savefig('F1_tam2.jpg',bbox_inches='tight',dpi=300)\n",
    "#TAM5\n",
    "axs2[0].set_xticklabels(com5,rotation=90,fontsize=20)\n",
    "axs2[0].tick_params(axis='y', labelsize=15)\n",
    "axs2[0].set_xlabel('[V E]',fontsize=15)\n",
    "axs2[0].set_yscale('log')\n",
    "axs2[0].set_ylabel('tiempo [s]',fontsize=15)\n",
    "axs2[0].plot(com5,[x[0] for x in T_tam5],**line_parm[0])\n",
    "axs2[0].plot(com5,[x[1] for x in T_tam5],**line_parm[1])\n",
    "axs2[0].plot(com5,[x[2] for x in T_tam5],**line_parm[2])\n",
    "axs2[0].plot(com5,[x[3] for x in T_tam5],**line_parm[3])\n",
    "axs2[0].plot(com5,[x[4] for x in T_tam5],**line_parm[4])\n",
    "axs2[0].plot(com5,[x[5] for x in T_tam5],**line_parm[5])\n",
    "axs2[0].plot(com5,[x[6] for x in T_tam5],**line_parm[6])\n",
    "axs2[0].plot(com5,[x[7] for x in T_tam5],**line_parm[7])\n",
    "axs2[0].legend(handles=mod,fontsize=15)\n",
    "axs2[0].grid(True)\n",
    "axs2[1].set_xticklabels(com5,rotation=90,fontsize=20)\n",
    "axs2[1].tick_params(axis='y', labelsize=15)\n",
    "axs2[1].set_xlabel('[V E]',fontsize=15)\n",
    "axs2[1].set_ylabel('GAP [%]',fontsize=15)\n",
    "axs2[1].set_ylim(-0.1)\n",
    "axs2[1].plot(com5,[x[0] for x in G_tam5],**line_parm[0])\n",
    "axs2[1].plot(com5,[x[1] for x in G_tam5],**line_parm[1])\n",
    "axs2[1].plot(com5,[x[2] for x in G_tam5],**line_parm[2])\n",
    "axs2[1].plot(com5,[x[3] for x in G_tam5],**line_parm[3])\n",
    "axs2[1].plot(com5,[x[4] for x in G_tam5],**line_parm[4])\n",
    "axs2[1].plot(com5,[x[5] for x in G_tam5],**line_parm[5])\n",
    "axs2[1].plot(com5,[x[6] for x in G_tam5],**line_parm[6])\n",
    "axs2[1].plot(com5,[x[7] for x in G_tam5],**line_parm[7])\n",
    "axs2[1].legend(handles=mod,fontsize=15)\n",
    "axs2[1].grid(True)\n",
    "fig2.savefig('F1_tam5.jpg',bbox_inches='tight',dpi=300)\n",
    "#TAM10\n",
    "axs3[0].set_xticklabels(com10,rotation=90,fontsize=20)\n",
    "axs3[0].tick_params(axis='y', labelsize=15)\n",
    "axs3[0].set_xlabel('[V E]',fontsize=15)\n",
    "axs3[0].set_yscale('log')\n",
    "axs3[0].set_ylabel('tiempo [s]',fontsize=15)\n",
    "axs3[0].plot(com10,[x[0] for x in T_tam10],**line_parm[0])\n",
    "axs3[0].plot(com10,[x[1] for x in T_tam10],**line_parm[1])\n",
    "axs3[0].plot(com10,[x[2] for x in T_tam10],**line_parm[2])\n",
    "axs3[0].plot(com10,[x[3] for x in T_tam10],**line_parm[3])\n",
    "axs3[0].plot(com10,[x[4] for x in T_tam10],**line_parm[4])\n",
    "axs3[0].plot(com10,[x[5] for x in T_tam10],**line_parm[5])\n",
    "axs3[0].plot(com10,[x[6] for x in T_tam10],**line_parm[6])\n",
    "axs3[0].plot(com10,[x[7] for x in T_tam10],**line_parm[7])\n",
    "axs3[0].legend(handles=mod,fontsize=15)\n",
    "axs3[0].grid(True)\n",
    "axs3[1].set_xticklabels(com10,rotation=90,fontsize=20)\n",
    "axs3[1].tick_params(axis='y', labelsize=15)\n",
    "axs3[1].set_xlabel('[V E]',fontsize=15)\n",
    "axs3[1].set_xlim(-x_offset,len(com10)-1+x_offset)\n",
    "axs3[1].set_ylabel('GAP [%]',fontsize=15)\n",
    "axs3[1].set_ylim(-5,85)\n",
    "axs3[1].plot(com10,[x[0] for x in G_tam10],**line_parm[0])\n",
    "axs3[1].plot(com10,[x[1] for x in G_tam10],**line_parm[1])\n",
    "axs3[1].plot(com10,[x[2] for x in G_tam10],**line_parm[2])\n",
    "axs3[1].plot(com10,[x[3] for x in G_tam10],**line_parm[3])\n",
    "axs3[1].plot(com10,[x[4] for x in G_tam10],**line_parm[4])\n",
    "axs3[1].plot(com10,[x[5] for x in G_tam10],**line_parm[5])\n",
    "axs3[1].plot(com10,[x[6] for x in G_tam10],**line_parm[6])\n",
    "axs3[1].plot(com10,[x[7] for x in G_tam10],**line_parm[7])\n",
    "axs3[1].legend(handles=mod,fontsize=15)\n",
    "axs3[1].grid(True)\n",
    "fig3.savefig('F1_tam10.jpg',bbox_inches='tight',dpi=300)\n",
    "#TAM20\n",
    "axs4[0].set_xticklabels(com20,rotation=90,fontsize=20)\n",
    "axs4[0].tick_params(axis='y', labelsize=15)\n",
    "axs4[0].set_xlabel('[V E]',fontsize=15)\n",
    "axs4[0].set_yscale('log')\n",
    "axs4[0].set_ylabel('tiempo [s]',fontsize=15)\n",
    "axs4[0].plot(com20,[x[0] for x in T_tam20],**line_parm[0])\n",
    "axs4[0].plot(com20,[x[1] for x in T_tam20],**line_parm[1])\n",
    "axs4[0].plot(com20,[x[2] for x in T_tam20],**line_parm[2])\n",
    "axs4[0].plot(com20,[x[3] for x in T_tam20],**line_parm[3])\n",
    "axs4[0].plot(com20,[x[4] for x in T_tam20],**line_parm[4])\n",
    "axs4[0].plot(com20,[x[5] for x in T_tam20],**line_parm[5])\n",
    "axs4[0].plot(com20,[x[6] for x in T_tam20],**line_parm[6])\n",
    "axs4[0].plot(com20,[x[7] for x in T_tam20],**line_parm[7])\n",
    "axs4[0].legend(handles=mod,fontsize=15)\n",
    "axs4[0].grid(True)\n",
    "axs4[1].set_xticklabels(com20,rotation=90,fontsize=20)\n",
    "axs4[1].tick_params(axis='y', labelsize=15)\n",
    "axs4[1].set_xlabel('[V E]',fontsize=15)\n",
    "axs4[1].set_xlim(-x_offset,len(com20)-1+x_offset)\n",
    "axs4[1].set_ylabel('GAP [%]',fontsize=15)\n",
    "axs4[1].set_ylim(-5,105)\n",
    "axs4[1].plot(com20,[x[0] for x in G_tam20],**line_parm[0])\n",
    "axs4[1].plot(com20,[x[1] for x in G_tam20],**line_parm[1])\n",
    "axs4[1].plot(com20,[x[2] for x in G_tam20],**line_parm[2])\n",
    "axs4[1].plot(com20,[x[3] for x in G_tam20],**line_parm[3])\n",
    "axs4[1].plot(com20,[x[4] for x in G_tam20],**line_parm[4])\n",
    "axs4[1].plot(com20,[x[5] for x in G_tam20],**line_parm[5])\n",
    "axs4[1].plot(com20,[x[6] for x in G_tam20],**line_parm[6])\n",
    "axs4[1].plot(com20,[x[7] for x in G_tam20],**line_parm[7])\n",
    "axs4[1].legend(handles=mod,fontsize=15)\n",
    "axs4[1].grid(True)\n",
    "fig4.savefig('F1_tam20.jpg',bbox_inches='tight',dpi=300)\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}