WIP. The analyser is a huge monster to be converted into a python code...

Analysis/analyser.ipynb

@@ -24,12 +24,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
-    "matrixMalEX=\"data_GG.csv\"\n",
-    "matrixMal=\"data_GM.csv\"\n",
+    "matrixMalEX=\"dataG.csv\"\n",
+    "matrixMal=\"dataM.csv\"\n",
     "matrixIt=\"data_L.csv\"\n",
     "matrixIt_Total=\"data_L_Total.csv\"\n",
     "n_qty=6 #CAMBIAR SEGUN LA CANTIDAD DE NODOS USADOS\n",
@@ -3374,7 +3374,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -3388,7 +3388,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.4"
+   "version": "3.9.7"
   }
  },
  "nbformat": 4,
 %% Cell type:code id: tags:
 ``` python
 %matplotlib inline
 import pandas as pd
 from pandas import DataFrame, Series
 import numpy as np
 import math
 import seaborn as sns
 import matplotlib.pyplot as plt
 import matplotlib.patches as mpatches
 import matplotlib.colors as colors
 from matplotlib.legend_handler import HandlerLine2D, HandlerTuple
 from matplotlib.colors import LinearSegmentedColormap
 from scipy import stats
 import scikit_posthocs as sp
 import sys
 ```
 %% Cell type:code id: tags:
 ``` python
-matrixMalEX="data_GG.csv"
-matrixMal="data_GM.csv"
+matrixMalEX="dataG.csv"
+matrixMal="dataM.csv"
 matrixIt="data_L.csv"
 matrixIt_Total="data_L_Total.csv"
 n_qty=6 #CAMBIAR SEGUN LA CANTIDAD DE NODOS USADOS
 n_groups= 2
 repet = 10 #CAMBIAR EL NUMERO SEGUN NUMERO DE EJECUCIONES POR CONFIG
 time_constant = False # Cambiar segun el speedUp usado
 speedup = 0.66 # Porcentaje del speedup ideal
 p_value = 0.05
 values = [2, 10, 20, 40]
 #                      WORST          BEST
 dist_names = ['null', 'BalancedFit', 'CompactFit']
 processes = [1,10,20,40,80,120]
 labelsP = [['(2,2)', '(2,10)', '(2,20)', '(2,40)'],['(10,2)', '(10,10)', '(10,20)', '(10,40)'],
           ['(20,2)', '(20,10)', '(20,20)', '(20,40)'],['(40,2)', '(40,10)', '(40,20)', '(40,40)']]
 labelsP_J = ['(2,2)', '(2,10)', '(2,20)', '(2,40)','(10,2)', '(10,10)', '(10,20)', '(10,40)',
               '(20,2)', '(20,10)', '(20,20)', '(20,40)','(40,2)', '(40,10)', '(40,20)', '(40,40)']
 positions = [321, 322, 323, 324, 325]
 positions_small = [221, 222, 223, 224]
 labels = ['(1,10)', '(1,20)', '(1,40)','(1,80)','(1,120)',
             '(10,1)', '(10,20)', '(10,40)','(10,80)','(10,120)',
             '(20,1)',  '(20,10)','(20,40)','(20,80)','(20,120)',
             '(40,1)',  '(40,10)',  '(40,20)','(40,80)','(40,120)',
             '(80,1)',  '(80,10)',  '(80,20)', '(80,40)','(80,120)',
             '(120,1)', '(120,10)', '(120,20)','(120,40)','(120,80)']
 labelsExpand = ['(1,10)', '(1,20)', '(1,40)','(1,80)','(1,120)',
                '(10,20)', '(10,40)','(10,80)','(10,120)',
                '(20,40)','(20,80)','(20,120)',
                '(40,80)','(40,120)',
                '(80,120)']
 labelsShrink = ['(10,1)',
                '(20,1)',  '(20,10)',
                '(40,1)',  '(40,10)',  '(40,20)',
                '(80,1)',  '(80,10)',  '(80,20)', '(80,40)',
                '(120,1)', '(120,10)', '(120,20)','(120,40)','(120,80)']
 labelsExpandOrdered = ['(1,10)', '(1,20)', '(10,20)',
                        '(1,40)','(10,40)','(20,40)',
                        '(1,80)','(10,80)','(20,80)','(40,80)',
                        '(1,120)', '(10,120)', '(20,120)','(40,120)','(80,120)']
 labelsShrinkOrdered = ['(10,1)', '(20,1)', '(40,1)', '(80,1)', '(120,1)',
                 '(20,10)',  '(40,10)',  '(80,10)',  '(120,10)',
                 '(40,20)', '(80,20)', '(120,20)',
                 '(80,40)','(120,40)',
                 '(120,80)']
 labelsExpandIntra = ['(1,10)', '(1,20)','(10,20)']
 labelsShrinkIntra = ['(10,1)', '(20,1)', '(20,10)']
 labelsExpandInter = ['(1,40)','(1,80)', '(1,160)',
                '(10,40)','(10,80)', '(10,160)',
                '(20,40)','(20,80)', '(20,160)',
                '(40,80)', '(40,160)',
                '(80,160)']
 labelsShrinkInter = ['(40,1)', '(40,10)', '(40,20)',
                '(80,1)', '(80,10)', '(80,20)','(80,40)',
                '(160,1)', '(160,10)', '(160,20)','(160,40)', '(160,80)']
                 #0          #1                 #2                     #3
 labelsMethods = ['Baseline', 'Baseline single','Baseline - Asynchronous','Baseline single - Asynchronous',
                  'Merge','Merge single','Merge - Asynchronous','Merge single - Asynchronous']
                  #4      #5             #6                 #7
 colors_spawn = ['green','springgreen','blue','darkblue','red','darkred','darkgoldenrod','olive','violet']
 linestyle_spawn = ['-', '--', '-.', ':']
 markers_spawn = ['.','v','s','p', 'h','d','X','P','^']
 OrMult_patch = mpatches.Patch(hatch='', facecolor='green', label='Baseline')
 OrSing_patch = mpatches.Patch(hatch='', facecolor='springgreen', label='Baseline single')
 OrPthMult_patch = mpatches.Patch(hatch='//', facecolor='blue', label='Baseline - Asyncrhonous')
 OrPthSing_patch = mpatches.Patch(hatch='\\', facecolor='darkblue', label='Baseline single - Asyncrhonous')
 MergeMult_patch = mpatches.Patch(hatch='||', facecolor='red', label='Merge')
 MergeSing_patch = mpatches.Patch(hatch='...', facecolor='darkred', label='Merge single')
 MergePthMult_patch = mpatches.Patch(hatch='xx', facecolor='yellow', label='Merge - Asyncrhonous')
 MergePthSing_patch = mpatches.Patch(hatch='++', facecolor='olive', label='Merge single - Asyncrhonous')
 handles_spawn = [OrMult_patch,OrSing_patch,OrPthMult_patch,OrPthSing_patch,MergeMult_patch,MergeSing_patch,MergePthMult_patch,MergePthSing_patch]
 ```
 %% Cell type:code id: tags:
 ``` python
 dfG = pd.read_csv( matrixMalEX )
 dfG = dfG.drop(columns=dfG.columns[0])
 dfG['S'] = dfG['N']
 dfG['N'] = dfG['S'] + dfG['%Async']
 dfG['%Async'] = (dfG['%Async'] / dfG['N']) * 100
 dfG['%Async'] = dfG['%Async'].fillna(0)
 if(n_qty == 1):
     group = dfG.groupby(['%Async', 'Cst', 'Css', 'Groups'])['TE']
     group2 = dfG.groupby(['%Async', 'Cst', 'Css', 'NP','NS'])['TE']
 else:
     group = dfG.groupby(['Dist', '%Async', 'Cst', 'Css', 'Groups'])['TE']
     group2 = dfG.groupby(['Dist', '%Async', 'Cst', 'Css', 'NP','NS'])['TE']
 grouped_aggG = group.agg(['median'])
 grouped_aggG.rename(columns={'median':'TE'}, inplace=True)
 grouped_aggG2 = group2.agg(['median'])
 grouped_aggG2.rename(columns={'median':'TE'}, inplace=True)
 ```
 %% Cell type:code id: tags:
 ``` python
 dfM = pd.read_csv( matrixMal )
 dfM = dfM.drop(columns=dfM.columns[0])
 dfM['S'] = dfM['N']
 dfM['N'] = dfM['S'] + dfM['%Async']
 dfM["TR"] = dfM["TC"] + dfM["TH"] + dfM["TS"] + dfM["TA"]
 dfM['%Async'] = (dfM['%Async'] / dfM['N']) * 100
 dfM['%Async'] = dfM['%Async'].fillna(0)
 dfM['alpha'] = 1
 #dfM = dfM.drop(dfM.loc[(dfM["Cst"] == 3) & (dfM["Css"] == 1) & (dfM["NP"] > dfM["NS"])].index)
 #dfM = dfM.drop(dfM.loc[(dfM["Cst"] == 2) & (dfM["Css"] == 1) & (dfM["NP"] > dfM["NS"])].index)
 if(n_qty == 1):
     groupM = dfM.groupby(['%Async', 'Cst', 'Css', 'NP', 'NS'])['TC', 'TH', 'TS', 'TA', 'TR', 'alpha']
 else:
     groupM = dfM.groupby(['Dist', '%Async', 'Cst', 'Css', 'NP', 'NS'])['TC', 'TH', 'TS', 'TA', 'TR', 'alpha']
 #group
 grouped_aggM = groupM.agg(['median'])
 grouped_aggM.columns = grouped_aggM.columns.get_level_values(0)
 for cst_aux in [1,3]:
     for css_aux in [0,1]:
         for np_aux in processes:
             for ns_aux in processes:
                 if np_aux != ns_aux:
                     grouped_aggM.loc[('2,2',0, cst_aux, css_aux, np_aux,ns_aux)]['alpha'] = \
                         grouped_aggM.loc[('2,2',0, cst_aux, css_aux, np_aux,ns_aux)]['TC'] / \
                         grouped_aggM.loc[('2,2',0, cst_aux-1, css_aux, np_aux,ns_aux)]['TC']
 ```
 %%%% Output: stream
     /tmp/ipykernel_2692/2056908859.py:18: FutureWarning: Indexing with multiple keys (implicitly converted to a tuple of keys) will be deprecated, use a list instead.
       groupM = dfM.groupby(['Dist', '%Async', 'Cst', 'Css', 'NP', 'NS'])['TC', 'TH', 'TS', 'TA', 'TR', 'alpha']
 %% Cell type:code id: tags:
 ``` python
 dfL = pd.read_csv( matrixIt )
 dfL = dfL.drop(columns=dfL.columns[0])
 dfL['%Async'] = dfL['%Async'].fillna(0)
 dfL['omega'] = 1
 #dfL = dfL.drop(dfL.loc[(dfL["Cst"] == 3) & (dfL["Css"] == 1) & (dfL["NP"] > dfL["NS"])].index)
 #dfL = dfL.drop(dfL.loc[(dfL["Cst"] == 2) & (dfL["Css"] == 1) & (dfL["NP"] > dfL["NS"])].index)
 if(n_qty == 1):
     groupL = dfL[dfL['NS'] != 0].groupby(['Tt', '%Async', 'Cst', 'Css', 'NP', 'NS'])['Ti', 'To', 'omega']
 else:
     groupL = dfL[dfL['NS'] != 0].groupby(['Tt', 'Dist', '%Async', 'Cst', 'Css', 'NP', 'NS'])['Ti', 'To', 'omega']
 #group
 grouped_aggL = groupL.agg(['median', 'count'])
 grouped_aggL.columns = grouped_aggL.columns.get_level_values(0)
 grouped_aggL.set_axis(['Ti', 'Iters', 'To', 'Iters2', 'omega', 'omega2'], axis='columns', inplace=True)
 grouped_aggL['Iters'] = np.round(grouped_aggL['Iters']/repet)
 grouped_aggL['Iters2'] = np.round(grouped_aggL['Iters2']/repet)
 for cst_aux in [1,3]:
     for css_aux in [0,1]:
         for np_aux in processes:
             for ns_aux in processes:
                 if np_aux != ns_aux:
                     grouped_aggL.loc[(1,2,0, cst_aux, css_aux, np_aux,ns_aux), 'omega'] = \
                         grouped_aggL.loc[(1,2,0, cst_aux, css_aux, np_aux,ns_aux)]['Ti'] / \
                         grouped_aggL.loc[(0,2,0, cst_aux, css_aux, np_aux,ns_aux)]['Ti']
 ```
 %%%% Output: stream
     /tmp/ipykernel_2692/1294489315.py:13: FutureWarning: Indexing with multiple keys (implicitly converted to a tuple of keys) will be deprecated, use a list instead.
       groupL = dfL[dfL['NS'] != 0].groupby(['Tt', 'Dist', '%Async', 'Cst', 'Css', 'NP', 'NS'])['Ti', 'To', 'omega']
 %% Cell type:code id: tags:
 ``` python
 dfLT = pd.read_csv( matrixIt_Total )
 dfLT = dfLT.drop(columns=dfLT.columns[0])
 dfLT['%Async'] = dfLT['%Async'].fillna(0)
 dfLT['ItA']= dfLT.Ti.apply(lambda x: list(x.replace('(','').replace(')','').split(',')))
 dfLT['TiA']= dfLT.ItA.apply(lambda x: np.median(list(map(float,[y for y in x if y]))) )
 dfLT['TiA']= dfLT['TiA'].fillna(0)
 dfLT['ItA']= dfLT.ItA.apply(lambda x: len([y for y in x if y]))
 #dfL = dfL.drop(dfL.loc[(dfL["Cst"] == 3) & (dfL["Css"] == 1) & (dfL["NP"] > dfL["NS"])].index)
 #dfL = dfL.drop(dfL.loc[(dfL["Cst"] == 2) & (dfL["Css"] == 1) & (dfL["NP"] > dfL["NS"])].index)
 if(n_qty == 1):
     groupLT = dfLT[dfLT['NS'] != 0].groupby(['%Async', 'Cst', 'Css', 'NP', 'NS'])['Sum', 'ItA']
 else:
     groupLT = dfLT[dfLT['NS'] != 0].groupby(['Dist', '%Async', 'Cst', 'Css', 'NP', 'NS'])['Sum', 'ItA']
 #group
 grouped_aggLT = groupLT.agg(['median'])
 grouped_aggLT.columns = grouped_aggLT.columns.get_level_values(0)
 grouped_aggLT.set_axis(['Sum','ItA'], axis='columns', inplace=True)
 ```
 %%%% Output: stream
     /home/usuario/miniconda3/lib/python3.9/site-packages/numpy/core/fromnumeric.py:3419: RuntimeWarning: Mean of empty slice.
       return _methods._mean(a, axis=axis, dtype=dtype,
     /tmp/ipykernel_2692/3028104048.py:17: FutureWarning: Indexing with multiple keys (implicitly converted to a tuple of keys) will be deprecated, use a list instead.
       groupLT = dfLT[dfLT['NS'] != 0].groupby(['Dist', '%Async', 'Cst', 'Css', 'NP', 'NS'])['Sum', 'ItA']
 %% Cell type:code id: tags:
 ``` python
 tc_list = []
 alpha_list = []
 omega_list = []
 ita_list = []
 dfLT['index'] = dfLT.index
 dfM['index'] = dfM.index
 for cst_aux in [0,1,2,3]:
     for css_aux in [0,1]:
         for np_aux in processes:
             for ns_aux in processes:
                 if np_aux != ns_aux:
                     dfLT_aux = dfLT[dfLT["NP"] == np_aux][dfLT["NS"] == ns_aux][dfLT["Cst"] == cst_aux][dfLT["Css"] == css_aux]
                     dfM_aux = dfM[dfM["NP"] == np_aux][dfM["NS"] == ns_aux][dfM["Css"] == css_aux]
                     if cst_aux == 1 or cst_aux == 3:
                         dfM_aux2= dfM_aux[dfM_aux["Cst"] == cst_aux-1]
                         dfM_aux2= dfM_aux2.sort_values(by=['TH'])
                     dfM_aux = dfM_aux[dfM_aux["Cst"] == cst_aux]
                     dfM_aux= dfM_aux.sort_values(by=['TH'])
                     index1_aux = dfM_aux.iloc[4]["index"]
                     index2_aux = dfM_aux.iloc[5]["index"]
                     # Comprobar que es un metodo asincrono
                     if cst_aux == 1 or cst_aux == 3:
                         value_aux1 = dfM_aux[dfM_aux["index"] == index1_aux]['TC'].values
                         value_aux2 = dfM_aux[dfM_aux["index"] == index2_aux]['TC'].values
                         valueS_aux1 = dfM_aux2.iloc[4]['TC']
                         valueS_aux2 = dfM_aux2.iloc[5]['TC']
                         value1_aux = (value_aux1 + value_aux2) / 2
                         value2_aux = (value_aux1/valueS_aux1 + value_aux2/valueS_aux2) / 2
                     else:
                         value1_aux = dfM_aux['TC'].median()
                         value2_aux = 1
                     tc_list.append(float(value1_aux))
                     alpha_list.append(float(value2_aux))
                     value_aux1 = dfLT_aux[dfLT_aux["index"] == index1_aux]['ItA'].values
                     value_aux2 = dfLT_aux[dfLT_aux["index"] == index2_aux]['ItA'].values
                     value3_aux = (value_aux1 + value_aux2) / 2
                     ita_list.append(int(value3_aux))
                     if cst_aux == 1 or cst_aux == 3:
                         iter_time_aux1 = dfLT_aux[dfLT_aux["index"] == index1_aux]['Time'].values
                         iter_time_aux2 = dfLT_aux[dfLT_aux["index"] == index2_aux]['Time'].values
                         if not time_constant:
                             iter_time_aux1 = (iter_time_aux1 / np_aux) / speedup
                             iter_time_aux2 = (iter_time_aux2 / np_aux) / speedup
                         iter_Atime_aux1 = dfLT_aux[dfLT_aux["index"] == index1_aux]['TiA'].values
                         iter_Atime_aux2 = dfLT_aux[dfLT_aux["index"] == index2_aux]['TiA'].values
                         value4_aux = (iter_Atime_aux1/iter_time_aux1 + iter_Atime_aux1/iter_time_aux2) / 2
                     else:
                         value4_aux = 1
                     omega_list.append(float(value4_aux))
 grouped_aggM['TC_A'] = tc_list
 grouped_aggM['ItA'] = ita_list
 grouped_aggM['Alpha_A'] = alpha_list
 grouped_aggM['Omega_A'] = omega_list
 ```
 %%%% Output: stream
     /tmp/ipykernel_2692/863462943.py:12: UserWarning: Boolean Series key will be reindexed to match DataFrame index.
       dfLT_aux = dfLT[dfLT["NP"] == np_aux][dfLT["NS"] == ns_aux][dfLT["Cst"] == cst_aux][dfLT["Css"] == css_aux]
     /tmp/ipykernel_2692/863462943.py:13: UserWarning: Boolean Series key will be reindexed to match DataFrame index.
       dfM_aux = dfM[dfM["NP"] == np_aux][dfM["NS"] == ns_aux][dfM["Css"] == css_aux]
 %% Cell type:code id: tags:
 ``` python
 coherent_check_df = grouped_aggL.copy()
 # Añadir suma total de iteraciones
 coherent_check_df['Sum'] = 0
 coherent_check_df.loc[(1,slice(None)),'Sum'] = grouped_aggLT[(grouped_aggLT['Sum'] != 0)].loc[(slice(None)),'Sum'].values
 coherent_check_df = coherent_check_df[(coherent_check_df['Sum'] != 0)]
 # Añadir tiempos TE y TC
 coherent_check_df['TE'] = 0
 coherent_check_df['TEA'] = 0
 coherent_check_df['TR'] = 0
 coherent_check_df['TRA'] = 0
 for cst_aux in [1,3]:
     coherent_check_df.loc[(1,2,0,cst_aux,slice(None)),'TE'] = grouped_aggG2.loc[('2,2',0,cst_aux-1,slice(None)),'TE'].values
     coherent_check_df.loc[(1,2,0,cst_aux,slice(None)),'TR'] = grouped_aggM.loc[('2,2',0,cst_aux-1,slice(None)),'TC'].values
     coherent_check_df.loc[(1,2,0,cst_aux,slice(None)),'TEA'] = grouped_aggG2.loc[('2,2',0,cst_aux,slice(None)),'TE'].values
     coherent_check_df.loc[(1,2,0,cst_aux,slice(None)),'TRA'] = grouped_aggM.loc[('2,2',0,cst_aux,slice(None)),'TC'].values
 # Calcular tiempos teoricos
 #coherent_check_df['Teorico-S'] = coherent_check_df['Ti'] * 3 + coherent_check_df['TR'] +  TIEMPOITERNS * 97
 #coherent_check_df['Rel-S'] = np.round(coherent_check_df['Teorico-S'] / coherent_check_df['TE'],2)
 #coherent_check_df['Teorico-A'] = coherent_check_df['Ti'] * 3 + coherent_check_df['Sum'] +  TIEMPOITERNS * (97 - coherent_check_df['Iters'])
 #coherent_check_df['Rel-A'] = np.round(coherent_check_df['Teorico-A'] / coherent_check_df['TEA'],2)
 coherent_check_df=coherent_check_df.droplevel('Tt').droplevel('%Async').droplevel('Dist')
 for cst_aux in [1,3]:
     for css_aux in [0,1]:
         aux_df = coherent_check_df.loc[(cst_aux, css_aux, slice(None))]
         aux_df.to_excel("coherent"+str(cst_aux)+"_"+str(css_aux)+".xlsx")
 ```
 %% Cell type:code id: tags:
 ``` python
 grouped_aggL.to_excel("resultL.xlsx")
 grouped_aggLT.to_excel("resultLT.xlsx")
 dfLT.to_excel("resultLT_all.xlsx")
 grouped_aggM.to_excel("resultM.xlsx")
 grouped_aggG2.to_excel("resultG.xlsx")
 ```
 %% Cell type:code id: tags:
 ``` python
 dfG
 dfM
 dfL
 dfLT
 grouped_aggG
 grouped_aggM
 grouped_aggL
 grouped_aggLT
 ```
 %%%% Output: execute_result
                                       Sum  ItA
     Dist %Async Cst Css NP  NS
     2    0.0    0   0   1   10   0.000000  0.0
                             20   0.000000  0.0
                             40   0.000000  0.0
                             80   0.000000  0.0
                             120  0.000000  0.0
     ...                               ...  ...
                 3   1   120 1    0.216691  3.0
                             10   0.271795  3.5
                             20   0.295311  3.5
                             40   0.204900  3.0
                             80   0.226526  3.0
     
     [240 rows x 2 columns]
 %% Cell type:code id: tags:
 ``` python
 dfLT
 ```
 %%%% Output: execute_result
           N  %Async   NP  N_par  NS  Dist  Compute_tam  Comm_tam  Cst  Css  Time  \
     0     0     0.0   40      0  10     2       100000         0    3    0   4.0
     1     0     0.0   40      0  10     2       100000         0    3    0   4.0
     2     0     0.0   40      0  10     2       100000         0    3    0   4.0
     3     0     0.0   40      0  10     2       100000         0    3    0   4.0
     4     0     0.0   40      0  10     2       100000         0    3    0   4.0
     ...  ..     ...  ...    ...  ..   ...          ...       ...  ...  ...   ...
     2395  0     0.0  120      0  10     2       100000         0    3    0   4.0
     2396  0     0.0  120      0  10     2       100000         0    3    0   4.0
     2397  0     0.0  120      0  10     2       100000         0    3    0   4.0
     2398  0     0.0  120      0  10     2       100000         0    3    0   4.0
     2399  0     0.0  120      0  10     2       100000         0    3    0   4.0
     
           Iters                                                 Ti       Sum  ItA  \
     0         3                               (0.225269, 0.102594)  0.327863    2
     1         3                               (0.197712, 0.111945)  0.309657    2
     2         3                                        (0.172556,)  0.172556    1
     3         3                               (0.208798, 0.101674)  0.310472    2
     4         3                               (0.169751, 0.099995)  0.269746    2
     ...     ...                                                ...       ...  ...
     2395      3           (0.061279, 0.086562, 0.102954, 0.064273)  0.315068    4
     2396      3           (0.065522, 0.090022, 0.089555, 0.069523)  0.314622    4
     2397      3  (0.065145, 0.10315, 0.110737, 0.085012, 0.093,...  1.037177   11
     2398      3  (0.069027, 0.098036, 0.125989, 0.112365, 0.109...  0.998392   10
     2399      3                     (0.065019, 0.091227, 0.065016)  0.221262    3
     
                TiA
     0     0.163932
     1     0.154829
     2     0.172556
     3     0.155236
     4     0.134873
     ...        ...
     2395  0.075417
     2396  0.079539
     2397  0.098615
     2398  0.103513
     2399  0.065019
     
     [2400 rows x 16 columns]
 %% Cell type:code id: tags:
 ``` python
 grouped_aggM.loc[('2,2',0,2,0)]
 ```
 %%%% Output: execute_result
                    TC   TH   TS   TA        TR  alpha      TC_A  ItA  Alpha_A  \
     NP  NS
     1   10   0.283736  0.0  0.0  0.0  0.283736    1.0  0.283736    0      1.0
         20   0.716209  0.0  0.0  0.0  0.716209    1.0  0.716209    0      1.0
         40   0.798951  0.0  0.0  0.0  0.798951    1.0  0.798951    0      1.0
         80   0.931771  0.0  0.0  0.0  0.931771    1.0  0.931771    0      1.0
         120  0.992033  0.0  0.0  0.0  0.992033    1.0  0.992033    0      1.0
     10  1    0.000982  0.0  0.0  0.0  0.000982    1.0  0.000982    0      1.0
         20   0.477040  0.0  0.0  0.0  0.477040    1.0  0.477040    0      1.0
         40   0.766185  0.0  0.0  0.0  0.766185    1.0  0.766185    0      1.0
         80   0.860920  0.0  0.0  0.0  0.860920    1.0  0.860920    0      1.0
         120  0.890894  0.0  0.0  0.0  0.890894    1.0  0.890894    0      1.0
     20  1    0.001005  0.0  0.0  0.0  0.001005    1.0  0.001005    0      1.0
         10   0.001025  0.0  0.0  0.0  0.001025    1.0  0.001025    0      1.0
         40   0.790193  0.0  0.0  0.0  0.790193    1.0  0.790193    0      1.0
         80   0.864170  0.0  0.0  0.0  0.864170    1.0  0.864170    0      1.0
         120  1.088929  0.0  0.0  0.0  1.088929    1.0  1.088929    0      1.0
     40  1    0.029802  0.0  0.0  0.0  0.029802    1.0  0.029802    0      1.0
         10   0.024519  0.0  0.0  0.0  0.024519    1.0  0.024519    0      1.0
         20   0.116366  0.0  0.0  0.0  0.116366    1.0  0.116366    0      1.0
         80   0.893692  0.0  0.0  0.0  0.893692    1.0  0.893692    0      1.0
         120  0.922904  0.0  0.0  0.0  0.922904    1.0  0.922904    0      1.0
     80  1    0.217198  0.0  0.0  0.0  0.217198    1.0  0.217198    0      1.0
         10   0.180846  0.0  0.0  0.0  0.180846    1.0  0.180846    0      1.0
         20   0.149038  0.0  0.0  0.0  0.149038    1.0  0.149038    0      1.0
         40   0.148336  0.0  0.0  0.0  0.148336    1.0  0.148336    0      1.0
         120  0.905912  0.0  0.0  0.0  0.905912    1.0  0.905912    0      1.0
     120 1    0.231024  0.0  0.0  0.0  0.231024    1.0  0.231024    0      1.0
         10   0.148412  0.0  0.0  0.0  0.148412    1.0  0.148412    0      1.0
         20   0.177781  0.0  0.0  0.0  0.177781    1.0  0.177781    0      1.0
         40   0.350567  0.0  0.0  0.0  0.350567    1.0  0.350567    0      1.0
         80   0.156000  0.0  0.0  0.0  0.156000    1.0  0.156000    0      1.0
     
              Omega_A
     NP  NS
     1   10       1.0
         20       1.0
         40       1.0
         80       1.0
         120      1.0
     10  1        1.0
         20       1.0
         40       1.0
         80       1.0
         120      1.0
     20  1        1.0
         10       1.0
         40       1.0
         80       1.0
         120      1.0
     40  1        1.0
         10       1.0
         20       1.0
         80       1.0
         120      1.0
     80  1        1.0
         10       1.0
         20       1.0
         40       1.0
         120      1.0
     120 1        1.0
         10       1.0
         20       1.0
         40       1.0
         80       1.0
 %% Cell type:code id: tags:
 ``` python
 grouped_aggL
 ```
 %%%% Output: execute_result
                                            Ti  Iters      To  Iters2     alpha  \
     Tt  Dist %Async Cst Css NP  NS
     0.0 2    0.0    0   0   1   10   3.999165    3.0  4485.0     3.0  1.000000
                                 20   3.999194    3.0  4485.0     3.0  1.000000
                                 40   3.999186    3.0  4485.0     3.0  1.000000
                                 80   3.999236    3.0  4485.0     3.0  1.000000
                                 120  3.999194    3.0  4485.0     3.0  1.000000
     ...                                   ...    ...     ...     ...       ...
     1.0 2    0.0    3   1   120 1    0.070046    3.0    37.0     3.0  2.108073
                                 10   0.075896    4.0    37.0     4.0  2.292376
                                 20   0.090617    5.0    37.0     5.0  2.733503
                                 40   0.069103    4.0    37.0     4.0  2.089061
                                 80   0.068959    4.0    37.0     4.0  2.083952
     
                                      alpha2
     Tt  Dist %Async Cst Css NP  NS
     0.0 2    0.0    0   0   1   10       30
                                 20       30
                                 40       30
                                 80       30
                                 120      30
     ...                                 ...
     1.0 2    0.0    3   1   120 1        30
                                 10       40
                                 20       54
                                 40       37
                                 80       39
     
     [360 rows x 6 columns]
 %% Cell type:code id: tags:
 ``` python
 auxIter = pd.DataFrame(dfM['Iters'].str.split(',',1).tolist(),columns = ['Iters0','Iters1'])
 auxIter['Iters1'] = pd.to_numeric(auxIter['Iters1'], errors='coerce')
 iters = auxIter['Iters1'].mean()
 print(iters)
 ```
 %%%% Output: stream
     97.0
 %% Cell type:markdown id: tags:
 A partir de aquí se muestran gráficos
 %% Cell type:code id: tags:
 ``` python
 #Reserva de memoria para las estructuras
 TP_data=[0]*2
 TH_data=[0]*2
 TM_data=[0]*2
 TP_A_data=[0]*2
 TH_A_data=[0]*2
 TM_A_data=[0]*2
 for dist in [1,2]:
     dist_index=dist-1
     TP_data[dist_index]=[0]*len(values)*(len(values))
     TH_data[dist_index]=[0]*len(values)*(len(values))
     TM_data[dist_index]=[0]*len(values)*(len(values))
     TP_A_data[dist_index]=[0]*len(values)*(len(values))
     TH_A_data[dist_index]=[0]*len(values)*(len(values))
     TM_A_data[dist_index]=[0]*len(values)*(len(values))
 # Obtencion de los grupos del dataframe necesarios
 #ACTUALMENTE NO SE DIFERENCIAN LOS TIEMPOS DE ITERACIONES DE PADRES E HIJOS CUANDO COINCIDE EL NUMERO DE PROCESOS
 if(n_qty == 1):
     groupM_aux = dfM.groupby(['NP', 'NS'])['TC']
     groupL_aux = dfL[dfL['Tt'] == 0].groupby(['NP'])['Ti']
 else:
     groupM_aux = dfM.groupby(['NP', 'NS', 'Dist'])['TC']
     groupL_aux = dfL[dfL['Tt'] == 0].groupby(['Dist', 'NP'])['Ti']
 grouped_aggM_aux = groupM_aux.agg(['mean'])
 grouped_aggM_aux.columns = grouped_aggM_aux.columns.get_level_values(0)
 grouped_aggL_aux = groupL_aux.agg(['mean'])
 grouped_aggL_aux.columns = grouped_aggL_aux.columns.get_level_values(0)
 grouped_aggL_aux.set_axis(['Ti'], axis='columns')
 #Calculo de los valores para las figuras
 #1=Best Fit
 #2=Worst Fit
 dist=1
 for dist in [1,2]:
     dist_index=dist-1
     dist_v = str(dist)+","+str(dist)
     i=0
     r=0
     for numP in values:
         j=0
         for numC in values:
             tc_real = grouped_aggM_aux.loc[(numP,numC,dist_v)]['mean']
             for tipo in [0]: #TODO Poner a 0,100
                 iters_aux=dfM[(dfM["NP"] == numP)][(dfM["NS"] == numC)][(dfM["Dist"] == dist_v)][(dfM["%Async"] == tipo)]['Iters'].head(1).tolist()[0].split(',')
                 itersP_aux = int(iters_aux[0])
                 itersS_aux = int(iters_aux[1])
                 iters_mal_aux = 0
                 if tipo != 0:
                     iters_mal_aux = grouped_aggL['Iters'].loc[(1,dist,tipo,numP,numC)]
                 t_iterP_aux = grouped_aggL_aux['Ti'].loc[(dist,numP)]
                 t_iterS_aux = grouped_aggL_aux['Ti'].loc[(dist,numC)]
                 p1 = t_iterP_aux * itersP_aux
                 p2 = t_iterS_aux * max((itersS_aux - iters_mal_aux),0)
                 array_aux = grouped_aggM[['TS', 'TA']].loc[(dist_v,tipo,numP,numC)].tolist()
                 p3 = tc_real + array_aux[0] + array_aux[1]
                 #Guardar datos
                 if tipo == 0:
                     TP_data[dist_index][i*len(values) + j] = p1
                     TH_data[dist_index][i*len(values) + j] = p2
                     TM_data[dist_index][i*len(values) + j] = p3
                 else:
                     TP_A_data[dist_index][i*len(values) + j] = p1
                     TH_A_data[dist_index][i*len(values) + j] = p2
                     TM_A_data[dist_index][i*len(values) + j] = p3
             j+=1
         i+=1
 print(TP_data)
 print(TH_data)
 print(TM_data)
 ```
 %%%% Output: stream
     [[0.21241231578947362, 0.21241231578947362, 0.21241231578947362, 0.21241231578947362, 0.04632109565217393, 0.04632109565217393, 0.04632109565217393, 0.04632109565217393, 0.025296672413793103, 0.025296672413793103, 0.025296672413793103, 0.025296672413793103, 0.0355868547008547, 0.0355868547008547, 0.0355868547008547, 0.0355868547008547], [0.1981199732142857, 0.1981199732142857, 0.1981199732142857, 0.1981199732142857, 0.06233977876106192, 0.06233977876106192, 0.06233977876106192, 0.06233977876106192, 0.026912142857142853, 0.026912142857142853, 0.026912142857142853, 0.026912142857142853, 0.0343439649122807, 0.0343439649122807, 0.0343439649122807, 0.0343439649122807]]
     [[2.1241231578947364, 0.4632109565217393, 0.25296672413793103, 0.35586854700854703, 2.1241231578947364, 0.4632109565217393, 0.25296672413793103, 0.35586854700854703, 2.1241231578947364, 0.4632109565217393, 0.25296672413793103, 0.35586854700854703, 2.1241231578947364, 0.4632109565217393, 0.25296672413793103, 0.35586854700854703], [1.9811997321428572, 0.6233977876106191, 0.2691214285714285, 0.343439649122807, 1.9811997321428572, 0.6233977876106191, 0.2691214285714285, 0.343439649122807, 1.9811997321428572, 0.6233977876106191, 0.2691214285714285, 0.343439649122807, 1.9811997321428572, 0.6233977876106191, 0.2691214285714285, 0.343439649122807]]
     [[0.22657399999999997, 0.22961033333333333, 0.37444533333333335, 1.0861523333333334, 0.18071299999999998, 0.2686593333333333, 0.48245, 1.8810366666666667, 0.22639533333333337, 0.31453400000000004, 0.564293, 2.4626886666666667, 0.4612826666666667, 1.0638560000000001, 1.5319243333333334, 2.1236686666666666], [0.21594133333333332, 0.36930899999999994, 1.1269756666666668, 1.1670603333333334, 0.22462733333333332, 0.47068400000000005, 1.5951943333333334, 1.693723, 0.7059706666666666, 1.368441, 1.8698483333333336, 2.2059883333333334, 0.4813296666666667, 1.3010543333333333, 1.8387883333333335, 2.1851773333333333]]
 %%%% Output: stream
     /home/usuario/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:36: FutureWarning: set_axis currently defaults to operating inplace.
     This will change in a future version of pandas, use inplace=True to avoid this warning.
     /home/usuario/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:53: UserWarning: Boolean Series key will be reindexed to match DataFrame index.
 %% Cell type:code id: tags:
 ``` python
 #TP_A_data=[[0.1997793257575758, 0.1997793257575758, 0.1997793257575758, 0.1997793257575758, 0.040469166666666695, 0.040469166666666695, 0.040469166666666695, 0.040469166666666695, 0.019951386363636366, 0.019951386363636366, 0.019951386363636366, 0.019951386363636366, 0.010227022727272729, 0.010227022727272729, 0.010227022727272729, 0.010227022727272729], [0.20020575000000002, 0.20020575000000002, 0.20020575000000002, 0.20020575000000002, 0.039894712121212116, 0.039894712121212116, 0.039894712121212116, 0.039894712121212116, 0.020662818181818185, 0.020662818181818185, 0.020662818181818185, 0.020662818181818185, 0.010635333333333332, 0.010635333333333332, 0.010635333333333332, 0.010635333333333332]]
 #TH_A_data=[[1.9977932575757578, 0.40469166666666695, 0.19951386363636364, 0.10227022727272729, 1.9977932575757578, 0.40469166666666695, 0.19951386363636364, 0.10227022727272729, 1.9977932575757578, 0.40469166666666695, 0.19951386363636364, 0.10227022727272729, 1.9977932575757578, 0.40469166666666695, 0.19951386363636364, 0.10227022727272729], [2.0020575000000003, 0.39894712121212117, 0.20662818181818185, 0.10635333333333331, 2.0020575000000003, 0.39894712121212117, 0.20662818181818185, 0.10635333333333331, 2.0020575000000003, 0.39894712121212117, 0.20662818181818185, 0.10635333333333331, 2.0020575000000003, 0.39894712121212117, 0.20662818181818185, 0.10635333333333331]]
 #TM_A_data=[[0.2083043333333333, 0.2661843333333333, 0.41778833333333326, 0.9868953333333335, 0.242685, 0.3060793333333333, 0.4986676666666667, 1.2530743333333334, 0.305179, 0.373607, 0.7375183333333334, 1.5113886666666667, 0.501651, 0.8987069999999999, 1.138518666666667, 1.5091376666666665], [0.205789, 0.4116923333333334, 1.0607546666666667, 0.9947066666666666, 0.27494700000000005, 0.669121, 1.2705783333333334, 1.3951336666666665, 0.4765406666666667, 0.9758123333333333, 1.267633, 1.4479673333333334, 0.4905743333333333, 1.0088953333333333, 1.4447113333333332, 1.4516683333333333]]
 for dist in [1,2]:
     dist_index=dist-1
     f=plt.figure(figsize=(20, 12))
 #for numP in values:
     x = np.arange(len(labelsP_J))
     width = 0.35
     sumaTP_TM = np.add(TP_data[dist_index], TM_data[dist_index]).tolist()
     sumaTP_TM_A = np.add(TP_A_data[dist_index], TM_A_data[dist_index]).tolist()
     ax=f.add_subplot(111)
     ax.bar(x+width/2, TP_data[dist_index], width, color='blue')
     ax.bar(x+width/2, TM_data[dist_index], width, bottom=TP_data[dist_index],color='orange')
     ax.bar(x+width/2, TH_data[dist_index], width, bottom=sumaTP_TM, color='green')
     ax.bar(x-width/2, TP_A_data[dist_index], width, hatch="\\/...", color='blue')
     ax.bar(x-width/2, TM_A_data[dist_index], width, bottom=TP_A_data[dist_index], hatch="\\/...", color='orange')
     ax.bar(x-width/2, TH_A_data[dist_index], width, bottom=sumaTP_TM_A, hatch="\\/...", color='green')
     ax.set_ylabel("Time(s)", fontsize=20)
     ax.set_xlabel("NP, NC", fontsize=20)
     plt.xticks(x, labelsP_J, rotation=90)
     blue_Spatch = mpatches.Patch(color='blue', label='Parents PR')
     orange_Spatch = mpatches.Patch(color='orange', label='Resize PR')
     green_Spatch = mpatches.Patch(color='green', label='Children PR')
     blue_Apatch = mpatches.Patch(hatch='\\/...', facecolor='blue', label='Parents NR')
     orange_Apatch = mpatches.Patch(hatch='\\/...', facecolor='orange', label='Resize NR')
     green_Apatch = mpatches.Patch(hatch='\\/...', facecolor='green', label='Children NR')
     handles=[blue_Spatch,orange_Spatch,green_Spatch,blue_Apatch,orange_Apatch,green_Apatch]
     plt.legend(handles=handles, loc='upper left', fontsize=21,ncol=2)
     ax.axvline((3.5), color='black')
     ax.axvline((7.5), color='black')
     ax.axvline((11.5), color='black')
     ax.tick_params(axis='both', which='major', labelsize=24)
     ax.tick_params(axis='both', which='minor', labelsize=22)
     plt.ylim((0, 25.5))
     #ax.axvline(4)
     f.tight_layout()
     f.savefig("Images/EX_Partitions_"+dist_names[dist]+".png", format="png")
 ```
 %%%% Output: display_data
     [Hidden Image Output]
 %%%% Output: display_data
     [Hidden Image Output]
 %% Cell type:code id: tags:
 ``` python
 def get_types_iker(checked_type='tc', used_direction='e', node_type="All", normality='m'):
     if checked_type=='te':
         var_aux='TE'
         tipo_fig="TE"
         grouped_aux=grouped_aggG2
     elif checked_type=='tc':
         var_aux='TC'
         tipo_fig="Mall"
         grouped_aux=grouped_aggM
     if node_type=='Intra':
         grouped_aux=grouped_aux.query('NP < 21 and NS < 21')
     elif node_type=='Inter':
         grouped_aux=grouped_aux.query('NP > 21 or NS > 21')
     if used_direction=='s':
         grouped_aux=grouped_aux.query('NP > NS')
         if node_type=='Intra':
             used_labels=labelsShrinkIntra
         elif node_type=='Inter':
             used_labels=labelsShrinkInter
         elif node_type=='All':
             used_labels=labelsShrink
         name_fig="Shrink"
         if normality=='r':
             handles=[OrSing_patch,OrPthMult_patch,OrPthSing_patch,MergeMult_patch,MergePthMult_patch]
         else:
             handles=[OrMult_patch,OrSing_patch,OrPthMult_patch,OrPthSing_patch,MergeMult_patch,MergePthMult_patch]
     elif used_direction=='e':
         grouped_aux=grouped_aux.query('NP < NS')
         if node_type=='Intra':
             used_labels=labelsExpandIntra
         elif node_type=='Inter':
             used_labels=labelsExpandInter
         elif node_type=='All':
             used_labels=labelsExpand
         name_fig="Expand"
         if normality=='r':
             handles=[OrSing_patch,OrPthMult_patch,OrPthSing_patch,MergeMult_patch,MergeSing_patch,MergePthMult_patch,MergePthSing_patch]
         else:
             handles=[OrMult_patch,OrSing_patch,OrPthMult_patch,OrPthSing_patch,MergeMult_patch,MergeSing_patch,MergePthMult_patch,MergePthSing_patch]
     title=tipo_fig+"_Spawn_"+node_type+"_"+name_fig+"_"+normality
     return var_aux, grouped_aux, handles, used_labels, title
 ```
 %% Cell type:code id: tags:
 ``` python
 def obtain_arrays_iker(grouped_aux, var_aux, used_direction='e', normality='m'):
     vOrMult = list(grouped_aux.query('Cst == 0 and Css == 0')[var_aux])
     vOrSingle = list(grouped_aux.query('Cst == 0 and Css == 1')[var_aux])
     vMergeMult = list(grouped_aux.query('Cst == 2 and Css == 0')[var_aux])
     vOrPthMult = list(grouped_aux.query('Cst == 1 and Css == 0')[var_aux])
     vOrPthSingle = list(grouped_aux.query('Cst == 1 and Css == 1')[var_aux])
     vMergePthMult = list(grouped_aux.query('Cst == 3 and Css == 0')[var_aux])
     h_line = None
     if used_direction=='e':
         vMergeSingle = list(grouped_aux.query('Cst == 2 and Css == 1')[var_aux])
         vMergePthSingle = list(grouped_aux.query('Cst == 3 and Css == 1')[var_aux])
     else:
         #FIXME Que tenga en cuenta TH al realizar shrink merge
         vMergePthMult = list(grouped_aux.query('Cst == 3 and Css == 0')[var_aux])
         vMergeSingle = None
         vMergePthSingle = None
     title_y = "Total time(s)"
     if normality == 'r':
         vOrSingle = np.subtract(vOrMult, vOrSingle)
         vOrPthMult = np.subtract(vOrMult, vOrPthMult)
         vOrPthSingle = np.subtract(vOrMult, vOrPthSingle)
         vMergeMult = np.subtract(vOrMult, vMergeMult)
         vMergePthMult = np.subtract(vOrMult, vMergePthMult)
         if used_direction=='e':
             vMergeSingle = np.subtract(vOrMult, vMergeSingle)
             vMergePthSingle = np.subtract(vOrMult, vMergePthSingle)
         vOrMult = None
         h_line = 0
         title_y = "Saved time(s)"
     elif normality == 'n':
         vOrSingle = np.divide(vOrSingle, vOrMult)
         vOrPthMult = np.divide(vOrPthMult, vOrMult)
         vOrPthSingle = np.divide(vOrPthSingle, vOrMult)
         vMergeMult = np.divide(vMergeMult, vOrMult)
         vMergePthMult = np.divide(vMergePthMult, vOrMult)
         if used_direction=='e':
             vMergeSingle = np.divide(vMergeSingle, vOrMult)
             vMergePthSingle = np.divide(vMergePthSingle, vOrMult)
         vOrMult = np.divide(vOrMult, vOrMult)
         h_line = 1
         title_y = "Relation Config time / Baseline Time"
     data_array=[vOrMult,vOrSingle,vOrPthMult,vOrPthSingle,vMergeMult,vMergeSingle,vMergePthMult,vMergePthSingle]
     v_lines=[]
     value_aux = 0.4
     if used_direction == 'e':
         value_aux = 0.5
     for i in range(0, len(vOrSingle)-1):
         v_lines.append(value_aux + i)
     return data_array, title_y, v_lines, h_line
 ```
 %% Cell type:code id: tags:
 ``` python
 def legend_loc_iker(data_array, len_x, ylim_zero):
     max_value = np.nanmax([x for x in data_array if x is not None]) # Los valores None es necesario evitarlos
     min_value = np.nanmin([x for x in data_array if x is not None]) # Los valores None es necesario evitarlos
     if(ylim_zero):
         min_value = 0
     middle_value = (max_value + min_value) / 2
     offset = (max_value - min_value) * 0.1
     def array_check_loc(ini, end):
         up = True
         lower = True
         for i in range(ini, end):
             for j in range(len(data_array)):
                 if not (data_array[j] is None):
                     if data_array[j][i] > (middle_value + offset):
                         up = False
                     elif data_array[j][i] < (middle_value - offset):
                         lower = False
                     if not up and not lower:
                         break
             else:
                 continue # Only executed if inner loop did NOT break
             break # Only executed if inner loop did break
         return up,lower
     up_left, lower_left = array_check_loc(0, math.floor(len_x/2))
     up_right, lower_right = array_check_loc(0, math.floor(len_x/2))
     legend_loc = 'best'
     if up_left:
         legend_loc = 'upper left'
     elif up_right:
         legend_loc = 'upper right'
     elif lower_left:
         legend_loc = 'lower left'
     elif lower_right:
         lower_right = 'lower right'
     return legend_loc
 ```
 %% Cell type:code id: tags:
 ``` python
 def graphic_iker(data_array, title="None", title_y="None", title_x="None", handles=None, used_labels=None, v_lines=None, h_line=None, ylim_zero=True):
     f=plt.figure(figsize=(30, 12))
     ax=f.add_subplot(111)
     x = np.arange(len(used_labels))
     width = 0.45/4
     legend_loc = legend_loc_iker(data_array, len(used_labels), ylim_zero)
     if not (data_array[0] is None):
         ax.bar(x-width*3.5, data_array[0], width, color='green')
     ax.bar(x-width*2.5, data_array[1], width, hatch="", color='springgreen')
     ax.bar(x-width*1.5, data_array[2], width, hatch="//", color='blue')
     ax.bar(x-width*0.5, data_array[3], width, hatch="\\",color='darkblue')
     ax.bar(x+width*0.5, data_array[4], width, hatch="||", color='red')
     if not (data_array[5] is None):
         ax.bar(x+width*1.5, data_array[5], width, hatch="...", color='darkred')
         ax.bar(x+width*2.5, data_array[6], width, hatch="xx", color='yellow')
     else:
         ax.bar(x+width*1.5, data_array[6], width, hatch="xx", color='yellow')
     if not (data_array[7] is None):
         ax.bar(x+width*3.5, data_array[7], width, hatch="++",color='olive')
     ax.axhline((0), color='black', linestyle='dashed')
     ax.set_ylabel(title_y, fontsize=30)
     ax.set_xlabel(title_x, fontsize=28)
     plt.xticks(x, used_labels, rotation=90)
     plt.legend(handles=handles, loc=legend_loc, fontsize=26,ncol=2,framealpha=1)
     if not ylim_zero: # Modifica los limites del eje y. No es buena practica que no aparezca el 0
         max_value = np.nanmax([x for x in data_array if x is not None]) # Los valores None es necesario evitarlos
         max_value += max_value * 0.1
         min_value = np.nanmin([x for x in data_array if x is not None]) # Los valores None es necesario evitarlos
         min_value -= min_value * 0.1
         if min_value < 0.1:
             min_value = 0
         plt.ylim((min_value, max_value))
     for line in v_lines:
         ax.axvline((line), color='black')
     if h_line != None:
         ax.axhline((h_line), color='black')
     ax.tick_params(axis='both', which='major', labelsize=30)
     ax.tick_params(axis='both', which='minor', labelsize=28)
     f.tight_layout()
     f.savefig("Images/Spawn/"+title+".png", format="png")
 ```
 %% Cell type:code id: tags:
 ``` python
 checked_type='te' # Valores 'te' y 'tc'
 used_direction='e' # Valores 's' y 'e'
 node_type='All' # Valores 'Intra', 'Inter', 'All'
 normality='n'
 #Values 'n' (normalizar), 'l' (logaritmico), 'm' (sin modificaciones), 'r' (Comparar respecto al primero)
 ylim_zero = True
 var_aux, grouped_aux, handles, used_labels, title = get_types_iker(checked_type, used_direction, node_type, normality)
 array_aux, title_y, v_lines, h_line = obtain_arrays_iker(grouped_aux, var_aux, used_direction, normality)
 graphic_iker(array_aux, title, title_y, "(NP, NC)", handles, used_labels, v_lines, ylim_zero)
 ```
 %%%% Output: display_data
     [Hidden Image Output]
 %% Cell type:code id: tags:
 ``` python
 used_direction='s'
 if used_direction=='s':
     dfM_aux=dfM.query('NP > NS')
     dfG_aux=dfG.query('NP > NS')
     used_labels=labelsShrink
     name_fig="Shrink"
     handles=[OrSing_patch,OrPthMult_patch,OrPthSing_patch,MergeMult_patch,MergePthMult_patch]
 elif used_direction=='e':
     dfM_aux=dfM.query('NP < NS')
     dfG_aux=dfG.query('NP < NS')
     used_labels=labelsExpand
     name_fig="Expand"
     handles=[OrSing_patch,OrPthMult_patch,OrPthSing_patch,MergeMult_patch,MergeSing_patch,MergePthMult_patch,MergePthSing_patch]
 # < Expand
 # > Shrink
 vOrMult = list(dfG_aux.query('Cst == 0 and Css == 0')['TE'])
 vOrSingle = list(dfG_aux.query('Cst == 0 and Css == 1')['TE'])
 vOrPthMult = list(dfG_aux.query('Cst == 1 and Css == 0')['TE'])
 vOrPthSingle = list(dfG_aux.query('Cst == 1 and Css == 1')['TE'])
 vMergeMult = list(dfG_aux.query('Cst == 2 and Css == 0')['TE'])
 vMergeSingle = list(dfG_aux.query('Cst == 2 and Css == 1')['TE'])
 vMergePthMult = list(dfG_aux.query('Cst == 3 and Css == 0')['TE'])
 vMergePthSingle = list(dfG_aux.query('Cst == 3 and Css == 1')['TE'])
 vOrMult2 = list(dfM_aux.query('Cst == 0 and Css == 0')['TC'])
 vOrSingle2 = list(dfM_aux.query('Cst == 0 and Css == 1')['TC'])
 vOrPthMult2 = list(dfM_aux.query('Cst == 1 and Css == 0')['TC'])
 vOrPthSingle2 = list(dfM_aux.query('Cst == 1 and Css == 1')['TC'])
 vMergeMult2 = list(dfM_aux.query('Cst == 2 and Css == 0')['TC'])
 vMergeSingle2 = list(dfM_aux.query('Cst == 2 and Css == 1')['TC'])
 vMergePthMult2 = list(dfM_aux.query('Cst == 3 and Css == 0')['TC'])
 vMergePthSingle2 = list(dfM_aux.query('Cst == 3 and Css == 1')['TC'])
 f=plt.figure(figsize=(30, 12))
 ax=f.add_subplot(111)
 ax.scatter(vOrMult,vOrMult2, color='green')
 ax.scatter(vOrSingle,vOrSingle2,  color='springgreen')
 ax.scatter(vOrPthMult,vOrPthMult2, color='blue')
 ax.scatter(vOrPthSingle,vOrPthSingle2,color='darkblue')
 ax.scatter(vMergeMult,vMergeMult2, color='red')
 if used_direction=='e':
     ax.scatter(vMergeSingle,vMergeSingle2,color='darkred')
 ax.scatter(vMergePthMult,vMergePthMult2, color='yellow')
 if used_direction=='e':
     ax.scatter(vMergePthSingle,vMergePthSingle2,color='olive')
 ax.set_ylabel("Time TC(s)", fontsize=20)
 ax.set_xlabel("Time EX (s)", fontsize=20)
 #plt.xticks(x, used_labels, rotation=90)
 plt.legend(handles=handles, loc='upper right', fontsize=21,ncol=2)
 ax.tick_params(axis='both', which='major', labelsize=24)
 ax.tick_params(axis='both', which='minor', labelsize=22)
 f.tight_layout()
 f.savefig("Images/Spawn/Dispersion_Spawn_"+name_fig+".png", format="png")
 ```
 %%%% Output: display_data
     [Hidden Image Output]
 %% Cell type:code id: tags:
 ``` python
 valores1 = [0]*10
 valores2 = [0.2]*10
 valores3 = [0.4]*10
 valores4 = [0.6]*10
 valores5 = [0.8]*10
 valores6 = [1]*10
 valores7 = [1.2]*10
 valores8 = [1.4]*10
 for np_aux in processes:
     for ns_aux in processes:
         if np_aux != ns_aux:
             if np_aux > ns_aux:
                 used_labels=labelsShrink
                 name_fig="Shrink"
                 handles=[OrMult_patch,OrSing_patch,OrPthMult_patch,OrPthSing_patch,MergeMult_patch,MergePthMult_patch]
             else:
                 used_labels=labelsExpand
                 name_fig="Expand"
                 handles=[OrMult_patch,OrSing_patch,OrPthMult_patch,OrPthSing_patch,MergeMult_patch,MergeSing_patch,MergePthMult_patch,MergePthSing_patch]
             dfM_aux = dfM.query('NP == @np_aux and NS == @ns_aux')
             vOrMult2 = list(dfM_aux.query('Cst == 0 and Css == 0')['TC'])
             vOrSingle2 = list(dfM_aux.query('Cst == 0 and Css == 1')['TC'])
             vOrPthMult2 = list(dfM_aux.query('Cst == 1 and Css == 0')['TC'])
             vOrPthSingle2 = list(dfM_aux.query('Cst == 1 and Css == 1')['TC'])
             vMergeMult2 = list(dfM_aux.query('Cst == 2 and Css == 0')['TC'])
             vMergeSingle2 = list(dfM_aux.query('Cst == 2 and Css == 1')['TC'])
             vMergePthMult2 = list(dfM_aux.query('Cst == 3 and Css == 0')['TC'])
             vMergePthSingle2 = list(dfM_aux.query('Cst == 3 and Css == 1')['TC'])
             f=plt.figure(figsize=(16, 8))
             ax=f.add_subplot(111)
             ax.scatter(vOrMult2,valores1, color='green')
             ax.scatter(vOrSingle2,valores2,  color='springgreen')
             ax.scatter(vOrPthMult2,valores3, color='blue')
             ax.scatter(vOrPthSingle2,valores4,color='darkblue')
             ax.scatter(vMergeMult2,valores5, color='red')
             if np_aux < ns_aux:
                 ax.scatter(vMergeSingle2,valores6,color='darkred')
             ax.scatter(vMergePthMult2,valores7, color='yellow')
             if np_aux < ns_aux:
                 ax.scatter(vMergePthSingle2,valores8,color='olive')
             ax.set_xlabel("Time TC(s)", fontsize=16)
             ax.set_ylabel("-", fontsize=16)
 #plt.xticks(x, used_labels, rotation=90)
             plt.legend(handles=handles, loc='upper right', fontsize=14,ncol=2)
             ax.tick_params(axis='both', which='major', labelsize=20)
             ax.tick_params(axis='both', which='minor', labelsize=18)
             f.tight_layout()
             f.savefig("Images/Spawn/Dispersion/Dispersion_Spawn_"+name_fig+"_"+str(np_aux)+"_"+str(ns_aux)+".png", format="png")
 ```
 %% Cell type:code id: tags:
 ``` python
 used_direction='e'
 test_parameter='TA'
 #TS es merge y TA connect para tests solo spawn
 if used_direction=='s':
     dfM_aux=dfM.query('NP > NS')
     used_labels=labelsShrink
     name_fig="Shrink"
     handles=[OrSing_patch,OrPthMult_patch,OrPthSing_patch,MergeMult_patch,MergePthMult_patch]
 elif used_direction=='e':
     dfM_aux=dfM.query('NP < NS')
     used_labels=labelsExpand
     name_fig="Expand"
     handles=[OrSing_patch,OrPthMult_patch,OrPthSing_patch,MergeMult_patch,MergeSing_patch,MergePthMult_patch,MergePthSing_patch]
 # < Expand
 # > Shrink
 dfM_aux = dfM_aux.copy()
 #dfM_aux['NTotal'] = dfM_aux['NP'] + dfM_aux['NS']
 dfM_aux['NTotal'] = dfM_aux['NS']
 #x = np.arange(len(used_labels))
 for cst_aux in [0,1,2,3]:
     for css_aux in [0,1]:
         f=plt.figure(figsize=(20, 12))
         ax=f.add_subplot(111)
         #sns.boxplot(y=test_parameter, x="NS", hue="NP", data = dfM_aux[(dfM_aux.Cst == cst_aux)][(dfM_aux.Css == css_aux)], orient="v", ax=ax)
         sns.boxplot(y=test_parameter, x="NTotal", data = dfM_aux[(dfM_aux.Cst == cst_aux)][(dfM_aux.Css == css_aux)], orient="v", ax=ax)
         # Anyade en el plot el numero de iteraciones - Por hacer TODO
         # https://stackoverflow.com/questions/45475962/labeling-boxplot-with-median-values
         #medians_aux = dfM[(dfM.Cst == cst_aux)][(dfM.Css == css_aux)].groupby(['NS','NP'])['TC'].median()
         #m1 = dfM[(dfM.Cst == cst_aux)][(dfM.Css == css_aux)].groupby(['NS','NP'])['TC'].median().values
         #mL1 = [str(np.ceil(s)) for s in m1]
         #ind = 0
         #for tick in range(len(ax.get_xticklabels())):
         #    ax.text(tick-.2, m1[ind+1]+1, mL1[ind+1],  horizontalalignment='center',  color='w', weight='semibold')
         #    ax.text(tick+.2, m1[ind]+1, mL1[ind], horizontalalignment='center', color='w', weight='semibold')
         #    ind += 2
         ax.set_ylabel("Time TC(s)", fontsize=20)
         ax.set_xlabel("NC", fontsize=20)
         plt.legend(loc='upper left', fontsize=21, title = "NP")
         ax.tick_params(axis='both', which='major', labelsize=24)
         ax.tick_params(axis='both', which='minor', labelsize=22)
         ax.axvline((.5), color='black')
         ax.axvline((1.5), color='black')
         ax.axvline((2.5), color='black')
         ax.axvline((3.5), color='black')
         ax.axvline((4.5), color='black')
         f.tight_layout()
         f.savefig("Images/Spawn/Boxplot_"+name_fig+"_"+test_parameter+"_"+labelsMethods[cst_aux*2 + css_aux]+".png", format="png")
 ```
 %% Cell type:code id: tags:
 ``` python
 used_direction='s'
 test_parameter='alpha' #Valores son "alpha" o "omega"
 if test_parameter == 'alpha':
     name_fig="Alpha_"
     real_parameter='Alpha_A'
     name_legend = "Values of α"
 elif test_parameter == 'omega':
     name_fig="Omega_"
     real_parameter='Omega_A'
     name_legend = "Values of ω"
 df_aux=grouped_aggM
 if used_direction=='s':
     df_aux=df_aux.query('NP > NS')
     used_labels=labelsShrinkOrdered
     name_fig= name_fig+"Shrink"
 elif used_direction=='e':
     df_aux=df_aux.query('NP < NS')
     used_labels=labelsExpand
     name_fig= name_fig+"Expand"
 elif used_direction=='a':
     df_aux=df_aux
     used_labels=labels
     name_fig= name_fig+"All"
 x = np.arange(len(used_labels))
 f=plt.figure(figsize=(22, 14))
 ax=f.add_subplot(111)
 ax.set_xlabel("(NP,NC)", fontsize=36)
 ax.set_ylabel(name_legend, fontsize=36)
 plt.xticks(x, used_labels,rotation=90)
 ax.tick_params(axis='both', which='major', labelsize=36)
 ax.tick_params(axis='both', which='minor', labelsize=36)
 for cst_aux in [1,3]:
     df_aux2 = df_aux.query('Cst == @cst_aux')
     for css_aux in [0,1]:
         if cst_aux == 3 and css_aux == 1 and used_direction == 's':
             continue
         array_aux = df_aux2.query('Css == @css_aux')
         if used_direction=='s':
             array_aux = array_aux.sort_values(by=['NS'])
         array_aux = array_aux[real_parameter].values
         style_aux = cst_aux*2 + css_aux
         ax.plot(x, array_aux, color=colors_spawn[style_aux], linestyle=linestyle_spawn[style_aux%4], \
                 marker=markers_spawn[style_aux], markersize=18, label=labelsMethods[style_aux])
 ax.set_ylim(0,3.2)
 plt.legend(loc='best', fontsize=30,ncol=2,framealpha=1)
 f.tight_layout()
 f.savefig("Images/Spawn/LinePlot_"+name_fig+".png", format="png")
 ```
 %%%% Output: display_data
     [Hidden Image Output]
 %% Cell type:code id: tags:
 ``` python
 used_direction='s'
 test_parameter='alpha' #Valores son "alpha" o "omega"
 if used_direction=='s':
     df_aux=grouped_aggM.query('NP > NS')
     used_labels=labelsShrink
     name_fig="Shrink"
     np_aux = [10, 20,20, 40,40,40, 80,80,80,80, 120,120,120,120,120]
     nc_aux = [1,  1,10,  1,10,20,  1,10,20,40,  1,10,20,40,80]
 elif used_direction=='e':
     df_aux=grouped_aggM.query('NP < NS')
     used_labels=labelsExpand
     name_fig="Expand"
     np_aux = [1,1,1,1,1,        10,10,10,10,  20,20,20,  40,40,  80 ]
     nc_aux = [10,20,40,80,120,  20,40,80,120, 40,80,120, 80,120, 120]
 elif used_direction=='a':
     df_aux=grouped_aggM
     used_labels=labels
     name_fig="All"
     np_aux = [1,1,1,1,1,        10,10,10,10,10, 20,20,20,20,20, 40,40,40,40,40, 80,80,80,80,80, 120,120,120,120,120]
     nc_aux = [10,20,40,80,120,  1,20,40,80,120, 1,10,40,80,120, 1,10,20,80,120, 1,10,20,40,120, 1,10,20,40,80]
 x = np.arange(len(used_labels))
 handles = []
 f=plt.figure(figsize=(20, 12))
 #ax=f.add_subplot(111)
 ax = plt.axes(projection='3d')
 ax.azim = -60
 ax.dist = 10
 ax.elev = 10
 ax.set_xlabel("NP", fontsize=20)
 ax.set_ylabel("NC", fontsize=20)
 ax.set_zlabel("Alpha", fontsize=20)
 ax.tick_params(axis='both', which='major', labelsize=24)
 ax.tick_params(axis='both', which='minor', labelsize=22)
 for cst_aux in [1,3]:
     df_aux2 = df_aux.query('Cst == @cst_aux')
     for css_aux in [0,1]:
         array_aux = df_aux2.query('Css == @css_aux')['alpha'].values
         ax.plot3D(np_aux, nc_aux, array_aux, colors_spawn[cst_aux*2 + css_aux])
         handles.append(handles_spawn[cst_aux*2 + css_aux])
 #ax.set_zlim(0,4)
 plt.legend(handles=handles, loc='best', fontsize=20,ncol=2,framealpha=1)
 f.tight_layout()
 f.savefig("Images/Spawn/3dPlot_"+name_fig+'_'+test_parameter+".png", format="png")
 ```
 %%%% Output: display_data
     [Hidden Image Output]
 %% Cell type:code id: tags:
 ``` python
 def check_normality(df, tipo):
     normality=[True] * (len(processes) * (len(processes)-1))
     total=0
     i=-1
     #Comprobar para cada configuración si se sigue una distribución normal/gaussiana
     for np_aux in processes:
         for ns_aux in processes:
             if np_aux != ns_aux:
                 i+=1
                 for cst_aux in [0,1,2,3]:
                     for css_aux in [0,1]:
                         df_aux = df.query('NP == @np_aux and NS == @ns_aux and Cst == @cst_aux and Css == @css_aux')
                         dataList = list(df_aux[tipo])
                         st,p = stats.shapiro(dataList) # Tendrían que ser al menos 20 datos y menos de 50
                         if p < p_value:
                             normality[i]=False
                             total+=1
     print("Se sigue una distribución guassiana: " + str(normality) + "\nUn total de: " + str(total) + " no siguen una gaussiana")
     return normality
 ```
 %% Cell type:code id: tags:
 ``` python
 def compute_global_stat_difference(dataLists, parametric):
     if parametric:
         st,p=stats.f_oneway(dataLists[0],dataLists[1],dataLists[2],dataLists[3],dataLists[4],dataLists[5],dataLists[6],dataLists[7])
     else:
         st,p=stats.kruskal(dataLists[0],dataLists[1],dataLists[2],dataLists[3],dataLists[4],dataLists[5],dataLists[6],dataLists[7])
     if p > p_value: # Si son iguales, no hay que hacer nada más
         return False
     return True
 ```
 %% Cell type:code id: tags:
 ``` python
 def compute_global_posthoc(dataLists, parametric):
     data_stats=[]
     ini=0
     end=len(labelsMethods)
     if parametric:
         df_aux = sp.posthoc_ttest(dataLists)
         df_Res = df_aux.copy()
         for i in range(ini,end):
             data_stats.append(np.mean(dataLists[i]))
             for j in range(ini,end):
                 if df_Res.iat[i,j] < p_value: # Medias diferentes
                     df_Res.iat[i, j] = True
                 else:
                     df_Res.iat[i, j] = False
     else:
         df_aux = sp.posthoc_conover(dataLists)
         df_Res = df_aux.copy()
         for i in range(ini,end):
             data_stats.append(np.median(dataLists[i]))
             for j in range(ini,end):
                 if df_Res.iat[i,j] < p_value: # Medianas diferentes
                     df_Res.iat[i, j] = True
                 else:
                     df_Res.iat[i, j] = False
     #print(df_Res)
     #print(df_aux)
     #print(data_stats)
     return df_Res, data_stats
 ```
 %% Cell type:code id: tags:
 ``` python
 # Aquellos grupos que tengán valores por encima del límite no se considerarán
 # Con sumar a si mismos su valor actual estarán fuera
 def check_groups_boundaries(data_stats, np_aux, ns_aux, tc_boundary):
     index_aux = 0
     for cst_aux in [0,2]: # Primero los grupos síncronos
         for css_aux in [0,1]:
             if cst_aux == 2 and css_aux == 1 and np_aux > ns_aux: # Arreglo para coger bien el tiempo en Merge Single Shrink
                 index_aux = 1
             tc_val = grouped_aggM.loc[('2,2',0, cst_aux, css_aux - index_aux, np_aux,ns_aux), 'TC_A']
             if tc_val > tc_boundary:
                 data_stats[cst_aux*2 + css_aux]+=data_stats[cst_aux*2 + css_aux]
     index_aux = 0
     for cst_aux in [1,3]: # Segundo se comprueban los asíncronos
         for css_aux in [0,1]:
             if cst_aux == 3 and css_aux == 1 and np_aux > ns_aux: # Arreglo para coger bien el tiempo en Merge Single Shrink
                 index_aux = 1
             tc_val = grouped_aggM.loc[('2,2',0, cst_aux, css_aux - index_aux, np_aux,ns_aux), 'TH']
             if tc_val > tc_boundary:
                 data_stats[cst_aux*2 + css_aux]+=data_stats[cst_aux*2 + css_aux]
 ```
 %% Cell type:code id: tags:
 ``` python
 def get_stat_differences(df_Res, data_stats, np_aux, ns_aux, shrink, parametric):
     best = 0
     otherBest=[]
     # TODO Descomentar tras anyadir RMS perspective en results_with_st
     #if rms_boundary != 0: # Si se usa perspectiva de RMS, se desconsideran valores muy altos
     #    check_groups_boundaries(data_stats, np_aux, ns_aux, tc_boundary)
     indexes = np.argsort(data_stats)
     best = -1
     i = 0
     while best == -1:
         index = indexes[i]
         if not (shrink and (index == 5 or index == 7)): # Las opciones Merge single(5) y Merge single - Pthreads(7) no se utilizan al reducir
             #if rms_boundary == 0 or data_stats[index] <= tc_boundary:
             best = index
         i+=1
     otherBest=[]
     for index in range(len(labelsMethods)): # Para cada metodo exceptuando best
         if not (shrink and (index == 5 or index == 7)): # Las opciones Merge single(5) y Merge single - Pthreads(7) no se utilizan al reducir
             if index != best and not df_Res.iat[best,index]: #Medias/Medianas iguales
                 #if data_stats[index] <= tc_boundary:
                 otherBest.append(index)
     stringV=""
     for i in otherBest:
         stringV+=labelsMethods[i]+", "
     print("Redimensión " + str(np_aux) + "/" + str(ns_aux) +" "+ str(parametric)+" Mejores: " + labelsMethods[best]+", " + stringV)
     otherBest.insert(0,best)
     return otherBest
 ```
 %% Cell type:code id: tags:
 ``` python
 def get_perc_differences(dataLists, np_aux, ns_aux, shrink, rms_boundary, tc_boundary):
     data_stats = []
     ini=0
     end=len(labelsMethods)
     for i in range(ini,end):
         data_stats.append(np.median(dataLists[i]))
     if rms_boundary != 0: # Si se usa perspectiva de RMS, se desconsideran valores muy altos
         check_groups_boundaries(data_stats, np_aux, ns_aux, tc_boundary)
     indexes = np.argsort(data_stats)
     best = -1
     bestMax = -1
     otherBest=[]
     for index in indexes: # Para cada metodo -- Empezando por el más bajo en media/mediana
         if shrink and (index == 5 or index == 7): # Las opciones Merge single(5) y Merge single - Pthreads(7) no se utilizan al reducir
             continue
         if best == -1:
             best = index
             bestMax = data_stats[best] * 0.05 + data_stats[best]
         elif data_stats[index] <= bestMax: # Medias/Medianas diferentes && Media/Medianas i < Media/Mediana best
             otherBest.append(index)
     stringV=""
     for i in otherBest:
         stringV+=labelsMethods[i]+", "
     print("Redimensión " + str(np_aux) + "/" + str(ns_aux)+" Mejores: " + labelsMethods[best]+", " + stringV)
     otherBest.insert(0,best)
     return otherBest
 ```
 %% Cell type:code id: tags:
 ``` python
 #Obtiene
 def check_groups_stats(dataLists, np_aux, ns_aux, shrink, parametric):
     global_difference=compute_global_stat_difference(dataLists, parametric)
     if not global_difference:
         print("Configuración: " + str(np_aux) + "/" + str(ns_aux) + " tiene valores iguales")
         return
     df_Res,data_stats=compute_global_posthoc(dataLists,parametric)
     return get_stat_differences(df_Res, data_stats, np_aux, ns_aux, shrink, parametric)
 ```
 %% Cell type:code id: tags:
 ``` python
 def results_with_st(tipo, data_aux):
     normality=check_normality(data_aux,tipo)
     if False in normality:
         normality = False
     else:
         normality = True
     results = []
     shrink = False
     for np_aux in processes:
         for ns_aux in processes:
             if np_aux != ns_aux:
                 dataSet = data_aux.query('NP == @np_aux and NS == @ns_aux')
                 dataLists=[]
                 if np_aux > ns_aux:
                     shrink = True
                 else:
                     shrink = False
                 #normality=True
                 for cst_aux in [0,1,2,3]:
                     for css_aux in [0,1]:
                         dataSet_aux = dataSet.query('Cst == @cst_aux and Css == @css_aux')
                         lista_aux = list(dataSet_aux[tipo])
                         dataLists.append(lista_aux)
                         #Si permito el shaphiro, acabare comparando manzanas y naranjas
                         # si hay distribuciones normales y no normales
                         #st,p = stats.shapiro(lista_aux) # Tendrían que ser al menos 20 datos y menos de 50
                         #if p < p_value:
                         #normality=False
                 aux_data = check_groups_stats(dataLists, np_aux, ns_aux, shrink, normality)
                 results.append(aux_data)
     return results
 ```
 %% Cell type:code id: tags:
 ``` python
 def results_with_perc(tipo, data_aux, rms_boundary=0):
     results = []
     shrink = False
     for np_aux in processes:
         for ns_aux in processes:
             if np_aux != ns_aux:
                 dataSet = data_aux.query('NP == @np_aux and NS == @ns_aux')
                 dataLists=[]
                 if np_aux > ns_aux:
                     shrink = True
                 else:
                     shrink = False
                 tc_boundary = dfM.query('NP == @np_aux and NS == @ns_aux')['TC'].max()
                 if rms_boundary == 0:
                     for cst_aux in [0,1,2,3]:
                         for css_aux in [0,1]:
                             dataSet_aux = dataSet.query('Cst == @cst_aux and Css == @css_aux')
                             lista_aux = list(dataSet_aux[tipo])
                             dataLists.append(lista_aux)
                 else:
                     boundaries = []
                     for cst_aux in [0,1,2,3]:
                         for css_aux in [0,1]:
                             dataSet_aux = dataSet.query('Cst == @cst_aux and Css == @css_aux')
                             lista_aux = list(dataSet_aux[tipo])
                             dataLists.append(lista_aux)
                             if cst_aux == 0 or cst_aux == 2:
                                 if cst_aux == 2 and css_aux == 1  and (np_aux > ns_aux):
                                     new_boundary = tc_boundary
                                 else:
                                     new_boundary = grouped_aggM.loc[('2,2',0, cst_aux, css_aux, np_aux,ns_aux), 'TC_A']
                             else:
                                 if cst_aux == 3 and css_aux == 1 and (np_aux > ns_aux):
                                     new_boundary = tc_boundary
                                 else:
                                     new_boundary = grouped_aggM.loc[('2,2',0, cst_aux, css_aux, np_aux,ns_aux), 'TH']
                             boundaries.append(new_boundary)
                     tc_boundary = min(boundaries)
                     tc_boundary = tc_boundary + tc_boundary*rms_boundary
                 aux_data = get_perc_differences(dataLists, np_aux, ns_aux, shrink, rms_boundary, tc_boundary)
                 results.append(aux_data)
     return results
 ```
 %% Cell type:code id: tags:
 ``` python
 checked_type='te'
 use_perc = True
 rms_boundary=0.1 # Poner a 0 para perspectiva de app. Valor >0 y <1 para perspectiva de RMS
 if checked_type=='te':
     tipo="TE"
     data_aux=dfG
 elif checked_type=='tc':
     tipo="TC"
     data_aux=dfM
 if use_perc:
     results = results_with_perc(tipo, data_aux, rms_boundary)
 else:
     results = results_with_st(tipo, data_aux)
 print(results)
 ```
 %%%% Output: stream
     Redimensión 1/10 Mejores: Merge single, Merge,
     Redimensión 1/20 Mejores: Merge single, Merge,
     Redimensión 1/40 Mejores: Baseline, Merge single, Merge,
     Redimensión 1/80 Mejores: Baseline, Merge, Merge single,
     Redimensión 1/120 Mejores: Baseline, Merge single,
     Redimensión 10/1 Mejores: Merge,
     Redimensión 10/20 Mejores: Merge, Merge single,
     Redimensión 10/40 Mejores: Merge, Merge single,
     Redimensión 10/80 Mejores: Merge,
     Redimensión 10/120 Mejores: Merge, Merge single,
     Redimensión 20/1 Mejores: Merge,
     Redimensión 20/10 Mejores: Merge,
     Redimensión 20/40 Mejores: Merge single, Merge,
     Redimensión 20/80 Mejores: Merge,
     Redimensión 20/120 Mejores: Merge,
     Redimensión 40/1 Mejores: Merge,
     Redimensión 40/10 Mejores: Merge,
     Redimensión 40/20 Mejores: Merge,
     Redimensión 40/80 Mejores: Merge,
     Redimensión 40/120 Mejores: Merge single,
     Redimensión 80/1 Mejores: Merge,
     Redimensión 80/10 Mejores: Merge,
     Redimensión 80/20 Mejores: Merge,
     Redimensión 80/40 Mejores: Merge,
     Redimensión 80/120 Mejores: Merge, Merge single,
     Redimensión 120/1 Mejores: Merge - Asynchronous,
     Redimensión 120/10 Mejores: Merge,
     Redimensión 120/20 Mejores: Merge,
     Redimensión 120/40 Mejores: Merge,
     Redimensión 120/80 Mejores: Merge,
     [[5, 4], [5, 4], [0, 5, 4], [0, 4, 5], [0, 5], [4], [4, 5], [4, 5], [4], [4, 5], [4], [4], [5, 4], [4], [4], [4], [4], [4], [4], [5], [4], [4], [4], [4], [4, 5], [6], [4], [4], [4], [4]]
 %% Cell type:code id: tags:
 ``` python
 #Lista de indices de mayor a menor de los valores
 aux_array = []
 for data in results:
     aux_array+=data
 unique, counts = np.unique(aux_array, return_counts=True)
 aux_dict = dict(zip(unique, counts))
 aux_keys=list(aux_dict.keys())
 aux_values=list(aux_dict.values())
 aux_ordered_index=list(reversed(list(np.argsort(aux_values))))
 i=0
 j=0
 used_aux=0
 heatmap=np.zeros((len(processes),len(processes))).astype(int)
 if use_perc:
     for i in range(len(processes)):
         for j in range(len(processes)):
             if i==j:
                 heatmap[i][j]=-1
                 used_aux+=1
             else:
                 results_index = i*len(processes) +j-used_aux
                 heatmap[i][j] = results[results_index][0]
 else:
     for i in range(len(processes)):
         for j in range(len(processes)):
             if i==j:
                 heatmap[i][j]=-1
                 used_aux+=1
             else:
                 results_index = i*len(processes) +j-used_aux
                 for index in aux_ordered_index:
                     if aux_keys[index] in results[results_index]:
                         heatmap[i][j]=aux_keys[index]
                         break
 heatmap[len(processes)-1][len(processes)-1]=8
 print(heatmap)
 ```
 %%%% Output: stream
     [[-1  5  5  0  0  0]
      [ 4 -1  4  4  4  4]
      [ 4  4 -1  5  4  4]
      [ 4  4  4 -1  4  5]
      [ 4  4  4  4 -1  4]
      [ 6  4  4  4  4  8]]
 %% Cell type:code id: tags:
 ``` python
 #Adapta results a una cadena asegurando que cada cadena no se sale de su celda
 results_str = []
 max_counts = 1
 for i in range(len(results)):
     results_str.append(list())
     count = len(results[i])
     new_data = str(results[i]).replace('[','').replace(']','')
     remainder = count%3
     if count <= 3:
         results_str[i].append(new_data)
     else:
         if remainder == 0:
             results_str[i].append(new_data[0:8])
             results_str[i].append(new_data[9:])
         else:
             index = 1 + (remainder -1)*3
             results_str[i].append(new_data[0:index+1])
             results_str[i].append(new_data[index+2:])
     if count > max_counts:
         if count > 3:
             aux_value = results_str[i].pop()[0:1]
         results_str[i][0] = results_str[i][0][0:max_counts*3-2]
         if remainder == 1 and max_counts > 1:
             results_str[i][0] = results_str[i][0] + ' ' + aux_value
 #print(results_str)
 ```
 %% Cell type:code id: tags:
 ``` python
 #Crea un heatmap teniendo en cuenta los colores anteriores
 f=plt.figure(figsize=(24, 12))
 ax=f.add_subplot(111)
 myColors = (colors.to_rgba("white"),colors.to_rgba("green"), colors.to_rgba("springgreen"),colors.to_rgba("blue"),colors.to_rgba("darkblue"),
             colors.to_rgba("red"),colors.to_rgba("darkred"),colors.to_rgba("darkgoldenrod"),colors.to_rgba("olive"),colors.to_rgba("white"))
 cmap = LinearSegmentedColormap.from_list('Custom', myColors, len(myColors))
 im = ax.imshow(heatmap,cmap=cmap,interpolation='nearest')
 # Loop over data dimensions and create text annotations.
 used_aux=0
 for i in range(len(processes)):
     for j in range(len(processes)):
         if i!=j:
             aux_color="white"
             if heatmap[i, j] == 1: # El 1 puede necesitar texto en negro
                 aux_color="black"
             results_index = i*len(processes) +j-used_aux
             if len(results_str[results_index]) == 1:
                 text = results_str[results_index][0]
                 ax.text(j, i, text, ha="center", va="center", color=aux_color, fontsize=36)
             else:
                 add_aux = 0.33
                 for line in range(len(results_str[results_index])):
                     i_range = i - 0.5 + add_aux
                     ax.text(j, i_range, results_str[results_index][line],
                             ha="center", va="center", color=aux_color, fontsize=36)
                     add_aux+=0.33
         else:
             used_aux+=1
 ax.set_ylabel("NP", fontsize=36)
 ax.set_xlabel("NC", fontsize=36)
 ax.set_xticklabels(['']+processes, fontsize=36)
 ax.set_yticklabels(['']+processes, fontsize=36)
 #
 labelsMethods_aux = ['Baseline (0)', 'Baseline single (1)','Baseline - Asynchronous (2)','Baseline single - Asynchronous (3)',
                  'Merge (4)','Merge single (5)','Merge - Asynchronous (6)','Merge single - Asynchronous (7)']
 colorbar=f.colorbar(im, ax=ax)
 colorbar.set_ticks([0.35, 1.25, 2.15, 3.05, 3.95, 4.85, 5.75, 6.65]) #TE
 #colorbar.set_ticks([-2.55, 0.35, 1.25, 2.15, 3.05, 3.95, 4.85, 5.75, 6.65]) #TC
 colorbar.set_ticklabels(labelsMethods_aux)
 colorbar.ax.tick_params(labelsize=32)
 #
 f.tight_layout()
 f.savefig("Images/Spawn/Heatmap_"+tipo+".png", format="png")
 ```
 %%%% Output: stream
     /tmp/ipykernel_2692/2593541567.py:36: UserWarning: FixedFormatter should only be used together with FixedLocator
       ax.set_xticklabels(['']+processes, fontsize=36)
     /tmp/ipykernel_2692/2593541567.py:37: UserWarning: FixedFormatter should only be used together with FixedLocator
       ax.set_yticklabels(['']+processes, fontsize=36)
 %%%% Output: display_data
     [Hidden Image Output]
 %% Cell type:code id: tags:
 ``` python
 aux_labels = ['(10)', '(10,1)', '(10,20)', '(10,40)','(10,80)','(10,120)']
 aux_values = [1, 20, 40, 80, 120]
 title_y="Execution time(s)"
 title_x="(NP,NC)"
 maxiters_aux = 30
 iters_aux1 = 10
 iters_aux2 = 20
 aggM_aux = grouped_aggM.query('NP == 10').query('Cst == 2').query('Css == 0')['TR'].values
 aux1 = grouped_aggL.query('NP == 10').query('Cst == 2').query('Css == 0').query('NS == 1')
 aux2 = grouped_aggL.query('NS == 10').query('Cst == 2').query('Css == 0')
 data_aux1 = [aux1['Ti'].values[0] * maxiters_aux]
 data_aux2 = [0]
 data_aux3 = [0]
 for i in range(len(aux_labels)-1):
     data_aux1.append(aux1['Ti'].values[0] * iters_aux1)
     data_aux2.append(aggM_aux[i])
     aux_value = aux_values[i]
     data_aux3.append(aux2.query('NP == @aux_value')['Ti'].values[0] * iters_aux2)
 print(data_aux1)
 print(data_aux2)
 print(data_aux3)
 sum_aux = np.add(data_aux1, data_aux2).tolist()
 f=plt.figure(figsize=(30, 12))
 ax=f.add_subplot(111)
 x = np.arange(len(aux_labels))
 width = 0.5
 blue_Spatch = mpatches.Patch(facecolor='blue', label='Parents Time')
 orange_Spatch = mpatches.Patch(hatch='...',facecolor='orange', label='Resize Time')
 green_Spatch = mpatches.Patch(hatch='\\/',facecolor='green', label='Children Time')
 handles=[blue_Spatch,orange_Spatch,green_Spatch]
 ax.bar(x, data_aux1, width, color='blue')
 ax.bar(x, data_aux2, width, bottom=data_aux1,color='orange', hatch='...')
 ax.bar(x, data_aux3, width, bottom=sum_aux,color='green', hatch='\\/')
 ax.set_ylabel(title_y, fontsize=30)
 ax.set_xlabel(title_x, fontsize=28)
 plt.xticks(x, aux_labels, rotation=90)
 #plt.yscale("log")
 ax.tick_params(axis='both', which='major', labelsize=30)
 ax.tick_params(axis='both', which='minor', labelsize=28)
 plt.legend(handles=handles, loc='upper left', fontsize=26)
 f.tight_layout()
 f.savefig("Images/malleabilityTest.png", format="png")
 ```
 %%%% Output: stream
     [11.986845, 3.995615, 3.995615, 3.995615, 3.995615, 3.995615]
     [0, 0.0009824999999999999, 0.4770405, 0.766185, 0.8609199999999999, 0.890894]
     [0, 79.98284, 3.99641, 1.99956, 0.9997100000000001, 0.6615499999999999]
 %%%% Output: display_data
     [Hidden Image Output]
 %% Cell type:code id: tags:
 ``` python
 ```
 %% Cell type:code id: tags:
 ``` python
 processes = [2,10,20,40,80,120,160,200]
 removed= []
 #Audik
 aux_real = [[171.737683, 171.721757, 171.712188, 172.025576, 171.824876, 172.195573, 172.085584, 172.184726, 171.713528, 172.086622, 172.066681, 172.964532, 172.229674, 171.916479, 171.984405, 172.127481, 171.669226, 171.739088, 171.974926, 171.751413], [68.331026, 68.713697, 68.206408, 67.885963, 68.693203, 68.568758, 68.54315, 68.511886, 68.390384, 68.5941, 68.464007, 68.369401, 68.422746, 68.535845, 68.503719, 68.404653, 68.792502, 68.477037, 68.512661, 68.559632], [40.694064, 40.989289, 40.742276, 41.025095, 40.863411, 41.005171, 40.705705, 42.076044, 40.49322, 40.933576, 40.632797, 41.346974, 42.414697, 39.96742, 40.927754, 39.910709, 39.778547, 40.712781, 41.478955, 40.403166], [30.04606, 29.085335, 27.345307, 30.238709, 34.168857, 29.744953, 27.631665, 28.170737, 27.113985, 27.96026, 29.121938, 29.229577, 27.341234, 27.349849, 29.133614, 27.205169, 30.273867, 28.97881, 30.29552, 29.045342], [23.08803, 23.585224, 23.425999, 22.946976, 25.210113, 23.013397, 23.421095, 22.66769, 24.621629, 23.740202, 24.069326, 24.87756, 24.931077, 24.022584, 23.596376, 22.101887, 22.086059, 23.988373, 22.905784, 22.300686], [20.578533, 21.146572, 23.113501, 22.796446, 27.166076, 21.821828, 21.016317, 23.468519, 19.655022, 23.826594, 21.723859, 24.282099, 24.850651, 26.058704, 21.709948, 20.57436, 21.496566, 22.860724, 25.819541, 23.12921], [25.043008, 24.306459, 22.952676, 23.921501, 23.581935, 24.324931, 27.242627, 22.308218, 24.807042, 26.235116, 22.731008, 21.579133, 21.154274, 23.548367, 27.395588, 23.154962, 23.773857, 26.417468, 23.717991, 25.39742], [24.616342, 24.039981, 24.206909, 24.654299, 28.106219, 26.687135, 23.869267, 24.097884, 25.629433, 27.700148, 25.425307, 26.413679, 25.972044, 25.791893, 25.866064, 24.27758, 25.591149, 26.614081, 26.93407, 29.430697]]
 aux_sint = [[171.134606, 171.096637, 171.138184, 171.13844, 171.098454, 171.162362, 171.082225, 171.079004, 171.114536, 171.227906, 171.071966, 171.130859, 171.104273, 171.07788, 171.072194, 171.069075, 171.140295, 171.174013, 171.25217, 171.117231], [67.571535, 67.520025, 68.079664, 66.738064, 67.532297, 68.069914, 68.139622, 68.190914, 68.243213, 67.492165, 68.112115, 68.059658, 68.160322, 68.085698, 67.525525, 68.187291, 68.02039, 68.176564, 67.980121, 68.312952], [42.473247, 45.53225, 43.409906, 42.42814, 42.118484, 41.443236, 42.156082, 42.256023, 42.111314, 41.603221, 42.184052, 40.928944, 42.07551, 40.908719, 44.262672, 43.524809, 43.537822, 39.367229, 42.1689, 42.298479], [], [26.457291, 24.824646, 33.71007, 25.375645, 25.186218, 26.786703, 26.456784, 23.513595, 30.993635, 24.907237, 24.459753, 30.953045, 25.399975, 27.167862, 27.861115, 27.324158, 26.498797, 29.3722, 26.955239, 20.790296], [26.147293, 27.675856, 25.173467, 25.416053, 25.663571, 25.885352, 26.732089, 26.314055, 28.788113, 23.810305, 26.504224, 25.912384, 27.372798, 29.319178, 28.562837, 23.406136, 27.48343, 28.364868, 28.199635, 26.765826], [30.542833, 36.02513, 29.552827, 29.877948, 35.743363, 29.331332, 31.847175, 34.500058, 26.578159, 32.713294, 34.322071, 29.951176, 32.658056, 34.987492, 28.456334, 34.068832, 30.607325, 29.413311, 30.532202, 30.318787], [32.60606, 25.885468, 33.127615, 33.713661, 31.726036, 31.823991, 32.649191, 30.652817, 30.046183, 37.428624, 29.665286, 38.247098, 33.328042, 35.135827, 34.260634, 28.044284, 36.702605, 33.427365, 32.09166, 28.789384]]
 #Queen
 #aux_real = [[640.313059, 643.368851, 644.812491, 642.399734, 642.226814, 642.35475, 643.609192, 643.139744, 643.61705, 643.132647, 643.070286, 641.406328, 643.896836, 643.121044, 643.905589, 643.581402, 643.184715, 642.431289, 643.143977, 641.346561], [152.345899, 151.53339, 149.128109, 151.998913, 149.090488, 151.955341, 151.659499, 149.203061, 150.377392, 152.248175, 151.157503, 150.235083, 151.598016, 148.938792, 150.996531, 152.080666, 152.054726, 152.084692, 149.608602, 152.129981], [101.902944, 104.00788, 111.700969, 104.470693, 107.641521, 109.437217, 105.494903, 105.986737, 112.172214, 107.554958, 105.88158, 103.885249, 104.048641, 109.519779, 104.72926, 106.655908, 112.435562, 109.019183, 109.924859, 106.986846], [85.844223, 90.53081, 92.977514, 86.023776, 89.785998, 91.638115, 88.630006, 95.970387, 88.875131, 86.355962, 90.481832, 91.073597, 97.963737, 84.313078, 95.048194, 95.72992, 89.552759, 89.888328, 91.38958, 87.145446], [83.436137, 83.105543, 85.827104, 87.823647, 78.886258, 76.341861, 80.18113, 79.869432, 79.663487, 84.819399, 81.543829, 76.885674, 78.460587, 78.630554, 87.104227, 77.991342, 77.524938, 86.127078, 74.564246, 81.977689], [85.21399, 78.378531, 84.526313, 84.21782, 84.658752, 77.547238, 81.649375, 82.462926, 81.282893, 88.414904, 86.387445, 78.367787, 85.032026, 75.91001, 81.139097, 84.108863, 82.793723, 80.279569, 81.509798, 74.677693], [85.845828, 93.088063, 85.805088, 85.299568, 87.980509, 83.421145, 77.985249, 81.953544, 80.678587, 89.825371, 89.70287, 87.75817, 78.578479, 81.567104, 86.481628, 81.899106, 87.496995, 81.568352, 87.55542, 79.566851], [96.258907, 82.779222, 94.729087, 87.904027, 82.401901, 84.358796, 81.886275, 84.079098, 100.73735, 89.685091, 86.394575, 80.389717, 81.828049, 86.734577, 82.226097, 85.730868, 92.968317, 84.245582, 91.952588, 86.288488]]
 #aux_sint = [[641.085136, 641.141923, 640.777817, 641.301842, 640.976289, 641.020807, 640.8895, 641.161191, 641.071841, 641.100684, 641.182133, 641.304331, 641.05437, 641.227479, 641.203772, 641.015224, 640.991178, 641.13879, 641.230584, 640.926491], [147.558438, 151.115339, 150.933246, 151.395058, 151.546527, 150.531321, 150.06193, 150.472433, 150.003948, 149.91831, 150.517089, 150.229956, 150.597576, 150.082463, 150.86667, 150.090303, 150.422634, 150.671741, 150.672547, 150.238191], [108.25061, 111.097101, 104.213767, 110.52693, 112.378777, 119.460641, 112.216745, 104.715758, 108.586798, 118.500656, 111.702574, 107.967457, 110.703181, 110.870681, 113.971439, 114.412381, 108.385472, 108.404177, 107.221267, 107.396806], [96.21288, 88.36866, 85.354348, 87.616739, 89.807877, 90.15373, 88.666607, 91.701534, 89.501369, 95.262825, 87.00914, 96.041417, 94.04346, 84.264348, 86.212998, 86.943123, 90.104903, 89.290074, 104.344068, 88.445732], [79.012331, 76.963467, 93.635579, 79.515014, 82.320548, 74.996362, 78.712431, 72.23961, 77.006344, 90.117262, 79.983322, 85.569436, 88.489679, 75.017607, 84.355796, 80.785074, 83.582964, 75.955045, 74.408056, 76.856599], [86.036661, 90.114675, 81.199959, 92.82014, 91.197787, 84.41333, 82.947796, 77.121997, 86.190024, 78.995126, 81.440768, 84.931682, 84.696228, 88.9819, 67.965288, 90.338966, 79.17985, 82.231772, 84.687085, 75.87027], [94.179702, 98.994605, 93.155944, 102.084059, 90.722862, 102.024703, 97.968444, 101.484367, 85.187726, 87.207102, 86.122057, 76.514077, 95.983665, 100.865989, 98.479677, 105.413981, 106.241153, 106.36522, 83.973521, 80.865762], [98.877075, 86.054865, 109.090461, 100.612676, 90.638634, 83.918211, 100.890697, 98.085722, 95.14564, 100.055308, 93.566746, 111.359513, 107.407847, 101.431541, 112.982436, 100.120412, 95.134338, 96.016258, 91.694929, 93.917124]]
 #TEST Codigo sin captura de tiempos
 #Codigo sin captura
 #aux_sint = [[172.04165, 166.565937, 174.073495, 175.127555, 171.268598, 179.163764, 173.093602, 173.310969, 173.688159, 176.989948], [68.426733, 68.518644, 67.934562, 67.770617, 68.418071, 68.441444, 68.489923, 68.576862, 68.357891, 68.507931], [42.795763, 40.645969, 43.651983, 44.816286, 41.884911, 40.704261, 41.76031, 43.314722, 43.712624, 41.83065], [34.192324, 34.384576, 34.783733, 30.904571, 33.712345, 29.96747, 34.664818, 34.72399, 28.920618, 29.126176], [33.248177, 33.448689, 33.0446, 29.792059, 30.750121, 29.591303, 29.085716, 30.602103, 31.814472, 30.39379], [35.421251, 28.404227, 30.464738, 31.917447, 33.279842, 30.914243, 28.864047, 31.015124, 31.052509, 27.903691], [37.979388, 33.597368, 38.465519, 37.411409, 42.863337, 36.253646, 39.904695, 46.736134, 37.887813, 39.185104], []]
 #Codigo con captura
 #aux_real = [[172.23061, 172.274031, 172.224975, 172.199288, 172.142126, 172.133047, 172.262196, 172.206232, 172.197641, 172.201656], [67.729525, 68.280772, 68.348186, 68.354578, 68.405148, 68.548252, 68.404705, 68.461352, 68.347126, 68.37433], [48.270716, 43.616036, 42.091586, 41.417283, 42.089665, 41.92953, 42.563296, 41.799318, 40.910303, 45.403695], [34.600393, 31.826466, 32.053285, 30.025669, 30.139128, 32.118884, 35.913205, 33.58797, 31.433738, 30.869531], [36.761911, 27.334207, 32.128742, 27.013322, 24.008163, 29.872332, 28.812638, 31.073714, 30.33739, 30.352381], [29.629487, 25.729118, 29.081673, 29.723521, 29.247765, 35.299698, 31.711029, 31.346167, 30.085182, 27.99439], [42.031709, 41.964477, 33.98214, 37.872788, 34.108217, 37.903346, 41.666486, 37.516745, 39.800734, 35.537407], []]
 ```
 %% Cell type:code id: tags:
 ``` python
 #TODO Guardar funcion como comparacion de dos datos
 normality = [True]*len(processes)
 variance = [True]*len(processes)
 results = [True]*len(processes)
 # Check for assumption of normality
 for i in range(len(processes)):
     if(processes[i] in removed):
         continue
     st,p = stats.shapiro(aux_real[i])
     if p < p_value:
         normality[i]=False
         continue
     st,p = stats.shapiro(aux_sint[i])
     if p < p_value:
         normality[i]=False
 # Check for assumption of homoestacity
 if True in normality: # Only needed for normal distributions
     for i in range(len(processes)):
         if(processes[i] in removed):
             continue
         st,p = stats.bartlett(aux_real[i],aux_sint[i])
         if p < p_value:
             variance[i] = False
 # Check if groups are equal (True) or not (False)
 for i in range(len(processes)):
     if(processes[i] in removed):
         continue
     if normality[i]:
         st,p = stats.ttest_ind(aux_real[i], aux_sint[i], equal_var=variance[i])
     else:
         st,p = stats.mannwhitneyu(aux_real[i], aux_sint[i])
     if p < p_value:
         results[i]=False
 for i in range(len(processes)):
     if(processes[i] in removed):
         continue
     print("Para "+str(processes[i])+" los grupos son =="+str(results[i])+"== Normal-->"+str(normality[i])+"<-- Varianza-->"+str(variance[i])+"<--" )
 ```
 %%%% Output: error
     ---------------------------------------------------------------------------
     ValueError                                Traceback (most recent call last)
     /tmp/ipykernel_4596/811272121.py in <module>
          33         st,p = stats.ttest_ind(aux_real[i], aux_sint[i], equal_var=variance[i])
          34     else:
     ---> 35         st,p = stats.mannwhitneyu(aux_real[i], aux_sint[i])
          36     if p < p_value:
          37         results[i]=False
     ~/miniconda3/lib/python3.9/site-packages/scipy/stats/_mannwhitneyu.py in mannwhitneyu(x, y, use_continuity, alternative, axis, method)
         389
         390     x, y, use_continuity, alternative, axis_int, method = (
     --> 391         _mwu_input_validation(x, y, use_continuity, alternative, axis, method))
         392
         393     x, y, xy = _broadcast_concatenate(x, y, axis)
     ~/miniconda3/lib/python3.9/site-packages/scipy/stats/_mannwhitneyu.py in _mwu_input_validation(x, y, use_continuity, alternative, axis, method)
         133         raise ValueError('`x` and `y` must not contain NaNs.')
         134     if np.size(x) == 0 or np.size(y) == 0:
     --> 135         raise ValueError('`x` and `y` must be of nonzero size.')
         136
         137     bools = {True, False}
     ValueError: `x` and `y` must be of nonzero size.
 %% Cell type:code id: tags:
 ``` python
 processes = [2,10,20,40,80,120,160]
 aux_cores = 20
 title_y="Growth rate(%)"
 title_x="Number of Nodes"
 aux_labels = ['System_1 - Audik', 'System_1 - Queen', 'System_2 - Audik', 'System_2 - Queen', 'System_3 - Audik', 'System_3 - Queen']
 #aux_labels = ['System_1', 'System_2', 'System_3']
 data1 = [100.22, 100.82, 99.51, 101.39, 101.10, 100.20, 102.80]
 data2 = [99.88, 100.78, 99.18, 100.54, 102.30, 103.14, 101.42]
 data3 = [100.14, 100.37, 100.78, 102.55, 108.96, 110.18, 102.91]
 data4 = [100.06, 100.16, 101.13, 101.99, 102.44, 104.88, 102.65]
 data5 = [100.38, 101.55, 101.46, 103.42, 102.44, 101.02, 114.71]
 data6 = [100.03, 100.97, 101.01, 100.57, 101.28, 102.05, 101.09]
 data_x = [data1, data2, data3, data4, data5, data6]
 #data_x = [data2, data4, data6]
 style_aux=0
 nodes = []
 for i in range(len(processes)):
     nodes.append(processes[i]/aux_cores)
 f=plt.figure(figsize=(15, 8))
 ax=f.add_subplot(111)
 for i in range(len(data_x)):
     ax.plot(nodes, data_x[i], color=colors_spawn[i], linestyle=linestyle_spawn[i%4], \
                 marker=markers_spawn[i], markersize=18, label=aux_labels[i])
 ax.axhline((100), color='black')
 ax.set_ylabel(title_y, fontsize=34)
 ax.set_xlabel(title_x, fontsize=32)
 ax.tick_params(axis='both', which='major', labelsize=34)
 ax.tick_params(axis='both', which='minor', labelsize=32)
 plt.legend(loc='best', fontsize=26)
 f.tight_layout()
 ax.set_ylim(95,120)
 f.savefig("Images/malleabilityTest.png", format="png")
 ```
 %%%% Output: display_data
     [Hidden Image Output]
 %% Cell type:code id: tags:
 ``` python
 processes = [2,10,20,40,80,120,160]
 aux_cores = 20
 title_y="Growth rate(%)"
 title_x="Number of Nodes"
 aux_labels = ['System_1 - 100Kb', 'System_1 - 10Mb', 'System_1 - 1Gb', 'System_2 - 100Kb', 'System_2 - 10Mb', 'System_2 - 1Gb', 'System_3 - 100Kb', 'System_3 - 10Mb', 'System_3 - 1Gb']
 data1 = [105.60, 115.34, 80.08, 84.10, 94.10, 73.12, 93.98]
 data2 = [97.37, 104.83, 98.73, 98.90, 94.63, 95.37, 98.02]
 data3 = [98.55, 97.01, 97.88, 99.05, 102.10, 98.74, 97.85]
 data4 = [113.15, 105.19, 101.15, 101.55, 80.81, 74.24, 78.54]
 data5 = [100.60, 99.13, 99.95, 96.98, 106.92, 84.42, 89.66]
 data6 = [98.88, 100.26, 100.05, 117.63, 103.59, 100.41, 106.25]
 data7 = [111.45, 103.65, 104.15, 103.38, 35.09, 101.37, 101.45]
 data8 = [101.44, 99.65, 99.24, 100.66, 105.61, 101.14, 101.67]
 data9 = [101.07, 99.99, 102.25, 100.46, 100.91, 100.53, 102.18]
 error1 = [1.51E-01, 2.09E-01, 4.80E-01, 3.93E-01, 2.68E-01, 1.45E-01, 2.35E-01]
 error2 = [1.86E-02, 6.31E-02, 7.68E-02, 1.10E-01, 8.33E-02, 5.99E-02, 6.94E-02]
 error3 = [1.83E-02, 8.26E-02, 3.11E-02, 2.86E-02, 4.14E-02, 3.26E-02, 3.73E-02]
 error4 = [2.23E-02, 6.10E-03, 4.08E-03, 6.32E-03, 4.99E-02, 9.55E-02, 1.01E-01]
 error5 = [1.21E-02, 1.61E-02, 8.52E-03, 3.12E-02, 1.15E-01, 5.49E-02, 4.70E-02]
 error6 = [2.46E-02, 5.21E-03, 1.34E-03, 1.16E-01, 6.07E-02, 1.12E-02, 7.64E-02]
 error7 = [3.71E-02, 3.67E-03, 3.89E-03, 3.48E-02, 3.76E-03, 1.03E-02, 7.90E-03]
 error8 = [1.79E-02, 5.02E-03, 6.63E-03, 2.94E-03, 5.25E-02, 1.67E-02, 8.36E-03]
 error9 = [7.47E-03, 2.25E-03, 1.64E-02, 5.94E-03, 2.85E-02, 3.22E-03, 2.54E-02]
 #data_x = [data1, data2, data3, data4, data5, data6, data7, data8, data9]
 #error_x = [error1, error2, error3, error4, error5, error6, error7, error8, error9]
 data_x = [data1, data4, data7]
 error_x = [error1, error2, error3]
 aux_labels = ['System_1 - 100Kb', 'System_2 - 100Kb', 'System_3 - 100Kb']
 #data_x = [data2, data5, data8]
 #error_x = [error4, error5, error6]
 #aux_labels = ['System_1 - 10Mb', 'System_2 - 10Mb', 'System_3 - 10Mb']
 #data_x = [data3, data6, data9]
 #error_x = [error7, error8, error9]
 #aux_labels = ['System_1 - 1Gb', 'System_2 - 1Gb', 'System_3 - 1Gb']
 style_aux=0
 nodes = []
 for i in range(len(processes)):
     nodes.append(processes[i]/aux_cores)
 f=plt.figure(figsize=(12, 10))
 ax=f.add_subplot(111)
 for i in range(len(data_x)):
     ax.errorbar(nodes, data_x[i], color=colors_spawn[i%9], linestyle=linestyle_spawn[i%4], \
                 marker=markers_spawn[i%9], markersize=18, label=aux_labels[i])
     #ax.errorbar(nodes, data_x[i], yerr=error_x[i], color=colors_spawn[i%8], linestyle=linestyle_spawn[i%4], \
     #            marker=markers_spawn[i%8], markersize=18, label=aux_labels[i])
     #ax.errorbar(nodes, data_x[i], yerr=error_x[i], color=colors_spawn[i%8], linestyle=linestyle_spawn[i%4], \
      #           label=aux_labels[i])
 ax.axhline((100), color='black')
 ax.set_ylabel(title_y, fontsize=34)
 ax.set_xlabel(title_x, fontsize=32)
 ax.tick_params(axis='both', which='major', labelsize=32)
 ax.tick_params(axis='both', which='minor', labelsize=30)
 plt.legend(loc='best', fontsize=26)
 f.tight_layout()
 ax.set_ylim(70,120)
 f.savefig("Images/malleabilityTest.png", format="png")
 ```
 %%%% Output: display_data
     [Hidden Image Output]
 %% Cell type:code id: tags:
 ``` python
 processes = [2,10,20,40,80,120,160]
 aux_cores = 20
 title_y="Growth rate(%)"
 title_x="Number of Nodes"
 aux_labels = ['System_1 - Audik', 'System_1 - Queen', 'System_2 - Audik', 'System_2 - Queen', 'System_3 - Audik', 'System_3 - Queen']
 data1 = [99.60, 100.38, 104.60, 111.05, 132.55, 131.33, 150.13]
 data2 = [99.57, 99.63, 101.22, 106.77, 112.37, 114.37, 125.83]
 data3 = [100.22, 100.47, 101.59, 105.68, 115.49, 118.51, 110.06]
 data4 = [100.32, 100.49, 100.67, 104.42, 112.88, 116.31, 116.04]
 data5 = [100.31, 102.19, 101.88, 108.02, 106.44, 104.87, 111.85]
 data5 = [99.85, 98.70, 97.80, 110.26, 109.10, 111.28, 107.41]
 data_x = [data1, data2, data3, data4, data5, data6]
 style_aux=0
 nodes = []
 for i in range(len(processes)):
     nodes.append(processes[i]/aux_cores)
 f=plt.figure(figsize=(15, 8))
 ax=f.add_subplot(111)
 for i in range(len(data_x)):
     ax.plot(nodes, data_x[i], color=colors_spawn[i], linestyle=linestyle_spawn[i%4], \
                 marker=markers_spawn[i], markersize=18, label=aux_labels[i])
 ax.axhline((100), color='black')
 ax.set_ylabel(title_y, fontsize=34)
 ax.set_xlabel(title_x, fontsize=32)
 ax.tick_params(axis='both', which='major', labelsize=34)
 ax.tick_params(axis='both', which='minor', labelsize=32)
 plt.legend(loc='best', fontsize=26)
 f.tight_layout()
 ax.set_ylim(90,160)
 f.savefig("Images/malleabilityTest.png", format="png")
 ```
 %%%% Output: display_data
     [Hidden Image Output]
 %% Cell type:code id: tags:
 ``` python
 ```