--- ADD_ver_10/Attic/CalculosMatrices.c	2006/01/19 17:16:29	1.1
+++ ADD_ver_10/Attic/CalculosMatrices.c	2006/02/15 13:00:30	1.2
@@ -1,36 +1,3 @@
-/********************************************************************/
-/*  CalculosMatrices.h                                              */
-/*                                                                  */
-/*  Copyright (c) 1997-2006 Rafael Rico      (rafael.rico@uah.es)   */
-/*                                                                  */
-/*  This file is part of ADD version 5.10.                          */
-/*                                                                  */
-/*  ADD is free software; you can redistribute it and/or modify     */
-/*  it under the terms of the GNU General Public License as         */
-/*  published by the Free Software Foundation; either version 2 of  */
-/*  the License, or (at your option) any later version.             */
-/*                                                                  */
-/*  ADD is distributed in the hope that it will be useful,          */
-/*  but WITHOUT ANY WARRANTY; without even the implied warranty of  */
-/*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the   */
-/*  GNU General Public License for more details.                    */
-/*                                                                  */
-/*  You should have received a copy of the GNU General Public       */
-/*  License along with ADD; if not, write to the Free Software      */
-/*  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA        */
-/*  02111-1307  USA                                                 */
-/*                                                                  */
-/*  --------------------------- History --------------------------- */
-/*                                                                  */
-/*  Revision 1.2. 01/2006                                           */
-/*  Added GPL License and JavaDoc style documentation               */
-/*                                                                  */
-/*  Revision 1.1. 09/2005                                           */
-/*  Initial Revision                                                */
-/*                                                                  */
-/********************************************************************/
-
-
 /******************************************************************************/
 /* MÓDULO: CalculosMatrices.c                                                 */
 /*                                                                            */
@@ -78,115 +45,115 @@ extern unsigned long *distribucionpasos;
 
 unsigned int CalcularMatrizCaminos(unsigned char **D, unsigned char **C)
 {
-	char mensaje[MAX_LINE];
-	unsigned char *v;		/* vector temporal */
-	unsigned char **tmp;	/* matriz temporal */
-
-	unsigned int i, j, k, potencia;
-	unsigned int suma;
-	unsigned char matriz_nula;
-
-
-	if(D == NULL)
-	{
-		sprintf(mensaje, "[CalcularMatrizCaminos] La matriz D indicada no existe");
-		Notificar(mensaje, ERROR_SALIR, ECO_NO);
-	}
-
-	/* necesito un vector y una matriz temporal de 'unsigned char' */
-	/* para calcular las sucesivas potencias de la matriz D */
-
-	/* hago la reserva de memoria para el vector */
-	v = calloc(configuracion.ventana , sizeof(unsigned char *));
-	if (v == NULL)
-	{
-		sprintf(mensaje, "[CalcularMatrizCaminos] Memoria insuficiente");
-		Notificar(mensaje, ERROR_SALIR, ECO_NO);
-		/* el programa finaliza si no hay memoria suficiente */
-	}
-
-	/* hago la reserva de memoria para la matriz */
-	/* 1º un puntero por cada fila */
-	tmp = calloc(configuracion.ventana , sizeof(unsigned char *));
-	if (tmp == NULL)
-	{
-		sprintf(mensaje, "[CalcularMatrizCaminos] Memoria insuficiente");
-		Notificar(mensaje, ERROR_SALIR, ECO_NO);
-		/* el programa finaliza si no hay memoria suficiente */
-	}
-	/* 2º un 'char' por cada columna */
-	for(i=0; i<configuracion.ventana; i++)
-	{
-		tmp[i] = calloc(configuracion.ventana, sizeof(unsigned char));
-		if (tmp[i] == NULL)
-		{
-			sprintf(mensaje, "[CalcularMatrizCaminos] Memoria insuficiente");
-			Notificar(mensaje, ERROR_SALIR, ECO_NO);
-			/* el programa finaliza si no hay memoria suficiente */
-		}
-	}
-
-
-	/* inicio la matriz temporal con la matriz 'identidad' (1s en la diagonal) */
-	/* al reservar con 'calloc' se rellena con 0s */
-
-	for(i=0; i<configuracion.ventana; i++) tmp[i][i] = 1;
-
-
-	/* calculo sucesivas potencias de la matriz 'D' hasta que se anule */
-	/* utilizo la expresión TMP * D = TMP */
-	/* el uso del vector me permite escribir el resultado sobre 'TMP' */
-	for(potencia=0; potencia<configuracion.ventana; potencia++)
-	{
-		for(i=0; i<configuracion.ventana; i++)
-		{
-          	for(k=0; k<configuracion.ventana; k++) v[k]=tmp[i][k];
-			for(j=0; j<configuracion.ventana; j++)
-			{
-				suma = 0;
-				for(k=0; k<configuracion.ventana; k++)
-				{
-					suma += v[k] * D[k][j];
-				}
-				tmp[i][j] = suma;
-			}
-		}
-
-		/* la matriz 'TMP' contiene la n-ésima+1 potencia de 'D' */
-
-		/* ahora evalúo si el resultado es la matriz nula */
-		/* si es así no tengo que continuar ya que no hay */
-		/* caminos de dependencias de longitud mayor */
-
-		matriz_nula = SI;
-		for(i=0; i<configuracion.ventana; i++)
-		{
-			for(j=0; j<configuracion.ventana; j++)
-			{
-				if(tmp[i][j] != 0) {matriz_nula = NO; break;}
-			}
-			if(matriz_nula == NO) break;
-		}
-		if(matriz_nula == SI) break;
-
-		/* sumo la nueva potencia de la matriz de dependencias D^^p */
-		/* a la matriz de caminos parcial 'C' si me han pasado un puntero no nulo */
-		if(*C != NULL)
-		{
-			for(i=0; i<configuracion.ventana; i++)
-			{
-				for(j=0; j<configuracion.ventana; j++) C[i][j] += tmp[i][j];
-			}
-		}
-	}
-
-	/* libero la memoria reservada anteriormente */
-	/* libero el vector */
-	free(v);
-	/* libero la matriz */
-	for(i=0; i<configuracion.ventana; i++) free(tmp[i]); free(tmp);
+    char mensaje[MAX_LINE];
+    unsigned char *v;        /* vector temporal */
+    unsigned char **tmp;    /* matriz temporal */
+
+    unsigned int i, j, k, potencia;
+    unsigned int suma;
+    unsigned char matriz_nula;
+
+
+    if(D == NULL)
+    {
+        sprintf(mensaje, "[CalcularMatrizCaminos] La matriz D indicada no existe");
+        Notificar(mensaje, ERROR_SALIR, ECO_NO);
+    }
+
+    /* necesito un vector y una matriz temporal de 'unsigned char' */
+    /* para calcular las sucesivas potencias de la matriz D */
 
-	return potencia+1;	/* devuelve el rango de la primera potencia nula de 'D' */
+    /* hago la reserva de memoria para el vector */
+    v = calloc(configuracion.ventana , sizeof(unsigned char *));
+    if (v == NULL)
+    {
+        sprintf(mensaje, "[CalcularMatrizCaminos] Memoria insuficiente");
+        Notificar(mensaje, ERROR_SALIR, ECO_NO);
+        /* el programa finaliza si no hay memoria suficiente */
+    }
+
+    /* hago la reserva de memoria para la matriz */
+    /* 1º un puntero por cada fila */
+    tmp = calloc(configuracion.ventana , sizeof(unsigned char *));
+    if (tmp == NULL)
+    {
+        sprintf(mensaje, "[CalcularMatrizCaminos] Memoria insuficiente");
+        Notificar(mensaje, ERROR_SALIR, ECO_NO);
+        /* el programa finaliza si no hay memoria suficiente */
+    }
+    /* 2º un 'char' por cada columna */
+    for(i=0; i<configuracion.ventana; i++)
+    {
+        tmp[i] = calloc(configuracion.ventana, sizeof(unsigned char));
+        if (tmp[i] == NULL)
+        {
+            sprintf(mensaje, "[CalcularMatrizCaminos] Memoria insuficiente");
+            Notificar(mensaje, ERROR_SALIR, ECO_NO);
+            /* el programa finaliza si no hay memoria suficiente */
+        }
+    }
+
+
+    /* inicio la matriz temporal con la matriz 'identidad' (1s en la diagonal) */
+    /* al reservar con 'calloc' se rellena con 0s */
+
+    for(i=0; i<configuracion.ventana; i++) tmp[i][i] = 1;
+
+
+    /* calculo sucesivas potencias de la matriz 'D' hasta que se anule */
+    /* utilizo la expresión TMP * D = TMP */
+    /* el uso del vector me permite escribir el resultado sobre 'TMP' */
+    for(potencia=0; potencia<configuracion.ventana; potencia++)
+    {
+        for(i=0; i<configuracion.ventana; i++)
+        {
+              for(k=0; k<configuracion.ventana; k++) v[k]=tmp[i][k];
+            for(j=0; j<configuracion.ventana; j++)
+            {
+                suma = 0;
+                for(k=0; k<configuracion.ventana; k++)
+                {
+                    suma += v[k] * D[k][j];
+                }
+                tmp[i][j] = suma;
+            }
+        }
+
+        /* la matriz 'TMP' contiene la n-ésima+1 potencia de 'D' */
+
+        /* ahora evalúo si el resultado es la matriz nula */
+        /* si es así no tengo que continuar ya que no hay */
+        /* caminos de dependencias de longitud mayor */
+
+        matriz_nula = SI;
+        for(i=0; i<configuracion.ventana; i++)
+        {
+            for(j=0; j<configuracion.ventana; j++)
+            {
+                if(tmp[i][j] != 0) {matriz_nula = NO; break;}
+            }
+            if(matriz_nula == NO) break;
+        }
+        if(matriz_nula == SI) break;
+
+        /* sumo la nueva potencia de la matriz de dependencias D^^p */
+        /* a la matriz de caminos parcial 'C' si me han pasado un puntero no nulo */
+        if(*C != NULL)
+        {
+            for(i=0; i<configuracion.ventana; i++)
+            {
+                for(j=0; j<configuracion.ventana; j++) C[i][j] += tmp[i][j];
+            }
+        }
+    }
+
+    /* libero la memoria reservada anteriormente */
+    /* libero el vector */
+    free(v);
+    /* libero la matriz */
+    for(i=0; i<configuracion.ventana; i++) free(tmp[i]); free(tmp);
+
+    return potencia+1;    /* devuelve el rango de la primera potencia nula de 'D' */
 }
 
 
@@ -198,131 +165,131 @@ unsigned int CalcularMatrizCaminos(unsig
 
 unsigned int ListaOrdenParcial(unsigned char **D, char **lista)
 {
-	char mensaje[MAX_LINE];
-	unsigned char *lanzadas;	/* vector de instrucciones lanzadas */
-	unsigned char **tmp;		/* matriz temporal */
+    char mensaje[MAX_LINE];
+    unsigned char *lanzadas;    /* vector de instrucciones lanzadas */
+    unsigned char **tmp;        /* matriz temporal */
 
     unsigned int pasos, procesadas;
     unsigned int i, j;
-	char cadena[6];		/* cadena para pasar enteros a strings */
+    char cadena[6];        /* cadena para pasar enteros a strings */
 
 
-	if(D == NULL)
-	{
-		sprintf(mensaje, "[ListaOrdenParcial] La matriz D indicada no existe");
-		Notificar(mensaje, ERROR_SALIR, ECO_NO);
-	}
-
-	/* necesito un vector y una matriz temporal de 'unsigned char' */
-	/* para calcular las sucesivas potencias de la matriz D */
-
-	/* hago la reserva de memoria para el vector */
-	lanzadas = calloc(configuracion.ventana , sizeof(unsigned char *));
-	if (lanzadas == NULL)
-	{
-		sprintf(mensaje, "[ListaOrdenParcial] Memoria insuficiente");
-		Notificar(mensaje, ERROR_SALIR, ECO_NO);
-		/* el programa finaliza si no hay memoria suficiente */
-	}
-
-	/* hago la reserva de memoria para la matriz */
-	/* 1º un puntero por cada fila */
-	tmp = calloc(configuracion.ventana , sizeof(unsigned char *));
-	if (tmp == NULL)
-	{
-		sprintf(mensaje, "[ListaOrdenParcial] Memoria insuficiente");
-		Notificar(mensaje, ERROR_SALIR, ECO_NO);
-		/* el programa finaliza si no hay memoria suficiente */
-	}
-	/* 2º un 'char' por cada columna */
-	for(i=0; i<configuracion.ventana; i++)
-	{
-		tmp[i] = calloc(configuracion.ventana, sizeof(unsigned char));
-		if (tmp[i] == NULL)
-		{
-			sprintf(mensaje, "[ListaOrdenParcial] Memoria insuficiente");
-			Notificar(mensaje, ERROR_SALIR, ECO_NO);
-			/* el programa finaliza si no hay memoria suficiente */
-		}
-	}
-
-	/* copio la matriz de dependencias D sobre la temporal */
-	for(i=0; i<configuracion.ventana; i++)
-	{
-		for(j=0; j<configuracion.ventana; j++) tmp[i][j] = D[i][j];
-	}
-	
-	/* pongo a cero el vector de lanzadas */
-	for(i=0; i<configuracion.ventana; i++) lanzadas[i] = 0;
+    if(D == NULL)
+    {
+        sprintf(mensaje, "[ListaOrdenParcial] La matriz D indicada no existe");
+        Notificar(mensaje, ERROR_SALIR, ECO_NO);
+    }
 
-	/* inicio el contador de pasos de computaci¢n */
-	pasos = 0;
+    /* necesito un vector y una matriz temporal de 'unsigned char' */
+    /* para calcular las sucesivas potencias de la matriz D */
+
+    /* hago la reserva de memoria para el vector */
+    lanzadas = calloc(configuracion.ventana , sizeof(unsigned char *));
+    if (lanzadas == NULL)
+    {
+        sprintf(mensaje, "[ListaOrdenParcial] Memoria insuficiente");
+        Notificar(mensaje, ERROR_SALIR, ECO_NO);
+        /* el programa finaliza si no hay memoria suficiente */
+    }
 
-	/* inicio el contador de instrucciones procesadas */
+    /* hago la reserva de memoria para la matriz */
+    /* 1º un puntero por cada fila */
+    tmp = calloc(configuracion.ventana , sizeof(unsigned char *));
+    if (tmp == NULL)
+    {
+        sprintf(mensaje, "[ListaOrdenParcial] Memoria insuficiente");
+        Notificar(mensaje, ERROR_SALIR, ECO_NO);
+        /* el programa finaliza si no hay memoria suficiente */
+    }
+    /* 2º un 'char' por cada columna */
+    for(i=0; i<configuracion.ventana; i++)
+    {
+        tmp[i] = calloc(configuracion.ventana, sizeof(unsigned char));
+        if (tmp[i] == NULL)
+        {
+            sprintf(mensaje, "[ListaOrdenParcial] Memoria insuficiente");
+            Notificar(mensaje, ERROR_SALIR, ECO_NO);
+            /* el programa finaliza si no hay memoria suficiente */
+        }
+    }
+
+    /* copio la matriz de dependencias D sobre la temporal */
+    for(i=0; i<configuracion.ventana; i++)
+    {
+        for(j=0; j<configuracion.ventana; j++) tmp[i][j] = D[i][j];
+    }
+    
+    /* pongo a cero el vector de lanzadas */
+    for(i=0; i<configuracion.ventana; i++) lanzadas[i] = 0;
+
+    /* inicio el contador de pasos de computaci¢n */
+    pasos = 0;
+
+    /* inicio el contador de instrucciones procesadas */
     procesadas = 0;
 
 
-	while(configuracion.ventana - procesadas)
-	{
-		pasos++;
-
-		/* busco tareas independientes entre las NO lanzadas */
-		for(i=0; i<configuracion.ventana; i++)
-		{
-			if(lanzadas[i]==0)	/* si es 0 significa que no se ha lanzado */
-			{
-               	/* miro si el vector de dependencias es nulo */
-				for(j=0; j<i; j++)
-				{
-					if(tmp[i][j]!=0) break;
-				}
-				if(j==i)
-				{
-					lanzadas[i]=1; /* la instrucci¢n es independiente */
-
-					/* anoto la instrucción en la lista del orden parcial */
-					/* en el paso de computación en curso */
-					if(lista != NULL)
-					{
-						sprintf(cadena, "%u", i);
-						AgregarElementoLista(lista[pasos-1], cadena);
-					}
-				}
-			}
-		}
-
-		/* ahora actualizo la matriz de dependencias con la lista de */
-		/* instrucciones independientes que han sido lanzadas */
-
-		for(i=0; i<configuracion.ventana; i++)
-		{
-			if(lanzadas[i]==1)	/* si es 1 significa que es independiente */
-			{
-				for(j=i+1; j<configuracion.ventana; j++)
-				{
-					if(tmp[j][i]!=0) tmp[j][i]=0;
-				}
-			}
-		}
-
-		/* ahora actualizo el vector de lanzadas */
-		for(i=0; i<configuracion.ventana; i++)
-		{
-			if(lanzadas[i]==1)
-			{
-				lanzadas[i]=2; /* significa que ha sido procesada */
-               	procesadas++;
-			}
-		}
-	}
-
-	/* libero la memoria reservada anteriormente */
-	/* libero el vector */
-	free(lanzadas);
-	/* libero la matriz */
-	for(i=0; i<configuracion.ventana; i++) free(tmp[i]); free(tmp);
+    while(configuracion.ventana - procesadas)
+    {
+        pasos++;
 
-	return pasos;
+        /* busco tareas independientes entre las NO lanzadas */
+        for(i=0; i<configuracion.ventana; i++)
+        {
+            if(lanzadas[i]==0)    /* si es 0 significa que no se ha lanzado */
+            {
+                   /* miro si el vector de dependencias es nulo */
+                for(j=0; j<i; j++)
+                {
+                    if(tmp[i][j]!=0) break;
+                }
+                if(j==i)
+                {
+                    lanzadas[i]=1; /* la instrucci¢n es independiente */
+
+                    /* anoto la instrucción en la lista del orden parcial */
+                    /* en el paso de computación en curso */
+                    if(lista != NULL)
+                    {
+                        sprintf(cadena, "%u", i);
+                        AgregarElementoLista(lista[pasos-1], cadena);
+                    }
+                }
+            }
+        }
+
+        /* ahora actualizo la matriz de dependencias con la lista de */
+        /* instrucciones independientes que han sido lanzadas */
+
+        for(i=0; i<configuracion.ventana; i++)
+        {
+            if(lanzadas[i]==1)    /* si es 1 significa que es independiente */
+            {
+                for(j=i+1; j<configuracion.ventana; j++)
+                {
+                    if(tmp[j][i]!=0) tmp[j][i]=0;
+                }
+            }
+        }
+
+        /* ahora actualizo el vector de lanzadas */
+        for(i=0; i<configuracion.ventana; i++)
+        {
+            if(lanzadas[i]==1)
+            {
+                lanzadas[i]=2; /* significa que ha sido procesada */
+                   procesadas++;
+            }
+        }
+    }
+
+    /* libero la memoria reservada anteriormente */
+    /* libero el vector */
+    free(lanzadas);
+    /* libero la matriz */
+    for(i=0; i<configuracion.ventana; i++) free(tmp[i]); free(tmp);
+
+    return pasos;
 }
 
 
@@ -330,26 +297,26 @@ unsigned int ListaOrdenParcial(unsigned
 
 unsigned int Acoplamiento(unsigned char **D)
 {
-	char mensaje[MAX_LINE];
-	unsigned int i, j;
-	unsigned int acoplo = 0;
-
-	if(D == NULL)
-	{
-		sprintf(mensaje, "[Acoplamiento] La matriz D indicada no existe");
-		Notificar(mensaje, ERROR_SALIR, ECO_NO);
-	}
-
-	/* puesto que las matrices se obtienen de la secuencia de código */
-	/* estamos seguros de que son canónicas y, por tanto, no es necesario */
-	/* hacer el recorrido completo de todas sus componentes */
-	/* basta con empezar en la instrucción 1 y recorres columnas hasta la diagonal */
-	for(i=1; i<configuracion.ventana; i++)
-	{
-		for(j=0; j<i; j++) if(D[i][j] != 0) acoplo++;
-	}
+    char mensaje[MAX_LINE];
+    unsigned int i, j;
+    unsigned int acoplo = 0;
 
-	return acoplo;
+    if(D == NULL)
+    {
+        sprintf(mensaje, "[Acoplamiento] La matriz D indicada no existe");
+        Notificar(mensaje, ERROR_SALIR, ECO_NO);
+    }
+
+    /* puesto que las matrices se obtienen de la secuencia de código */
+    /* estamos seguros de que son canónicas y, por tanto, no es necesario */
+    /* hacer el recorrido completo de todas sus componentes */
+    /* basta con empezar en la instrucción 1 y recorres columnas hasta la diagonal */
+    for(i=1; i<configuracion.ventana; i++)
+    {
+        for(j=0; j<i; j++) if(D[i][j] != 0) acoplo++;
+    }
+
+    return acoplo;
 }
 
 
@@ -363,30 +330,30 @@ unsigned int Acoplamiento(unsigned char
 
 char ** CrearArrayStrings(unsigned int num_cadenas, unsigned int tamano)
 {
-	char mensaje[MAX_LINE];
-	unsigned int i;
-	char **listado;
-
-	/* 1º un puntero por cada fila */
-	listado = calloc(num_cadenas, sizeof(char *));
-	if (listado == NULL)
-	{
-		sprintf(mensaje, "[CrearArrayStrings] Memoria insuficiente");
-		Notificar(mensaje, ERROR_SALIR, ECO_NO);
-		/* el programa finaliza si no hay memoria suficiente */
-	}
-	/* 2º cuatro 'char' por cada columna (3 caracteres de número y un separador ':') */
-	for(i=0; i<configuracion.ventana; i++)
-	{
-		listado[i] = calloc(tamano, sizeof(char));
-		if (listado[i] == NULL)
-		{
-			sprintf(mensaje, "[CrearArrayStrings] Memoria insuficiente");
-			Notificar(mensaje, ERROR_SALIR, ECO_NO);
-			/* el programa finaliza si no hay memoria suficiente */
-		}
-	}
-	return listado;
+    char mensaje[MAX_LINE];
+    unsigned int i;
+    char **listado;
+
+    /* 1º un puntero por cada fila */
+    listado = calloc(num_cadenas, sizeof(char *));
+    if (listado == NULL)
+    {
+        sprintf(mensaje, "[CrearArrayStrings] Memoria insuficiente");
+        Notificar(mensaje, ERROR_SALIR, ECO_NO);
+        /* el programa finaliza si no hay memoria suficiente */
+    }
+    /* 2º cuatro 'char' por cada columna (3 caracteres de número y un separador ':') */
+    for(i=0; i<configuracion.ventana; i++)
+    {
+        listado[i] = calloc(tamano, sizeof(char));
+        if (listado[i] == NULL)
+        {
+            sprintf(mensaje, "[CrearArrayStrings] Memoria insuficiente");
+            Notificar(mensaje, ERROR_SALIR, ECO_NO);
+            /* el programa finaliza si no hay memoria suficiente */
+        }
+    }
+    return listado;
 }
 
 
@@ -397,11 +364,11 @@ char ** CrearArrayStrings(unsigned int n
 
 void CrearListaOrdenParcial()
 {
-	unsigned int dim;
+    unsigned int dim;
 
-	dim = configuracion.ventana;
+    dim = configuracion.ventana;
 
-	OrdenParcial = CrearArrayStrings(dim, 4*dim);
+    OrdenParcial = CrearArrayStrings(dim, 4*dim);
 }
 
 
@@ -409,11 +376,11 @@ void CrearListaOrdenParcial()
 
 void IniciarListaOrdenParcial()
 {
-	unsigned int i, dim;
+    unsigned int i, dim;
 
-	dim = configuracion.ventana;
-	
-	if(OrdenParcial != NULL) for(i=0; i<dim; i++) *OrdenParcial[i] = '\0'; 
+    dim = configuracion.ventana;
+    
+    if(OrdenParcial != NULL) for(i=0; i<dim; i++) *OrdenParcial[i] = '\0'; 
 }
 
 
@@ -421,18 +388,18 @@ void IniciarListaOrdenParcial()
 
 void LiberarMemoriaListaOrdenParcial()
 {
-	unsigned int i,dim;
+    unsigned int i,dim;
 
-	dim = configuracion.ventana;
+    dim = configuracion.ventana;
 
-	if(OrdenParcial != NULL)
-	{
-		for(i=0; i<dim; i++)
-		{
-			free(OrdenParcial[i]); 
-		}
-		free(OrdenParcial);
-	}
+    if(OrdenParcial != NULL)
+    {
+        for(i=0; i<dim; i++)
+        {
+            free(OrdenParcial[i]); 
+        }
+        free(OrdenParcial);
+    }
 }
 
 
@@ -440,7 +407,7 @@ void LiberarMemoriaListaOrdenParcial()
 
 void CrearMatrizCaminos()
 {
-	matrizC = CrearMatriz();
+    matrizC = CrearMatriz();
 }
 
 
@@ -448,7 +415,7 @@ void CrearMatrizCaminos()
 
 void IniciarMatrizCaminos()
 {
-	IniciarMatriz(matrizC);
+    IniciarMatriz(matrizC);
 }
 
 
@@ -456,7 +423,7 @@ void IniciarMatrizCaminos()
 
 void LiberarMemoriaMatrizCaminos()
 {
-	LiberarMemoriaMatriz(matrizC);
+    LiberarMemoriaMatriz(matrizC);
 }
 
 
@@ -464,18 +431,18 @@ void LiberarMemoriaMatrizCaminos()
 
 parametromatriz * CrearVariableAgregada()
 {
-	char mensaje[MAX_LINE];
-	parametromatriz *variable;
-	
-	variable = calloc(1, sizeof(parametromatriz));
-	if (variable == NULL)
-	{
-		sprintf(mensaje, "[CrearVariableAgragada] Memoria insuficiente");
-		Notificar(mensaje, ERROR_SALIR, ECO_NO);
-		/* el programa finaliza si no hay memoria suficiente */
-	}
+    char mensaje[MAX_LINE];
+    parametromatriz *variable;
+    
+    variable = calloc(1, sizeof(parametromatriz));
+    if (variable == NULL)
+    {
+        sprintf(mensaje, "[CrearVariableAgragada] Memoria insuficiente");
+        Notificar(mensaje, ERROR_SALIR, ECO_NO);
+        /* el programa finaliza si no hay memoria suficiente */
+    }
 
-	return variable;
+    return variable;
 }
 
 
@@ -483,37 +450,37 @@ parametromatriz * CrearVariableAgregada(
 
 void IniciarVariableAgregada(parametromatriz *variable)
 {
-	variable->Ddatoexp = 0.0;
-	variable->Ddir_exp = 0.0;
-	variable->Dpilaexp = 0.0; 
-	variable->Destadoexp = 0.0; 
-		
-	variable->Ddatoimp = 0.0; 
-	variable->Ddir_imp = 0.0; 
-	variable->Dpilaimp = 0.0; 
-	variable->Destadoimp = 0.0; 
-
-	variable->ADdatoexp = 0.0; 
-	variable->ADdir_exp = 0.0; 
-	variable->ADpilaexp = 0.0; 
-	variable->ADestadoexp = 0.0; 
-		
-	variable->ADdatoimp = 0.0; 
-	variable->ADdir_imp = 0.0; 
-	variable->ADpilaimp = 0.0; 
-	variable->ADestadoimp = 0.0; 
-
-	variable->Sdatoexp = 0.0; 
-	variable->Sdir_exp = 0.0; 
-	variable->Spilaexp = 0.0; 
-	variable->Sestadoexp = 0.0; 
-		
-	variable->Sdatoimp = 0.0; 
-	variable->Sdir_imp = 0.0; 
-	variable->Spilaimp = 0.0; 
-	variable->Sestadoimp = 0.0; 
+    variable->Ddatoexp = 0.0;
+    variable->Ddir_exp = 0.0;
+    variable->Dpilaexp = 0.0; 
+    variable->Destadoexp = 0.0; 
+        
+    variable->Ddatoimp = 0.0; 
+    variable->Ddir_imp = 0.0; 
+    variable->Dpilaimp = 0.0; 
+    variable->Destadoimp = 0.0; 
+
+    variable->ADdatoexp = 0.0; 
+    variable->ADdir_exp = 0.0; 
+    variable->ADpilaexp = 0.0; 
+    variable->ADestadoexp = 0.0; 
+        
+    variable->ADdatoimp = 0.0; 
+    variable->ADdir_imp = 0.0; 
+    variable->ADpilaimp = 0.0; 
+    variable->ADestadoimp = 0.0; 
+
+    variable->Sdatoexp = 0.0; 
+    variable->Sdir_exp = 0.0; 
+    variable->Spilaexp = 0.0; 
+    variable->Sestadoexp = 0.0; 
+        
+    variable->Sdatoimp = 0.0; 
+    variable->Sdir_imp = 0.0; 
+    variable->Spilaimp = 0.0; 
+    variable->Sestadoimp = 0.0; 
 
-	variable->D = 0.0; 
+    variable->D = 0.0; 
 }
 
 
@@ -524,37 +491,37 @@ void IniciarVariableAgregada(parametroma
 /*
 void CalcularPromedioVariableAgregada(parametromatriz *media, parametromatriz *actual, unsigned long n)
 {
-	if(matriz.Ddatoexp != NULL) media->Ddatoexp = ((n - 1) * media->Ddatoexp + actual->Ddatoexp) / n;
-	if(matriz.Ddir_exp != NULL) media->Ddir_exp = ((n - 1) * media->Ddir_exp + actual->Ddir_exp) / n;
-	if(matriz.Dpilaexp != NULL) media->Dpilaexp = ((n - 1) * media->Dpilaexp + actual->Dpilaexp) / n; 
-	if(matriz.Destadoexp != NULL) media->Destadoexp = ((n - 1) * media->Destadoexp + actual->Destadoexp) / n; 
-		
-	if(matriz.Ddatoimp != NULL) media->Ddatoimp = ((n - 1) * media->Ddatoimp + actual->Ddatoimp) / n; 
-	if(matriz.Ddir_imp != NULL) media->Ddir_imp = ((n - 1) * media->Ddir_imp + actual->Ddir_imp) / n; 
-	if(matriz.Dpilaimp != NULL) media->Dpilaimp = ((n - 1) * media->Dpilaimp + actual->Dpilaimp) / n; 
-	if(matriz.Destadoimp != NULL) media->Destadoimp = ((n - 1) * media->Destadoimp + actual->Destadoimp) / n; 
-
-	if(matriz.ADdatoexp != NULL) media->ADdatoexp = ((n - 1) * media->ADdatoexp + actual->ADdatoexp) / n; 
-	if(matriz.ADdir_exp != NULL) media->ADdir_exp = ((n - 1) * media->ADdir_exp + actual->ADdir_exp) / n; 
-	if(matriz.ADpilaexp != NULL) media->ADpilaexp = ((n - 1) * media->ADpilaexp + actual->ADpilaexp) / n; 
-	if(matriz.ADestadoexp != NULL) media->ADestadoexp = ((n - 1) * media->ADestadoexp + actual->ADestadoexp) / n; 
-		
-	if(matriz.ADdatoimp != NULL) media->ADdatoimp = ((n - 1) * media->ADdatoimp + actual->ADdatoimp) / n; 
-	if(matriz.ADdir_imp != NULL) media->ADdir_imp = ((n - 1) * media->ADdir_imp + actual->ADdir_imp) / n; 
-	if(matriz.ADpilaimp != NULL) media->ADpilaimp = ((n - 1) * media->ADpilaimp + actual->ADpilaimp) / n; 
-	if(matriz.ADestadoimp != NULL) media->ADestadoimp = ((n - 1) * media->ADestadoimp + actual->ADestadoimp) / n; 
-
-	if(matriz.Sdatoexp != NULL) media->Sdatoexp = ((n - 1) * media->Sdatoexp + actual->Sdatoexp) / n; 
-	if(matriz.Sdir_exp != NULL) media->Sdir_exp = ((n - 1) * media->Sdir_exp + actual->Sdir_exp) / n; 
-	if(matriz.Spilaexp != NULL) media->Spilaexp = ((n - 1) * media->Spilaexp + actual->Spilaexp) / n; 
-	if(matriz.Sestadoexp != NULL) media->Sestadoexp = ((n - 1) * media->Sestadoexp + actual->Sestadoexp) / n; 
-		
-	if(matriz.Sdatoimp != NULL) media->Sdatoimp = ((n - 1) * media->Sdatoimp + actual->Sdatoimp) / n; 
-	if(matriz.Sdir_imp != NULL) media->Sdir_imp = ((n - 1) * media->Sdir_imp + actual->Sdir_imp) / n; 
-	if(matriz.Spilaimp != NULL) media->Spilaimp = ((n - 1) * media->Spilaimp + actual->Spilaimp) / n; 
-	if(matriz.Sestadoimp != NULL) media->Sestadoimp = ((n - 1) * media->Sestadoimp + actual->Sestadoimp) / n; 
+    if(matriz.Ddatoexp != NULL) media->Ddatoexp = ((n - 1) * media->Ddatoexp + actual->Ddatoexp) / n;
+    if(matriz.Ddir_exp != NULL) media->Ddir_exp = ((n - 1) * media->Ddir_exp + actual->Ddir_exp) / n;
+    if(matriz.Dpilaexp != NULL) media->Dpilaexp = ((n - 1) * media->Dpilaexp + actual->Dpilaexp) / n; 
+    if(matriz.Destadoexp != NULL) media->Destadoexp = ((n - 1) * media->Destadoexp + actual->Destadoexp) / n; 
+        
+    if(matriz.Ddatoimp != NULL) media->Ddatoimp = ((n - 1) * media->Ddatoimp + actual->Ddatoimp) / n; 
+    if(matriz.Ddir_imp != NULL) media->Ddir_imp = ((n - 1) * media->Ddir_imp + actual->Ddir_imp) / n; 
+    if(matriz.Dpilaimp != NULL) media->Dpilaimp = ((n - 1) * media->Dpilaimp + actual->Dpilaimp) / n; 
+    if(matriz.Destadoimp != NULL) media->Destadoimp = ((n - 1) * media->Destadoimp + actual->Destadoimp) / n; 
+
+    if(matriz.ADdatoexp != NULL) media->ADdatoexp = ((n - 1) * media->ADdatoexp + actual->ADdatoexp) / n; 
+    if(matriz.ADdir_exp != NULL) media->ADdir_exp = ((n - 1) * media->ADdir_exp + actual->ADdir_exp) / n; 
+    if(matriz.ADpilaexp != NULL) media->ADpilaexp = ((n - 1) * media->ADpilaexp + actual->ADpilaexp) / n; 
+    if(matriz.ADestadoexp != NULL) media->ADestadoexp = ((n - 1) * media->ADestadoexp + actual->ADestadoexp) / n; 
+        
+    if(matriz.ADdatoimp != NULL) media->ADdatoimp = ((n - 1) * media->ADdatoimp + actual->ADdatoimp) / n; 
+    if(matriz.ADdir_imp != NULL) media->ADdir_imp = ((n - 1) * media->ADdir_imp + actual->ADdir_imp) / n; 
+    if(matriz.ADpilaimp != NULL) media->ADpilaimp = ((n - 1) * media->ADpilaimp + actual->ADpilaimp) / n; 
+    if(matriz.ADestadoimp != NULL) media->ADestadoimp = ((n - 1) * media->ADestadoimp + actual->ADestadoimp) / n; 
+
+    if(matriz.Sdatoexp != NULL) media->Sdatoexp = ((n - 1) * media->Sdatoexp + actual->Sdatoexp) / n; 
+    if(matriz.Sdir_exp != NULL) media->Sdir_exp = ((n - 1) * media->Sdir_exp + actual->Sdir_exp) / n; 
+    if(matriz.Spilaexp != NULL) media->Spilaexp = ((n - 1) * media->Spilaexp + actual->Spilaexp) / n; 
+    if(matriz.Sestadoexp != NULL) media->Sestadoexp = ((n - 1) * media->Sestadoexp + actual->Sestadoexp) / n; 
+        
+    if(matriz.Sdatoimp != NULL) media->Sdatoimp = ((n - 1) * media->Sdatoimp + actual->Sdatoimp) / n; 
+    if(matriz.Sdir_imp != NULL) media->Sdir_imp = ((n - 1) * media->Sdir_imp + actual->Sdir_imp) / n; 
+    if(matriz.Spilaimp != NULL) media->Spilaimp = ((n - 1) * media->Spilaimp + actual->Spilaimp) / n; 
+    if(matriz.Sestadoimp != NULL) media->Sestadoimp = ((n - 1) * media->Sestadoimp + actual->Sestadoimp) / n; 
 
-	if(matriz.D != NULL) media->D = ((n - 1) * media->D + actual->D) / n; 
+    if(matriz.D != NULL) media->D = ((n - 1) * media->D + actual->D) / n; 
 }
 */
 
@@ -565,37 +532,37 @@ void CalcularPromedioVariableAgregada(pa
 
 void CalcularPromedioVariableAgregada(parametromatriz *media, parametromatriz *actual, unsigned long n)
 {
-	if(matriz.Ddatoexp != NULL) media->Ddatoexp = CalcularNuevoPromedio(media->Ddatoexp, actual->Ddatoexp, n);
-	if(matriz.Ddir_exp != NULL) media->Ddir_exp = CalcularNuevoPromedio(media->Ddir_exp, actual->Ddir_exp, n);
-	if(matriz.Dpilaexp != NULL) media->Dpilaexp = CalcularNuevoPromedio(media->Dpilaexp, actual->Dpilaexp, n); 
-	if(matriz.Destadoexp != NULL) media->Destadoexp = CalcularNuevoPromedio(media->Destadoexp, actual->Destadoexp, n); 
-		
-	if(matriz.Ddatoimp != NULL) media->Ddatoimp = CalcularNuevoPromedio(media->Ddatoimp, actual->Ddatoimp, n); 
-	if(matriz.Ddir_imp != NULL) media->Ddir_imp = CalcularNuevoPromedio(media->Ddir_imp, actual->Ddir_imp, n); 
-	if(matriz.Dpilaimp != NULL) media->Dpilaimp = CalcularNuevoPromedio(media->Dpilaimp, actual->Dpilaimp, n); 
-	if(matriz.Destadoimp != NULL) media->Destadoimp = CalcularNuevoPromedio(media->Destadoimp, actual->Destadoimp, n); 
-
-	if(matriz.ADdatoexp != NULL) media->ADdatoexp = CalcularNuevoPromedio(media->ADdatoexp, actual->ADdatoexp, n); 
-	if(matriz.ADdir_exp != NULL) media->ADdir_exp = CalcularNuevoPromedio(media->ADdir_exp, actual->ADdir_exp, n); 
-	if(matriz.ADpilaexp != NULL) media->ADpilaexp = CalcularNuevoPromedio(media->ADpilaexp, actual->ADpilaexp, n); 
-	if(matriz.ADestadoexp != NULL) media->ADestadoexp = CalcularNuevoPromedio(media->ADestadoexp, actual->ADestadoexp, n); 
-		
-	if(matriz.ADdatoimp != NULL) media->ADdatoimp = CalcularNuevoPromedio(media->ADdatoimp, actual->ADdatoimp, n); 
-	if(matriz.ADdir_imp != NULL) media->ADdir_imp = CalcularNuevoPromedio(media->ADdir_imp, actual->ADdir_imp, n); 
-	if(matriz.ADpilaimp != NULL) media->ADpilaimp = CalcularNuevoPromedio(media->ADpilaimp, actual->ADpilaimp, n); 
-	if(matriz.ADestadoimp != NULL) media->ADestadoimp = CalcularNuevoPromedio(media->ADestadoimp, actual->ADestadoimp, n); 
-
-	if(matriz.Sdatoexp != NULL) media->Sdatoexp = CalcularNuevoPromedio(media->Sdatoexp, actual->Sdatoexp, n); 
-	if(matriz.Sdir_exp != NULL) media->Sdir_exp = CalcularNuevoPromedio(media->Sdir_exp, actual->Sdir_exp, n); 
-	if(matriz.Spilaexp != NULL) media->Spilaexp = CalcularNuevoPromedio(media->Spilaexp, actual->Spilaexp, n); 
-	if(matriz.Sestadoexp != NULL) media->Sestadoexp = CalcularNuevoPromedio(media->Sestadoexp, actual->Sestadoexp, n); 
-		
-	if(matriz.Sdatoimp != NULL) media->Sdatoimp = CalcularNuevoPromedio(media->Sdatoimp, actual->Sdatoimp, n); 
-	if(matriz.Sdir_imp != NULL) media->Sdir_imp = CalcularNuevoPromedio(media->Sdir_imp, actual->Sdir_imp, n); 
-	if(matriz.Spilaimp != NULL) media->Spilaimp = CalcularNuevoPromedio(media->Spilaimp, actual->Spilaimp, n); 
-	if(matriz.Sestadoimp != NULL) media->Sestadoimp = CalcularNuevoPromedio(media->Sestadoimp, actual->Sestadoimp, n); 
+    if(matriz.Ddatoexp != NULL) media->Ddatoexp = CalcularNuevoPromedio(media->Ddatoexp, actual->Ddatoexp, n);
+    if(matriz.Ddir_exp != NULL) media->Ddir_exp = CalcularNuevoPromedio(media->Ddir_exp, actual->Ddir_exp, n);
+    if(matriz.Dpilaexp != NULL) media->Dpilaexp = CalcularNuevoPromedio(media->Dpilaexp, actual->Dpilaexp, n); 
+    if(matriz.Destadoexp != NULL) media->Destadoexp = CalcularNuevoPromedio(media->Destadoexp, actual->Destadoexp, n); 
+        
+    if(matriz.Ddatoimp != NULL) media->Ddatoimp = CalcularNuevoPromedio(media->Ddatoimp, actual->Ddatoimp, n); 
+    if(matriz.Ddir_imp != NULL) media->Ddir_imp = CalcularNuevoPromedio(media->Ddir_imp, actual->Ddir_imp, n); 
+    if(matriz.Dpilaimp != NULL) media->Dpilaimp = CalcularNuevoPromedio(media->Dpilaimp, actual->Dpilaimp, n); 
+    if(matriz.Destadoimp != NULL) media->Destadoimp = CalcularNuevoPromedio(media->Destadoimp, actual->Destadoimp, n); 
+
+    if(matriz.ADdatoexp != NULL) media->ADdatoexp = CalcularNuevoPromedio(media->ADdatoexp, actual->ADdatoexp, n); 
+    if(matriz.ADdir_exp != NULL) media->ADdir_exp = CalcularNuevoPromedio(media->ADdir_exp, actual->ADdir_exp, n); 
+    if(matriz.ADpilaexp != NULL) media->ADpilaexp = CalcularNuevoPromedio(media->ADpilaexp, actual->ADpilaexp, n); 
+    if(matriz.ADestadoexp != NULL) media->ADestadoexp = CalcularNuevoPromedio(media->ADestadoexp, actual->ADestadoexp, n); 
+        
+    if(matriz.ADdatoimp != NULL) media->ADdatoimp = CalcularNuevoPromedio(media->ADdatoimp, actual->ADdatoimp, n); 
+    if(matriz.ADdir_imp != NULL) media->ADdir_imp = CalcularNuevoPromedio(media->ADdir_imp, actual->ADdir_imp, n); 
+    if(matriz.ADpilaimp != NULL) media->ADpilaimp = CalcularNuevoPromedio(media->ADpilaimp, actual->ADpilaimp, n); 
+    if(matriz.ADestadoimp != NULL) media->ADestadoimp = CalcularNuevoPromedio(media->ADestadoimp, actual->ADestadoimp, n); 
+
+    if(matriz.Sdatoexp != NULL) media->Sdatoexp = CalcularNuevoPromedio(media->Sdatoexp, actual->Sdatoexp, n); 
+    if(matriz.Sdir_exp != NULL) media->Sdir_exp = CalcularNuevoPromedio(media->Sdir_exp, actual->Sdir_exp, n); 
+    if(matriz.Spilaexp != NULL) media->Spilaexp = CalcularNuevoPromedio(media->Spilaexp, actual->Spilaexp, n); 
+    if(matriz.Sestadoexp != NULL) media->Sestadoexp = CalcularNuevoPromedio(media->Sestadoexp, actual->Sestadoexp, n); 
+        
+    if(matriz.Sdatoimp != NULL) media->Sdatoimp = CalcularNuevoPromedio(media->Sdatoimp, actual->Sdatoimp, n); 
+    if(matriz.Sdir_imp != NULL) media->Sdir_imp = CalcularNuevoPromedio(media->Sdir_imp, actual->Sdir_imp, n); 
+    if(matriz.Spilaimp != NULL) media->Spilaimp = CalcularNuevoPromedio(media->Spilaimp, actual->Spilaimp, n); 
+    if(matriz.Sestadoimp != NULL) media->Sestadoimp = CalcularNuevoPromedio(media->Sestadoimp, actual->Sestadoimp, n); 
 
-	if(matriz.D != NULL) media->D = CalcularNuevoPromedio(media->D, actual->D, n); 
+    if(matriz.D != NULL) media->D = CalcularNuevoPromedio(media->D, actual->D, n); 
 }
 
 
@@ -606,37 +573,37 @@ void CalcularPromedioVariableAgregada(pa
 
 void CalcularPasosComputacion(parametromatriz *pasos)
 {
-	if(matriz.Ddatoexp != NULL) pasos->Ddatoexp = ListaOrdenParcial(matriz.Ddatoexp, NULL);
-	if(matriz.Ddir_exp != NULL) pasos->Ddir_exp = ListaOrdenParcial(matriz.Ddir_exp, NULL);
-	if(matriz.Dpilaexp != NULL) pasos->Dpilaexp = ListaOrdenParcial(matriz.Dpilaexp, NULL); 
-	if(matriz.Destadoexp != NULL) pasos->Destadoexp = ListaOrdenParcial(matriz.Destadoexp, NULL); 
-		
-	if(matriz.Ddatoimp != NULL) pasos->Ddatoimp = ListaOrdenParcial(matriz.Ddatoimp, NULL); 
-	if(matriz.Ddir_imp != NULL) pasos->Ddir_imp = ListaOrdenParcial(matriz.Ddir_imp, NULL); 
-	if(matriz.Dpilaimp != NULL) pasos->Dpilaimp = ListaOrdenParcial(matriz.Dpilaimp, NULL); 
-	if(matriz.Destadoimp != NULL) pasos->Destadoimp = ListaOrdenParcial(matriz.Destadoimp, NULL); 
-
-	if(matriz.ADdatoexp != NULL) pasos->ADdatoexp = ListaOrdenParcial(matriz.ADdatoexp, NULL); 
-	if(matriz.ADdir_exp != NULL) pasos->ADdir_exp = ListaOrdenParcial(matriz.ADdir_exp, NULL); 
-	if(matriz.ADpilaexp != NULL) pasos->ADpilaexp = ListaOrdenParcial(matriz.ADpilaexp, NULL); 
-	if(matriz.ADestadoexp != NULL) pasos->ADestadoexp = ListaOrdenParcial(matriz.ADestadoexp, NULL); 
-		
-	if(matriz.ADdatoimp != NULL) pasos->ADdatoimp = ListaOrdenParcial(matriz.ADdatoimp, NULL); 
-	if(matriz.ADdir_imp != NULL) pasos->ADdir_imp = ListaOrdenParcial(matriz.ADdir_imp, NULL); 
-	if(matriz.ADpilaimp != NULL) pasos->ADpilaimp = ListaOrdenParcial(matriz.ADpilaimp, NULL); 
-	if(matriz.ADestadoimp != NULL) pasos->ADestadoimp = ListaOrdenParcial(matriz.ADestadoimp, NULL); 
-
-	if(matriz.Sdatoexp != NULL) pasos->Sdatoexp = ListaOrdenParcial(matriz.Sdatoexp, NULL); 
-	if(matriz.Sdir_exp != NULL) pasos->Sdir_exp = ListaOrdenParcial(matriz.Sdir_exp, NULL); 
-	if(matriz.Spilaexp != NULL) pasos->Spilaexp = ListaOrdenParcial(matriz.Spilaexp, NULL); 
-	if(matriz.Sestadoexp != NULL) pasos->Sestadoexp = ListaOrdenParcial(matriz.Sestadoexp, NULL); 
-		
-	if(matriz.Sdatoimp != NULL) pasos->Sdatoimp = ListaOrdenParcial(matriz.Sdatoimp, NULL); 
-	if(matriz.Sdir_imp != NULL) pasos->Sdir_imp = ListaOrdenParcial(matriz.Sdir_imp, NULL); 
-	if(matriz.Spilaimp != NULL) pasos->Spilaimp = ListaOrdenParcial(matriz.Spilaimp, NULL); 
-	if(matriz.Sestadoimp != NULL) pasos->Sestadoimp = ListaOrdenParcial(matriz.Sestadoimp, NULL); 
+    if(matriz.Ddatoexp != NULL) pasos->Ddatoexp = ListaOrdenParcial(matriz.Ddatoexp, NULL);
+    if(matriz.Ddir_exp != NULL) pasos->Ddir_exp = ListaOrdenParcial(matriz.Ddir_exp, NULL);
+    if(matriz.Dpilaexp != NULL) pasos->Dpilaexp = ListaOrdenParcial(matriz.Dpilaexp, NULL); 
+    if(matriz.Destadoexp != NULL) pasos->Destadoexp = ListaOrdenParcial(matriz.Destadoexp, NULL); 
+        
+    if(matriz.Ddatoimp != NULL) pasos->Ddatoimp = ListaOrdenParcial(matriz.Ddatoimp, NULL); 
+    if(matriz.Ddir_imp != NULL) pasos->Ddir_imp = ListaOrdenParcial(matriz.Ddir_imp, NULL); 
+    if(matriz.Dpilaimp != NULL) pasos->Dpilaimp = ListaOrdenParcial(matriz.Dpilaimp, NULL); 
+    if(matriz.Destadoimp != NULL) pasos->Destadoimp = ListaOrdenParcial(matriz.Destadoimp, NULL); 
+
+    if(matriz.ADdatoexp != NULL) pasos->ADdatoexp = ListaOrdenParcial(matriz.ADdatoexp, NULL); 
+    if(matriz.ADdir_exp != NULL) pasos->ADdir_exp = ListaOrdenParcial(matriz.ADdir_exp, NULL); 
+    if(matriz.ADpilaexp != NULL) pasos->ADpilaexp = ListaOrdenParcial(matriz.ADpilaexp, NULL); 
+    if(matriz.ADestadoexp != NULL) pasos->ADestadoexp = ListaOrdenParcial(matriz.ADestadoexp, NULL); 
+        
+    if(matriz.ADdatoimp != NULL) pasos->ADdatoimp = ListaOrdenParcial(matriz.ADdatoimp, NULL); 
+    if(matriz.ADdir_imp != NULL) pasos->ADdir_imp = ListaOrdenParcial(matriz.ADdir_imp, NULL); 
+    if(matriz.ADpilaimp != NULL) pasos->ADpilaimp = ListaOrdenParcial(matriz.ADpilaimp, NULL); 
+    if(matriz.ADestadoimp != NULL) pasos->ADestadoimp = ListaOrdenParcial(matriz.ADestadoimp, NULL); 
+
+    if(matriz.Sdatoexp != NULL) pasos->Sdatoexp = ListaOrdenParcial(matriz.Sdatoexp, NULL); 
+    if(matriz.Sdir_exp != NULL) pasos->Sdir_exp = ListaOrdenParcial(matriz.Sdir_exp, NULL); 
+    if(matriz.Spilaexp != NULL) pasos->Spilaexp = ListaOrdenParcial(matriz.Spilaexp, NULL); 
+    if(matriz.Sestadoexp != NULL) pasos->Sestadoexp = ListaOrdenParcial(matriz.Sestadoexp, NULL); 
+        
+    if(matriz.Sdatoimp != NULL) pasos->Sdatoimp = ListaOrdenParcial(matriz.Sdatoimp, NULL); 
+    if(matriz.Sdir_imp != NULL) pasos->Sdir_imp = ListaOrdenParcial(matriz.Sdir_imp, NULL); 
+    if(matriz.Spilaimp != NULL) pasos->Spilaimp = ListaOrdenParcial(matriz.Spilaimp, NULL); 
+    if(matriz.Sestadoimp != NULL) pasos->Sestadoimp = ListaOrdenParcial(matriz.Sestadoimp, NULL); 
 
-	if(matriz.D != NULL) pasos->D = ListaOrdenParcial(matriz.D, NULL); 
+    if(matriz.D != NULL) pasos->D = ListaOrdenParcial(matriz.D, NULL); 
 }
 
 
@@ -647,37 +614,37 @@ void CalcularPasosComputacion(parametrom
 /*
 void CalcularGradoParalelismo(parametromatriz *pasos, parametromatriz *grado)
 {
-	if(matriz.Ddatoexp != NULL) grado->Ddatoexp = 1 / pasos->Ddatoexp;
-	if(matriz.Ddir_exp != NULL) grado->Ddir_exp = 1 / pasos->Ddir_exp;
-	if(matriz.Dpilaexp != NULL) grado->Dpilaexp = 1 / pasos->Dpilaexp; 
-	if(matriz.Destadoexp != NULL) grado->Destadoexp = 1 / pasos->Destadoexp; 
-		
-	if(matriz.Ddatoimp != NULL) grado->Ddatoimp = 1 / pasos->Ddatoimp; 
-	if(matriz.Ddir_imp != NULL) grado->Ddir_imp = 1 / pasos->Ddir_imp; 
-	if(matriz.Dpilaimp != NULL) grado->Dpilaimp = 1 / pasos->Dpilaimp; 
-	if(matriz.Destadoimp != NULL) grado->Destadoimp = 1 / pasos->Destadoimp; 
-
-	if(matriz.ADdatoexp != NULL) grado->ADdatoexp = 1 / pasos->ADdatoexp; 
-	if(matriz.ADdir_exp != NULL) grado->ADdir_exp = 1 / pasos->ADdir_exp; 
-	if(matriz.ADpilaexp != NULL) grado->ADpilaexp = 1 / pasos->ADpilaexp; 
-	if(matriz.ADestadoexp != NULL) grado->ADestadoexp = 1 / pasos->ADestadoexp; 
-		
-	if(matriz.ADdatoimp != NULL) grado->ADdatoimp = 1 / pasos->ADdatoimp; 
-	if(matriz.ADdir_imp != NULL) grado->ADdir_imp = 1 / pasos->ADdir_imp; 
-	if(matriz.ADpilaimp != NULL) grado->ADpilaimp = 1 / pasos->ADpilaimp; 
-	if(matriz.ADestadoimp != NULL) grado->ADestadoimp = 1 / pasos->ADestadoimp; 
-
-	if(matriz.Sdatoexp != NULL) grado->Sdatoexp = 1 / pasos->Sdatoexp; 
-	if(matriz.Sdir_exp != NULL) grado->Sdir_exp = 1 / pasos->Sdir_exp; 
-	if(matriz.Spilaexp != NULL) grado->Spilaexp = 1 / pasos->Spilaexp; 
-	if(matriz.Sestadoexp != NULL) grado->Sestadoexp = 1 / pasos->Sestadoexp; 
-		
-	if(matriz.Sdatoimp != NULL) grado->Sdatoimp = 1 / pasos->Sdatoimp; 
-	if(matriz.Sdir_imp != NULL) grado->Sdir_imp = 1 / pasos->Sdir_imp; 
-	if(matriz.Spilaimp != NULL) grado->Spilaimp = 1 / pasos->Spilaimp; 
-	if(matriz.Sestadoimp != NULL) grado->Sestadoimp = 1 / pasos->Sestadoimp; 
+    if(matriz.Ddatoexp != NULL) grado->Ddatoexp = 1 / pasos->Ddatoexp;
+    if(matriz.Ddir_exp != NULL) grado->Ddir_exp = 1 / pasos->Ddir_exp;
+    if(matriz.Dpilaexp != NULL) grado->Dpilaexp = 1 / pasos->Dpilaexp; 
+    if(matriz.Destadoexp != NULL) grado->Destadoexp = 1 / pasos->Destadoexp; 
+        
+    if(matriz.Ddatoimp != NULL) grado->Ddatoimp = 1 / pasos->Ddatoimp; 
+    if(matriz.Ddir_imp != NULL) grado->Ddir_imp = 1 / pasos->Ddir_imp; 
+    if(matriz.Dpilaimp != NULL) grado->Dpilaimp = 1 / pasos->Dpilaimp; 
+    if(matriz.Destadoimp != NULL) grado->Destadoimp = 1 / pasos->Destadoimp; 
+
+    if(matriz.ADdatoexp != NULL) grado->ADdatoexp = 1 / pasos->ADdatoexp; 
+    if(matriz.ADdir_exp != NULL) grado->ADdir_exp = 1 / pasos->ADdir_exp; 
+    if(matriz.ADpilaexp != NULL) grado->ADpilaexp = 1 / pasos->ADpilaexp; 
+    if(matriz.ADestadoexp != NULL) grado->ADestadoexp = 1 / pasos->ADestadoexp; 
+        
+    if(matriz.ADdatoimp != NULL) grado->ADdatoimp = 1 / pasos->ADdatoimp; 
+    if(matriz.ADdir_imp != NULL) grado->ADdir_imp = 1 / pasos->ADdir_imp; 
+    if(matriz.ADpilaimp != NULL) grado->ADpilaimp = 1 / pasos->ADpilaimp; 
+    if(matriz.ADestadoimp != NULL) grado->ADestadoimp = 1 / pasos->ADestadoimp; 
+
+    if(matriz.Sdatoexp != NULL) grado->Sdatoexp = 1 / pasos->Sdatoexp; 
+    if(matriz.Sdir_exp != NULL) grado->Sdir_exp = 1 / pasos->Sdir_exp; 
+    if(matriz.Spilaexp != NULL) grado->Spilaexp = 1 / pasos->Spilaexp; 
+    if(matriz.Sestadoexp != NULL) grado->Sestadoexp = 1 / pasos->Sestadoexp; 
+        
+    if(matriz.Sdatoimp != NULL) grado->Sdatoimp = 1 / pasos->Sdatoimp; 
+    if(matriz.Sdir_imp != NULL) grado->Sdir_imp = 1 / pasos->Sdir_imp; 
+    if(matriz.Spilaimp != NULL) grado->Spilaimp = 1 / pasos->Spilaimp; 
+    if(matriz.Sestadoimp != NULL) grado->Sestadoimp = 1 / pasos->Sestadoimp; 
 
-	if(matriz.D != NULL) grado->D = 1 / pasos->D; 
+    if(matriz.D != NULL) grado->D = 1 / pasos->D; 
 }
 
 */
@@ -689,41 +656,41 @@ void CalcularGradoParalelismo(parametrom
 
 void CalcularGradoParalelismoNormalizado(parametromatriz *pasos, parametromatriz *grado)
 {
-	unsigned int dim;
+    unsigned int dim;
 
-	dim = configuracion.ventana;
-	
-	if(matriz.Ddatoexp != NULL) grado->Ddatoexp = InversoNormalizado(dim, pasos->Ddatoexp);
-	if(matriz.Ddir_exp != NULL) grado->Ddir_exp = InversoNormalizado(dim, pasos->Ddir_exp);
-	if(matriz.Dpilaexp != NULL) grado->Dpilaexp = InversoNormalizado(dim, pasos->Dpilaexp); 
-	if(matriz.Destadoexp != NULL) grado->Destadoexp = InversoNormalizado(dim, pasos->Destadoexp); 
-		
-	if(matriz.Ddatoimp != NULL) grado->Ddatoimp = InversoNormalizado(dim, pasos->Ddatoimp); 
-	if(matriz.Ddir_imp != NULL) grado->Ddir_imp = InversoNormalizado(dim, pasos->Ddir_imp); 
-	if(matriz.Dpilaimp != NULL) grado->Dpilaimp = InversoNormalizado(dim, pasos->Dpilaimp); 
-	if(matriz.Destadoimp != NULL) grado->Destadoimp = InversoNormalizado(dim, pasos->Destadoimp); 
-
-	if(matriz.ADdatoexp != NULL) grado->ADdatoexp = InversoNormalizado(dim, pasos->ADdatoexp); 
-	if(matriz.ADdir_exp != NULL) grado->ADdir_exp = InversoNormalizado(dim, pasos->ADdir_exp); 
-	if(matriz.ADpilaexp != NULL) grado->ADpilaexp = InversoNormalizado(dim, pasos->ADpilaexp); 
-	if(matriz.ADestadoexp != NULL) grado->ADestadoexp = InversoNormalizado(dim, pasos->ADestadoexp); 
-		
-	if(matriz.ADdatoimp != NULL) grado->ADdatoimp = InversoNormalizado(dim, pasos->ADdatoimp); 
-	if(matriz.ADdir_imp != NULL) grado->ADdir_imp = InversoNormalizado(dim, pasos->ADdir_imp); 
-	if(matriz.ADpilaimp != NULL) grado->ADpilaimp = InversoNormalizado(dim, pasos->ADpilaimp); 
-	if(matriz.ADestadoimp != NULL) grado->ADestadoimp = InversoNormalizado(dim, pasos->ADestadoimp); 
-
-	if(matriz.Sdatoexp != NULL) grado->Sdatoexp = InversoNormalizado(dim, pasos->Sdatoexp); 
-	if(matriz.Sdir_exp != NULL) grado->Sdir_exp = InversoNormalizado(dim, pasos->Sdir_exp); 
-	if(matriz.Spilaexp != NULL) grado->Spilaexp = InversoNormalizado(dim, pasos->Spilaexp); 
-	if(matriz.Sestadoexp != NULL) grado->Sestadoexp = InversoNormalizado(dim, pasos->Sestadoexp); 
-		
-	if(matriz.Sdatoimp != NULL) grado->Sdatoimp = InversoNormalizado(dim, pasos->Sdatoimp); 
-	if(matriz.Sdir_imp != NULL) grado->Sdir_imp = InversoNormalizado(dim, pasos->Sdir_imp); 
-	if(matriz.Spilaimp != NULL) grado->Spilaimp = InversoNormalizado(dim, pasos->Spilaimp); 
-	if(matriz.Sestadoimp != NULL) grado->Sestadoimp = InversoNormalizado(dim, pasos->Sestadoimp); 
+    dim = configuracion.ventana;
+    
+    if(matriz.Ddatoexp != NULL) grado->Ddatoexp = InversoNormalizado(dim, pasos->Ddatoexp);
+    if(matriz.Ddir_exp != NULL) grado->Ddir_exp = InversoNormalizado(dim, pasos->Ddir_exp);
+    if(matriz.Dpilaexp != NULL) grado->Dpilaexp = InversoNormalizado(dim, pasos->Dpilaexp); 
+    if(matriz.Destadoexp != NULL) grado->Destadoexp = InversoNormalizado(dim, pasos->Destadoexp); 
+        
+    if(matriz.Ddatoimp != NULL) grado->Ddatoimp = InversoNormalizado(dim, pasos->Ddatoimp); 
+    if(matriz.Ddir_imp != NULL) grado->Ddir_imp = InversoNormalizado(dim, pasos->Ddir_imp); 
+    if(matriz.Dpilaimp != NULL) grado->Dpilaimp = InversoNormalizado(dim, pasos->Dpilaimp); 
+    if(matriz.Destadoimp != NULL) grado->Destadoimp = InversoNormalizado(dim, pasos->Destadoimp); 
+
+    if(matriz.ADdatoexp != NULL) grado->ADdatoexp = InversoNormalizado(dim, pasos->ADdatoexp); 
+    if(matriz.ADdir_exp != NULL) grado->ADdir_exp = InversoNormalizado(dim, pasos->ADdir_exp); 
+    if(matriz.ADpilaexp != NULL) grado->ADpilaexp = InversoNormalizado(dim, pasos->ADpilaexp); 
+    if(matriz.ADestadoexp != NULL) grado->ADestadoexp = InversoNormalizado(dim, pasos->ADestadoexp); 
+        
+    if(matriz.ADdatoimp != NULL) grado->ADdatoimp = InversoNormalizado(dim, pasos->ADdatoimp); 
+    if(matriz.ADdir_imp != NULL) grado->ADdir_imp = InversoNormalizado(dim, pasos->ADdir_imp); 
+    if(matriz.ADpilaimp != NULL) grado->ADpilaimp = InversoNormalizado(dim, pasos->ADpilaimp); 
+    if(matriz.ADestadoimp != NULL) grado->ADestadoimp = InversoNormalizado(dim, pasos->ADestadoimp); 
+
+    if(matriz.Sdatoexp != NULL) grado->Sdatoexp = InversoNormalizado(dim, pasos->Sdatoexp); 
+    if(matriz.Sdir_exp != NULL) grado->Sdir_exp = InversoNormalizado(dim, pasos->Sdir_exp); 
+    if(matriz.Spilaexp != NULL) grado->Spilaexp = InversoNormalizado(dim, pasos->Spilaexp); 
+    if(matriz.Sestadoexp != NULL) grado->Sestadoexp = InversoNormalizado(dim, pasos->Sestadoexp); 
+        
+    if(matriz.Sdatoimp != NULL) grado->Sdatoimp = InversoNormalizado(dim, pasos->Sdatoimp); 
+    if(matriz.Sdir_imp != NULL) grado->Sdir_imp = InversoNormalizado(dim, pasos->Sdir_imp); 
+    if(matriz.Spilaimp != NULL) grado->Spilaimp = InversoNormalizado(dim, pasos->Spilaimp); 
+    if(matriz.Sestadoimp != NULL) grado->Sestadoimp = InversoNormalizado(dim, pasos->Sestadoimp); 
 
-	if(matriz.D != NULL) grado->D = InversoNormalizado(dim, pasos->D); 
+    if(matriz.D != NULL) grado->D = InversoNormalizado(dim, pasos->D); 
 }
 
 
@@ -731,37 +698,37 @@ void CalcularGradoParalelismoNormalizado
 
 void CalcularAcoplamiento(parametromatriz *acoplamiento)
 {
-	if(matriz.Ddatoexp != NULL) acoplamiento->Ddatoexp = Acoplamiento(matriz.Ddatoexp);
-	if(matriz.Ddir_exp != NULL) acoplamiento->Ddir_exp = Acoplamiento(matriz.Ddir_exp);
-	if(matriz.Dpilaexp != NULL) acoplamiento->Dpilaexp = Acoplamiento(matriz.Dpilaexp); 
-	if(matriz.Destadoexp != NULL) acoplamiento->Destadoexp = Acoplamiento(matriz.Destadoexp); 
-		
-	if(matriz.Ddatoimp != NULL) acoplamiento->Ddatoimp = Acoplamiento(matriz.Ddatoimp); 
-	if(matriz.Ddir_imp != NULL) acoplamiento->Ddir_imp = Acoplamiento(matriz.Ddir_imp); 
-	if(matriz.Dpilaimp != NULL) acoplamiento->Dpilaimp = Acoplamiento(matriz.Dpilaimp); 
-	if(matriz.Destadoimp != NULL) acoplamiento->Destadoimp = Acoplamiento(matriz.Destadoimp); 
-
-	if(matriz.ADdatoexp != NULL) acoplamiento->ADdatoexp = Acoplamiento(matriz.ADdatoexp); 
-	if(matriz.ADdir_exp != NULL) acoplamiento->ADdir_exp = Acoplamiento(matriz.ADdir_exp); 
-	if(matriz.ADpilaexp != NULL) acoplamiento->ADpilaexp = Acoplamiento(matriz.ADpilaexp); 
-	if(matriz.ADestadoexp != NULL) acoplamiento->ADestadoexp = Acoplamiento(matriz.ADestadoexp); 
-		
-	if(matriz.ADdatoimp != NULL) acoplamiento->ADdatoimp = Acoplamiento(matriz.ADdatoimp); 
-	if(matriz.ADdir_imp != NULL) acoplamiento->ADdir_imp = Acoplamiento(matriz.ADdir_imp); 
-	if(matriz.ADpilaimp != NULL) acoplamiento->ADpilaimp = Acoplamiento(matriz.ADpilaimp); 
-	if(matriz.ADestadoimp != NULL) acoplamiento->ADestadoimp = Acoplamiento(matriz.ADestadoimp); 
-
-	if(matriz.Sdatoexp != NULL) acoplamiento->Sdatoexp = Acoplamiento(matriz.Sdatoexp); 
-	if(matriz.Sdir_exp != NULL) acoplamiento->Sdir_exp = Acoplamiento(matriz.Sdir_exp); 
-	if(matriz.Spilaexp != NULL) acoplamiento->Spilaexp = Acoplamiento(matriz.Spilaexp); 
-	if(matriz.Sestadoexp != NULL) acoplamiento->Sestadoexp = Acoplamiento(matriz.Sestadoexp); 
-		
-	if(matriz.Sdatoimp != NULL) acoplamiento->Sdatoimp = Acoplamiento(matriz.Sdatoimp); 
-	if(matriz.Sdir_imp != NULL) acoplamiento->Sdir_imp = Acoplamiento(matriz.Sdir_imp); 
-	if(matriz.Spilaimp != NULL) acoplamiento->Spilaimp = Acoplamiento(matriz.Spilaimp); 
-	if(matriz.Sestadoimp != NULL) acoplamiento->Sestadoimp = Acoplamiento(matriz.Sestadoimp); 
+    if(matriz.Ddatoexp != NULL) acoplamiento->Ddatoexp = Acoplamiento(matriz.Ddatoexp);
+    if(matriz.Ddir_exp != NULL) acoplamiento->Ddir_exp = Acoplamiento(matriz.Ddir_exp);
+    if(matriz.Dpilaexp != NULL) acoplamiento->Dpilaexp = Acoplamiento(matriz.Dpilaexp); 
+    if(matriz.Destadoexp != NULL) acoplamiento->Destadoexp = Acoplamiento(matriz.Destadoexp); 
+        
+    if(matriz.Ddatoimp != NULL) acoplamiento->Ddatoimp = Acoplamiento(matriz.Ddatoimp); 
+    if(matriz.Ddir_imp != NULL) acoplamiento->Ddir_imp = Acoplamiento(matriz.Ddir_imp); 
+    if(matriz.Dpilaimp != NULL) acoplamiento->Dpilaimp = Acoplamiento(matriz.Dpilaimp); 
+    if(matriz.Destadoimp != NULL) acoplamiento->Destadoimp = Acoplamiento(matriz.Destadoimp); 
+
+    if(matriz.ADdatoexp != NULL) acoplamiento->ADdatoexp = Acoplamiento(matriz.ADdatoexp); 
+    if(matriz.ADdir_exp != NULL) acoplamiento->ADdir_exp = Acoplamiento(matriz.ADdir_exp); 
+    if(matriz.ADpilaexp != NULL) acoplamiento->ADpilaexp = Acoplamiento(matriz.ADpilaexp); 
+    if(matriz.ADestadoexp != NULL) acoplamiento->ADestadoexp = Acoplamiento(matriz.ADestadoexp); 
+        
+    if(matriz.ADdatoimp != NULL) acoplamiento->ADdatoimp = Acoplamiento(matriz.ADdatoimp); 
+    if(matriz.ADdir_imp != NULL) acoplamiento->ADdir_imp = Acoplamiento(matriz.ADdir_imp); 
+    if(matriz.ADpilaimp != NULL) acoplamiento->ADpilaimp = Acoplamiento(matriz.ADpilaimp); 
+    if(matriz.ADestadoimp != NULL) acoplamiento->ADestadoimp = Acoplamiento(matriz.ADestadoimp); 
+
+    if(matriz.Sdatoexp != NULL) acoplamiento->Sdatoexp = Acoplamiento(matriz.Sdatoexp); 
+    if(matriz.Sdir_exp != NULL) acoplamiento->Sdir_exp = Acoplamiento(matriz.Sdir_exp); 
+    if(matriz.Spilaexp != NULL) acoplamiento->Spilaexp = Acoplamiento(matriz.Spilaexp); 
+    if(matriz.Sestadoexp != NULL) acoplamiento->Sestadoexp = Acoplamiento(matriz.Sestadoexp); 
+        
+    if(matriz.Sdatoimp != NULL) acoplamiento->Sdatoimp = Acoplamiento(matriz.Sdatoimp); 
+    if(matriz.Sdir_imp != NULL) acoplamiento->Sdir_imp = Acoplamiento(matriz.Sdir_imp); 
+    if(matriz.Spilaimp != NULL) acoplamiento->Spilaimp = Acoplamiento(matriz.Spilaimp); 
+    if(matriz.Sestadoimp != NULL) acoplamiento->Sestadoimp = Acoplamiento(matriz.Sestadoimp); 
 
-	if(matriz.D != NULL) acoplamiento->D = (double) Acoplamiento(matriz.D); 
+    if(matriz.D != NULL) acoplamiento->D = (double) Acoplamiento(matriz.D); 
 }
 
 
@@ -771,14 +738,14 @@ void CalcularAcoplamiento(parametromatri
 
 void CrearHistogramaPasos()
 {
-	char mensaje[MAX_LINE];
+    char mensaje[MAX_LINE];
 
-	distribucionpasos = calloc(configuracion.ventana+1, sizeof(unsigned long));
+    distribucionpasos = calloc(configuracion.ventana+1, sizeof(unsigned long));
     if (distribucionpasos == NULL)
     {
         sprintf(mensaje, "[CrearHistogramaPasos] Memoria insuficiente");
-		Notificar(mensaje, ERROR_SALIR, ECO_NO);
-		/* el programa finaliza si no hay memoria suficiente */
+        Notificar(mensaje, ERROR_SALIR, ECO_NO);
+        /* el programa finaliza si no hay memoria suficiente */
     }
 }
 
@@ -787,9 +754,9 @@ void CrearHistogramaPasos()
 
 void IniciarHistogramaPasos()
 {
-	unsigned int i;
+    unsigned int i;
 
-	for(i=0; i<configuracion.ventana; i++) distribucionpasos[i] = 0;
+    for(i=0; i<configuracion.ventana; i++) distribucionpasos[i] = 0;
 }
 
 
@@ -797,7 +764,7 @@ void IniciarHistogramaPasos()
 
 void LiberarMemoriaHistogramaPasos()
 {
-	free(distribucionpasos);
+    free(distribucionpasos);
 }
 
 
@@ -805,6 +772,6 @@ void LiberarMemoriaHistogramaPasos()
 
 void ActualizarHistogramaPasos()
 {
-	distribucionpasos[(unsigned int)pasos->D]++;
+    distribucionpasos[(unsigned int)pasos->D]++;
 }