[BACK]Return to CalculosMatrices.c CVS log [TXT] [DIR] Up to [Repository ATC2] / ADD_ver_10

Diff for /ADD_ver_10/Attic/CalculosMatrices.c between versions 1.1 and 1.2

version 1.1, 2006/01/19 17:16:29 version 1.2, 2006/02/15 13:00:30
Line 1 Line 1
 /********************************************************************/  
 /*  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                                                 */  /* MÓDULO: CalculosMatrices.c                                                 */
 /*                                                                            */  /*                                                                            */
Line 78  extern unsigned long *distribucionpasos; Line 45  extern unsigned long *distribucionpasos;
   
 unsigned int CalcularMatrizCaminos(unsigned char **D, unsigned char **C)  unsigned int CalcularMatrizCaminos(unsigned char **D, unsigned char **C)
 {  {
         char mensaje[MAX_LINE];      char mensaje[MAX_LINE];
         unsigned char *v;               /* vector temporal */      unsigned char *v;        /* vector temporal */
         unsigned char **tmp;    /* matriz temporal */      unsigned char **tmp;    /* matriz temporal */
   
         unsigned int i, j, k, potencia;      unsigned int i, j, k, potencia;
         unsigned int suma;      unsigned int suma;
         unsigned char matriz_nula;      unsigned char matriz_nula;
   
   
         if(D == NULL)      if(D == NULL)
         {      {
                 sprintf(mensaje, "[CalcularMatrizCaminos] La matriz D indicada no existe");          sprintf(mensaje, "[CalcularMatrizCaminos] La matriz D indicada no existe");
                 Notificar(mensaje, ERROR_SALIR, ECO_NO);          Notificar(mensaje, ERROR_SALIR, ECO_NO);
         }      }
   
         /* necesito un vector y una matriz temporal de 'unsigned char' */      /* necesito un vector y una matriz temporal de 'unsigned char' */
         /* para calcular las sucesivas potencias de la matriz D */      /* 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);  
   
         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' */
 }  }
   
   
Line 198  unsigned int CalcularMatrizCaminos(unsig Line 165  unsigned int CalcularMatrizCaminos(unsig
   
 unsigned int ListaOrdenParcial(unsigned char **D, char **lista)  unsigned int ListaOrdenParcial(unsigned char **D, char **lista)
 {  {
         char mensaje[MAX_LINE];      char mensaje[MAX_LINE];
         unsigned char *lanzadas;        /* vector de instrucciones lanzadas */      unsigned char *lanzadas;    /* vector de instrucciones lanzadas */
         unsigned char **tmp;            /* matriz temporal */      unsigned char **tmp;        /* matriz temporal */
   
     unsigned int pasos, procesadas;      unsigned int pasos, procesadas;
     unsigned int i, j;      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)      if(D == NULL)
         {      {
                 sprintf(mensaje, "[ListaOrdenParcial] La matriz D indicada no existe");          sprintf(mensaje, "[ListaOrdenParcial] La matriz D indicada no existe");
                 Notificar(mensaje, ERROR_SALIR, ECO_NO);          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;  
   
         /* inicio el contador de pasos de computaci¢n */      /* necesito un vector y una matriz temporal de 'unsigned char' */
         pasos = 0;      /* 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;      procesadas = 0;
   
   
         while(configuracion.ventana - procesadas)      while(configuracion.ventana - procesadas)
         {      {
                 pasos++;          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;          /* 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;
 }  }
   
   
Line 330  unsigned int ListaOrdenParcial(unsigned Line 297  unsigned int ListaOrdenParcial(unsigned
   
 unsigned int Acoplamiento(unsigned char **D)  unsigned int Acoplamiento(unsigned char **D)
 {  {
         char mensaje[MAX_LINE];      char mensaje[MAX_LINE];
         unsigned int i, j;      unsigned int i, j;
         unsigned int acoplo = 0;      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++;  
         }  
   
         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;
 }  }
   
   
Line 363  unsigned int Acoplamiento(unsigned char Line 330  unsigned int Acoplamiento(unsigned char
   
 char ** CrearArrayStrings(unsigned int num_cadenas, unsigned int tamano)  char ** CrearArrayStrings(unsigned int num_cadenas, unsigned int tamano)
 {  {
         char mensaje[MAX_LINE];      char mensaje[MAX_LINE];
         unsigned int i;      unsigned int i;
         char **listado;      char **listado;
   
         /* 1º un puntero por cada fila */      /* 1º un puntero por cada fila */
         listado = calloc(num_cadenas, sizeof(char *));      listado = calloc(num_cadenas, sizeof(char *));
         if (listado == NULL)      if (listado == NULL)
         {      {
                 sprintf(mensaje, "[CrearArrayStrings] Memoria insuficiente");          sprintf(mensaje, "[CrearArrayStrings] Memoria insuficiente");
                 Notificar(mensaje, ERROR_SALIR, ECO_NO);          Notificar(mensaje, ERROR_SALIR, ECO_NO);
                 /* el programa finaliza si no hay memoria suficiente */          /* el programa finaliza si no hay memoria suficiente */
         }      }
         /* 2º cuatro 'char' por cada columna (3 caracteres de número y un separador ':') */      /* 2º cuatro 'char' por cada columna (3 caracteres de número y un separador ':') */
         for(i=0; i<configuracion.ventana; i++)      for(i=0; i<configuracion.ventana; i++)
         {      {
                 listado[i] = calloc(tamano, sizeof(char));          listado[i] = calloc(tamano, sizeof(char));
                 if (listado[i] == NULL)          if (listado[i] == NULL)
                 {          {
                         sprintf(mensaje, "[CrearArrayStrings] Memoria insuficiente");              sprintf(mensaje, "[CrearArrayStrings] Memoria insuficiente");
                         Notificar(mensaje, ERROR_SALIR, ECO_NO);              Notificar(mensaje, ERROR_SALIR, ECO_NO);
                         /* el programa finaliza si no hay memoria suficiente */              /* el programa finaliza si no hay memoria suficiente */
                 }          }
         }      }
         return listado;      return listado;
 }  }
   
   
Line 397  char ** CrearArrayStrings(unsigned int n Line 364  char ** CrearArrayStrings(unsigned int n
   
 void CrearListaOrdenParcial()  void CrearListaOrdenParcial()
 {  {
         unsigned int dim;      unsigned int dim;
   
         dim = configuracion.ventana;      dim = configuracion.ventana;
   
         OrdenParcial = CrearArrayStrings(dim, 4*dim);      OrdenParcial = CrearArrayStrings(dim, 4*dim);
 }  }
   
   
Line 409  void CrearListaOrdenParcial() Line 376  void CrearListaOrdenParcial()
   
 void IniciarListaOrdenParcial()  void IniciarListaOrdenParcial()
 {  {
         unsigned int i, dim;      unsigned int i, dim;
   
         dim = configuracion.ventana;      dim = configuracion.ventana;
               
         if(OrdenParcial != NULL) for(i=0; i<dim; i++) *OrdenParcial[i] = '\0';       if(OrdenParcial != NULL) for(i=0; i<dim; i++) *OrdenParcial[i] = '\0'; 
 }  }
   
   
Line 421  void IniciarListaOrdenParcial() Line 388  void IniciarListaOrdenParcial()
   
 void LiberarMemoriaListaOrdenParcial()  void LiberarMemoriaListaOrdenParcial()
 {  {
         unsigned int i,dim;      unsigned int i,dim;
   
         dim = configuracion.ventana;      dim = configuracion.ventana;
   
         if(OrdenParcial != NULL)      if(OrdenParcial != NULL)
         {      {
                 for(i=0; i<dim; i++)          for(i=0; i<dim; i++)
                 {          {
                         free(OrdenParcial[i]);               free(OrdenParcial[i]); 
                 }          }
                 free(OrdenParcial);          free(OrdenParcial);
         }      }
 }  }
   
   
Line 440  void LiberarMemoriaListaOrdenParcial() Line 407  void LiberarMemoriaListaOrdenParcial()
   
 void CrearMatrizCaminos()  void CrearMatrizCaminos()
 {  {
         matrizC = CrearMatriz();      matrizC = CrearMatriz();
 }  }
   
   
Line 448  void CrearMatrizCaminos() Line 415  void CrearMatrizCaminos()
   
 void IniciarMatrizCaminos()  void IniciarMatrizCaminos()
 {  {
         IniciarMatriz(matrizC);      IniciarMatriz(matrizC);
 }  }
   
   
Line 456  void IniciarMatrizCaminos() Line 423  void IniciarMatrizCaminos()
   
 void LiberarMemoriaMatrizCaminos()  void LiberarMemoriaMatrizCaminos()
 {  {
         LiberarMemoriaMatriz(matrizC);      LiberarMemoriaMatriz(matrizC);
 }  }
   
   
Line 464  void LiberarMemoriaMatrizCaminos() Line 431  void LiberarMemoriaMatrizCaminos()
   
 parametromatriz * CrearVariableAgregada()  parametromatriz * CrearVariableAgregada()
 {  {
         char mensaje[MAX_LINE];      char mensaje[MAX_LINE];
         parametromatriz *variable;      parametromatriz *variable;
               
         variable = calloc(1, sizeof(parametromatriz));      variable = calloc(1, sizeof(parametromatriz));
         if (variable == NULL)      if (variable == NULL)
         {      {
                 sprintf(mensaje, "[CrearVariableAgragada] Memoria insuficiente");          sprintf(mensaje, "[CrearVariableAgragada] Memoria insuficiente");
                 Notificar(mensaje, ERROR_SALIR, ECO_NO);          Notificar(mensaje, ERROR_SALIR, ECO_NO);
                 /* el programa finaliza si no hay memoria suficiente */          /* el programa finaliza si no hay memoria suficiente */
         }      }
   
         return variable;      return variable;
 }  }
   
   
Line 483  parametromatriz * CrearVariableAgregada( Line 450  parametromatriz * CrearVariableAgregada(
   
 void IniciarVariableAgregada(parametromatriz *variable)  void IniciarVariableAgregada(parametromatriz *variable)
 {  {
         variable->Ddatoexp = 0.0;      variable->Ddatoexp = 0.0;
         variable->Ddir_exp = 0.0;      variable->Ddir_exp = 0.0;
         variable->Dpilaexp = 0.0;       variable->Dpilaexp = 0.0; 
         variable->Destadoexp = 0.0;       variable->Destadoexp = 0.0; 
                           
         variable->Ddatoimp = 0.0;       variable->Ddatoimp = 0.0; 
         variable->Ddir_imp = 0.0;       variable->Ddir_imp = 0.0; 
         variable->Dpilaimp = 0.0;       variable->Dpilaimp = 0.0; 
         variable->Destadoimp = 0.0;       variable->Destadoimp = 0.0; 
   
         variable->ADdatoexp = 0.0;       variable->ADdatoexp = 0.0; 
         variable->ADdir_exp = 0.0;       variable->ADdir_exp = 0.0; 
         variable->ADpilaexp = 0.0;       variable->ADpilaexp = 0.0; 
         variable->ADestadoexp = 0.0;       variable->ADestadoexp = 0.0; 
                           
         variable->ADdatoimp = 0.0;       variable->ADdatoimp = 0.0; 
         variable->ADdir_imp = 0.0;       variable->ADdir_imp = 0.0; 
         variable->ADpilaimp = 0.0;       variable->ADpilaimp = 0.0; 
         variable->ADestadoimp = 0.0;       variable->ADestadoimp = 0.0; 
   
         variable->Sdatoexp = 0.0;       variable->Sdatoexp = 0.0; 
         variable->Sdir_exp = 0.0;       variable->Sdir_exp = 0.0; 
         variable->Spilaexp = 0.0;       variable->Spilaexp = 0.0; 
         variable->Sestadoexp = 0.0;       variable->Sestadoexp = 0.0; 
                           
         variable->Sdatoimp = 0.0;       variable->Sdatoimp = 0.0; 
         variable->Sdir_imp = 0.0;       variable->Sdir_imp = 0.0; 
         variable->Spilaimp = 0.0;       variable->Spilaimp = 0.0; 
         variable->Sestadoimp = 0.0;       variable->Sestadoimp = 0.0; 
   
         variable->D = 0.0;       variable->D = 0.0; 
 }  }
   
   
Line 524  void IniciarVariableAgregada(parametroma Line 491  void IniciarVariableAgregada(parametroma
 /*  /*
 void CalcularPromedioVariableAgregada(parametromatriz *media, parametromatriz *actual, unsigned long n)  void CalcularPromedioVariableAgregada(parametromatriz *media, parametromatriz *actual, unsigned long n)
 {  {
         if(matriz.Ddatoexp != NULL) media->Ddatoexp = ((n - 1) * media->Ddatoexp + actual->Ddatoexp) / 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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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; 
 }  }
 */  */
   
Line 565  void CalcularPromedioVariableAgregada(pa Line 532  void CalcularPromedioVariableAgregada(pa
   
 void CalcularPromedioVariableAgregada(parametromatriz *media, parametromatriz *actual, unsigned long n)  void CalcularPromedioVariableAgregada(parametromatriz *media, parametromatriz *actual, unsigned long n)
 {  {
         if(matriz.Ddatoexp != NULL) media->Ddatoexp = CalcularNuevoPromedio(media->Ddatoexp, actual->Ddatoexp, 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.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.Dpilaexp != NULL) media->Dpilaexp = CalcularNuevoPromedio(media->Dpilaexp, actual->Dpilaexp, n); 
         if(matriz.Destadoexp != NULL) media->Destadoexp = CalcularNuevoPromedio(media->Destadoexp, actual->Destadoexp, 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.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.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.Dpilaimp != NULL) media->Dpilaimp = CalcularNuevoPromedio(media->Dpilaimp, actual->Dpilaimp, n); 
         if(matriz.Destadoimp != NULL) media->Destadoimp = CalcularNuevoPromedio(media->Destadoimp, actual->Destadoimp, 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.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.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.ADpilaexp != NULL) media->ADpilaexp = CalcularNuevoPromedio(media->ADpilaexp, actual->ADpilaexp, n); 
         if(matriz.ADestadoexp != NULL) media->ADestadoexp = CalcularNuevoPromedio(media->ADestadoexp, actual->ADestadoexp, 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.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.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.ADpilaimp != NULL) media->ADpilaimp = CalcularNuevoPromedio(media->ADpilaimp, actual->ADpilaimp, n); 
         if(matriz.ADestadoimp != NULL) media->ADestadoimp = CalcularNuevoPromedio(media->ADestadoimp, actual->ADestadoimp, 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.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.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.Spilaexp != NULL) media->Spilaexp = CalcularNuevoPromedio(media->Spilaexp, actual->Spilaexp, n); 
         if(matriz.Sestadoexp != NULL) media->Sestadoexp = CalcularNuevoPromedio(media->Sestadoexp, actual->Sestadoexp, 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.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.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.Spilaimp != NULL) media->Spilaimp = CalcularNuevoPromedio(media->Spilaimp, actual->Spilaimp, n); 
         if(matriz.Sestadoimp != NULL) media->Sestadoimp = CalcularNuevoPromedio(media->Sestadoimp, actual->Sestadoimp, 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); 
 }  }
   
   
Line 606  void CalcularPromedioVariableAgregada(pa Line 573  void CalcularPromedioVariableAgregada(pa
   
 void CalcularPasosComputacion(parametromatriz *pasos)  void CalcularPasosComputacion(parametromatriz *pasos)
 {  {
         if(matriz.Ddatoexp != NULL) pasos->Ddatoexp = ListaOrdenParcial(matriz.Ddatoexp, 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.Ddir_exp != NULL) pasos->Ddir_exp = ListaOrdenParcial(matriz.Ddir_exp, NULL);
         if(matriz.Dpilaexp != NULL) pasos->Dpilaexp = ListaOrdenParcial(matriz.Dpilaexp, NULL);       if(matriz.Dpilaexp != NULL) pasos->Dpilaexp = ListaOrdenParcial(matriz.Dpilaexp, NULL); 
         if(matriz.Destadoexp != NULL) pasos->Destadoexp = ListaOrdenParcial(matriz.Destadoexp, NULL);       if(matriz.Destadoexp != NULL) pasos->Destadoexp = ListaOrdenParcial(matriz.Destadoexp, NULL); 
                           
         if(matriz.Ddatoimp != NULL) pasos->Ddatoimp = ListaOrdenParcial(matriz.Ddatoimp, 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.Ddir_imp != NULL) pasos->Ddir_imp = ListaOrdenParcial(matriz.Ddir_imp, NULL); 
         if(matriz.Dpilaimp != NULL) pasos->Dpilaimp = ListaOrdenParcial(matriz.Dpilaimp, NULL);       if(matriz.Dpilaimp != NULL) pasos->Dpilaimp = ListaOrdenParcial(matriz.Dpilaimp, NULL); 
         if(matriz.Destadoimp != NULL) pasos->Destadoimp = ListaOrdenParcial(matriz.Destadoimp, NULL);       if(matriz.Destadoimp != NULL) pasos->Destadoimp = ListaOrdenParcial(matriz.Destadoimp, NULL); 
   
         if(matriz.ADdatoexp != NULL) pasos->ADdatoexp = ListaOrdenParcial(matriz.ADdatoexp, 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.ADdir_exp != NULL) pasos->ADdir_exp = ListaOrdenParcial(matriz.ADdir_exp, NULL); 
         if(matriz.ADpilaexp != NULL) pasos->ADpilaexp = ListaOrdenParcial(matriz.ADpilaexp, NULL);       if(matriz.ADpilaexp != NULL) pasos->ADpilaexp = ListaOrdenParcial(matriz.ADpilaexp, NULL); 
         if(matriz.ADestadoexp != NULL) pasos->ADestadoexp = ListaOrdenParcial(matriz.ADestadoexp, NULL);       if(matriz.ADestadoexp != NULL) pasos->ADestadoexp = ListaOrdenParcial(matriz.ADestadoexp, NULL); 
                           
         if(matriz.ADdatoimp != NULL) pasos->ADdatoimp = ListaOrdenParcial(matriz.ADdatoimp, 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.ADdir_imp != NULL) pasos->ADdir_imp = ListaOrdenParcial(matriz.ADdir_imp, NULL); 
         if(matriz.ADpilaimp != NULL) pasos->ADpilaimp = ListaOrdenParcial(matriz.ADpilaimp, NULL);       if(matriz.ADpilaimp != NULL) pasos->ADpilaimp = ListaOrdenParcial(matriz.ADpilaimp, NULL); 
         if(matriz.ADestadoimp != NULL) pasos->ADestadoimp = ListaOrdenParcial(matriz.ADestadoimp, NULL);       if(matriz.ADestadoimp != NULL) pasos->ADestadoimp = ListaOrdenParcial(matriz.ADestadoimp, NULL); 
   
         if(matriz.Sdatoexp != NULL) pasos->Sdatoexp = ListaOrdenParcial(matriz.Sdatoexp, 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.Sdir_exp != NULL) pasos->Sdir_exp = ListaOrdenParcial(matriz.Sdir_exp, NULL); 
         if(matriz.Spilaexp != NULL) pasos->Spilaexp = ListaOrdenParcial(matriz.Spilaexp, NULL);       if(matriz.Spilaexp != NULL) pasos->Spilaexp = ListaOrdenParcial(matriz.Spilaexp, NULL); 
         if(matriz.Sestadoexp != NULL) pasos->Sestadoexp = ListaOrdenParcial(matriz.Sestadoexp, NULL);       if(matriz.Sestadoexp != NULL) pasos->Sestadoexp = ListaOrdenParcial(matriz.Sestadoexp, NULL); 
                           
         if(matriz.Sdatoimp != NULL) pasos->Sdatoimp = ListaOrdenParcial(matriz.Sdatoimp, 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.Sdir_imp != NULL) pasos->Sdir_imp = ListaOrdenParcial(matriz.Sdir_imp, NULL); 
         if(matriz.Spilaimp != NULL) pasos->Spilaimp = ListaOrdenParcial(matriz.Spilaimp, NULL);       if(matriz.Spilaimp != NULL) pasos->Spilaimp = ListaOrdenParcial(matriz.Spilaimp, NULL); 
         if(matriz.Sestadoimp != NULL) pasos->Sestadoimp = ListaOrdenParcial(matriz.Sestadoimp, 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); 
 }  }
   
   
Line 647  void CalcularPasosComputacion(parametrom Line 614  void CalcularPasosComputacion(parametrom
 /*  /*
 void CalcularGradoParalelismo(parametromatriz *pasos, parametromatriz *grado)  void CalcularGradoParalelismo(parametromatriz *pasos, parametromatriz *grado)
 {  {
         if(matriz.Ddatoexp != NULL) grado->Ddatoexp = 1 / pasos->Ddatoexp;      if(matriz.Ddatoexp != NULL) grado->Ddatoexp = 1 / pasos->Ddatoexp;
         if(matriz.Ddir_exp != NULL) grado->Ddir_exp = 1 / pasos->Ddir_exp;      if(matriz.Ddir_exp != NULL) grado->Ddir_exp = 1 / pasos->Ddir_exp;
         if(matriz.Dpilaexp != NULL) grado->Dpilaexp = 1 / pasos->Dpilaexp;       if(matriz.Dpilaexp != NULL) grado->Dpilaexp = 1 / pasos->Dpilaexp; 
         if(matriz.Destadoexp != NULL) grado->Destadoexp = 1 / pasos->Destadoexp;       if(matriz.Destadoexp != NULL) grado->Destadoexp = 1 / pasos->Destadoexp; 
                           
         if(matriz.Ddatoimp != NULL) grado->Ddatoimp = 1 / pasos->Ddatoimp;       if(matriz.Ddatoimp != NULL) grado->Ddatoimp = 1 / pasos->Ddatoimp; 
         if(matriz.Ddir_imp != NULL) grado->Ddir_imp = 1 / pasos->Ddir_imp;       if(matriz.Ddir_imp != NULL) grado->Ddir_imp = 1 / pasos->Ddir_imp; 
         if(matriz.Dpilaimp != NULL) grado->Dpilaimp = 1 / pasos->Dpilaimp;       if(matriz.Dpilaimp != NULL) grado->Dpilaimp = 1 / pasos->Dpilaimp; 
         if(matriz.Destadoimp != NULL) grado->Destadoimp = 1 / pasos->Destadoimp;       if(matriz.Destadoimp != NULL) grado->Destadoimp = 1 / pasos->Destadoimp; 
   
         if(matriz.ADdatoexp != NULL) grado->ADdatoexp = 1 / pasos->ADdatoexp;       if(matriz.ADdatoexp != NULL) grado->ADdatoexp = 1 / pasos->ADdatoexp; 
         if(matriz.ADdir_exp != NULL) grado->ADdir_exp = 1 / pasos->ADdir_exp;       if(matriz.ADdir_exp != NULL) grado->ADdir_exp = 1 / pasos->ADdir_exp; 
         if(matriz.ADpilaexp != NULL) grado->ADpilaexp = 1 / pasos->ADpilaexp;       if(matriz.ADpilaexp != NULL) grado->ADpilaexp = 1 / pasos->ADpilaexp; 
         if(matriz.ADestadoexp != NULL) grado->ADestadoexp = 1 / pasos->ADestadoexp;       if(matriz.ADestadoexp != NULL) grado->ADestadoexp = 1 / pasos->ADestadoexp; 
                           
         if(matriz.ADdatoimp != NULL) grado->ADdatoimp = 1 / pasos->ADdatoimp;       if(matriz.ADdatoimp != NULL) grado->ADdatoimp = 1 / pasos->ADdatoimp; 
         if(matriz.ADdir_imp != NULL) grado->ADdir_imp = 1 / pasos->ADdir_imp;       if(matriz.ADdir_imp != NULL) grado->ADdir_imp = 1 / pasos->ADdir_imp; 
         if(matriz.ADpilaimp != NULL) grado->ADpilaimp = 1 / pasos->ADpilaimp;       if(matriz.ADpilaimp != NULL) grado->ADpilaimp = 1 / pasos->ADpilaimp; 
         if(matriz.ADestadoimp != NULL) grado->ADestadoimp = 1 / pasos->ADestadoimp;       if(matriz.ADestadoimp != NULL) grado->ADestadoimp = 1 / pasos->ADestadoimp; 
   
         if(matriz.Sdatoexp != NULL) grado->Sdatoexp = 1 / pasos->Sdatoexp;       if(matriz.Sdatoexp != NULL) grado->Sdatoexp = 1 / pasos->Sdatoexp; 
         if(matriz.Sdir_exp != NULL) grado->Sdir_exp = 1 / pasos->Sdir_exp;       if(matriz.Sdir_exp != NULL) grado->Sdir_exp = 1 / pasos->Sdir_exp; 
         if(matriz.Spilaexp != NULL) grado->Spilaexp = 1 / pasos->Spilaexp;       if(matriz.Spilaexp != NULL) grado->Spilaexp = 1 / pasos->Spilaexp; 
         if(matriz.Sestadoexp != NULL) grado->Sestadoexp = 1 / pasos->Sestadoexp;       if(matriz.Sestadoexp != NULL) grado->Sestadoexp = 1 / pasos->Sestadoexp; 
                           
         if(matriz.Sdatoimp != NULL) grado->Sdatoimp = 1 / pasos->Sdatoimp;       if(matriz.Sdatoimp != NULL) grado->Sdatoimp = 1 / pasos->Sdatoimp; 
         if(matriz.Sdir_imp != NULL) grado->Sdir_imp = 1 / pasos->Sdir_imp;       if(matriz.Sdir_imp != NULL) grado->Sdir_imp = 1 / pasos->Sdir_imp; 
         if(matriz.Spilaimp != NULL) grado->Spilaimp = 1 / pasos->Spilaimp;       if(matriz.Spilaimp != NULL) grado->Spilaimp = 1 / pasos->Spilaimp; 
         if(matriz.Sestadoimp != NULL) grado->Sestadoimp = 1 / pasos->Sestadoimp;       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; 
 }  }
   
 */  */
Line 689  void CalcularGradoParalelismo(parametrom Line 656  void CalcularGradoParalelismo(parametrom
   
 void CalcularGradoParalelismoNormalizado(parametromatriz *pasos, parametromatriz *grado)  void CalcularGradoParalelismoNormalizado(parametromatriz *pasos, parametromatriz *grado)
 {  {
         unsigned int dim;      unsigned int dim;
   
         dim = configuracion.ventana;      dim = configuracion.ventana;
               
         if(matriz.Ddatoexp != NULL) grado->Ddatoexp = InversoNormalizado(dim, pasos->Ddatoexp);      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.Ddir_exp != NULL) grado->Ddir_exp = InversoNormalizado(dim, pasos->Ddir_exp);
         if(matriz.Dpilaexp != NULL) grado->Dpilaexp = InversoNormalizado(dim, pasos->Dpilaexp);       if(matriz.Dpilaexp != NULL) grado->Dpilaexp = InversoNormalizado(dim, pasos->Dpilaexp); 
         if(matriz.Destadoexp != NULL) grado->Destadoexp = InversoNormalizado(dim, pasos->Destadoexp);       if(matriz.Destadoexp != NULL) grado->Destadoexp = InversoNormalizado(dim, pasos->Destadoexp); 
                           
         if(matriz.Ddatoimp != NULL) grado->Ddatoimp = InversoNormalizado(dim, pasos->Ddatoimp);       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.Ddir_imp != NULL) grado->Ddir_imp = InversoNormalizado(dim, pasos->Ddir_imp); 
         if(matriz.Dpilaimp != NULL) grado->Dpilaimp = InversoNormalizado(dim, pasos->Dpilaimp);       if(matriz.Dpilaimp != NULL) grado->Dpilaimp = InversoNormalizado(dim, pasos->Dpilaimp); 
         if(matriz.Destadoimp != NULL) grado->Destadoimp = InversoNormalizado(dim, pasos->Destadoimp);       if(matriz.Destadoimp != NULL) grado->Destadoimp = InversoNormalizado(dim, pasos->Destadoimp); 
   
         if(matriz.ADdatoexp != NULL) grado->ADdatoexp = InversoNormalizado(dim, pasos->ADdatoexp);       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.ADdir_exp != NULL) grado->ADdir_exp = InversoNormalizado(dim, pasos->ADdir_exp); 
         if(matriz.ADpilaexp != NULL) grado->ADpilaexp = InversoNormalizado(dim, pasos->ADpilaexp);       if(matriz.ADpilaexp != NULL) grado->ADpilaexp = InversoNormalizado(dim, pasos->ADpilaexp); 
         if(matriz.ADestadoexp != NULL) grado->ADestadoexp = InversoNormalizado(dim, pasos->ADestadoexp);       if(matriz.ADestadoexp != NULL) grado->ADestadoexp = InversoNormalizado(dim, pasos->ADestadoexp); 
                           
         if(matriz.ADdatoimp != NULL) grado->ADdatoimp = InversoNormalizado(dim, pasos->ADdatoimp);       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.ADdir_imp != NULL) grado->ADdir_imp = InversoNormalizado(dim, pasos->ADdir_imp); 
         if(matriz.ADpilaimp != NULL) grado->ADpilaimp = InversoNormalizado(dim, pasos->ADpilaimp);       if(matriz.ADpilaimp != NULL) grado->ADpilaimp = InversoNormalizado(dim, pasos->ADpilaimp); 
         if(matriz.ADestadoimp != NULL) grado->ADestadoimp = InversoNormalizado(dim, pasos->ADestadoimp);       if(matriz.ADestadoimp != NULL) grado->ADestadoimp = InversoNormalizado(dim, pasos->ADestadoimp); 
   
         if(matriz.Sdatoexp != NULL) grado->Sdatoexp = InversoNormalizado(dim, pasos->Sdatoexp);       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.Sdir_exp != NULL) grado->Sdir_exp = InversoNormalizado(dim, pasos->Sdir_exp); 
         if(matriz.Spilaexp != NULL) grado->Spilaexp = InversoNormalizado(dim, pasos->Spilaexp);       if(matriz.Spilaexp != NULL) grado->Spilaexp = InversoNormalizado(dim, pasos->Spilaexp); 
         if(matriz.Sestadoexp != NULL) grado->Sestadoexp = InversoNormalizado(dim, pasos->Sestadoexp);       if(matriz.Sestadoexp != NULL) grado->Sestadoexp = InversoNormalizado(dim, pasos->Sestadoexp); 
                           
         if(matriz.Sdatoimp != NULL) grado->Sdatoimp = InversoNormalizado(dim, pasos->Sdatoimp);       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.Sdir_imp != NULL) grado->Sdir_imp = InversoNormalizado(dim, pasos->Sdir_imp); 
         if(matriz.Spilaimp != NULL) grado->Spilaimp = InversoNormalizado(dim, pasos->Spilaimp);       if(matriz.Spilaimp != NULL) grado->Spilaimp = InversoNormalizado(dim, pasos->Spilaimp); 
         if(matriz.Sestadoimp != NULL) grado->Sestadoimp = InversoNormalizado(dim, pasos->Sestadoimp);       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); 
 }  }
   
   
Line 731  void CalcularGradoParalelismoNormalizado Line 698  void CalcularGradoParalelismoNormalizado
   
 void CalcularAcoplamiento(parametromatriz *acoplamiento)  void CalcularAcoplamiento(parametromatriz *acoplamiento)
 {  {
         if(matriz.Ddatoexp != NULL) acoplamiento->Ddatoexp = Acoplamiento(matriz.Ddatoexp);      if(matriz.Ddatoexp != NULL) acoplamiento->Ddatoexp = Acoplamiento(matriz.Ddatoexp);
         if(matriz.Ddir_exp != NULL) acoplamiento->Ddir_exp = Acoplamiento(matriz.Ddir_exp);      if(matriz.Ddir_exp != NULL) acoplamiento->Ddir_exp = Acoplamiento(matriz.Ddir_exp);
         if(matriz.Dpilaexp != NULL) acoplamiento->Dpilaexp = Acoplamiento(matriz.Dpilaexp);       if(matriz.Dpilaexp != NULL) acoplamiento->Dpilaexp = Acoplamiento(matriz.Dpilaexp); 
         if(matriz.Destadoexp != NULL) acoplamiento->Destadoexp = Acoplamiento(matriz.Destadoexp);       if(matriz.Destadoexp != NULL) acoplamiento->Destadoexp = Acoplamiento(matriz.Destadoexp); 
                           
         if(matriz.Ddatoimp != NULL) acoplamiento->Ddatoimp = Acoplamiento(matriz.Ddatoimp);       if(matriz.Ddatoimp != NULL) acoplamiento->Ddatoimp = Acoplamiento(matriz.Ddatoimp); 
         if(matriz.Ddir_imp != NULL) acoplamiento->Ddir_imp = Acoplamiento(matriz.Ddir_imp);       if(matriz.Ddir_imp != NULL) acoplamiento->Ddir_imp = Acoplamiento(matriz.Ddir_imp); 
         if(matriz.Dpilaimp != NULL) acoplamiento->Dpilaimp = Acoplamiento(matriz.Dpilaimp);       if(matriz.Dpilaimp != NULL) acoplamiento->Dpilaimp = Acoplamiento(matriz.Dpilaimp); 
         if(matriz.Destadoimp != NULL) acoplamiento->Destadoimp = Acoplamiento(matriz.Destadoimp);       if(matriz.Destadoimp != NULL) acoplamiento->Destadoimp = Acoplamiento(matriz.Destadoimp); 
   
         if(matriz.ADdatoexp != NULL) acoplamiento->ADdatoexp = Acoplamiento(matriz.ADdatoexp);       if(matriz.ADdatoexp != NULL) acoplamiento->ADdatoexp = Acoplamiento(matriz.ADdatoexp); 
         if(matriz.ADdir_exp != NULL) acoplamiento->ADdir_exp = Acoplamiento(matriz.ADdir_exp);       if(matriz.ADdir_exp != NULL) acoplamiento->ADdir_exp = Acoplamiento(matriz.ADdir_exp); 
         if(matriz.ADpilaexp != NULL) acoplamiento->ADpilaexp = Acoplamiento(matriz.ADpilaexp);       if(matriz.ADpilaexp != NULL) acoplamiento->ADpilaexp = Acoplamiento(matriz.ADpilaexp); 
         if(matriz.ADestadoexp != NULL) acoplamiento->ADestadoexp = Acoplamiento(matriz.ADestadoexp);       if(matriz.ADestadoexp != NULL) acoplamiento->ADestadoexp = Acoplamiento(matriz.ADestadoexp); 
                           
         if(matriz.ADdatoimp != NULL) acoplamiento->ADdatoimp = Acoplamiento(matriz.ADdatoimp);       if(matriz.ADdatoimp != NULL) acoplamiento->ADdatoimp = Acoplamiento(matriz.ADdatoimp); 
         if(matriz.ADdir_imp != NULL) acoplamiento->ADdir_imp = Acoplamiento(matriz.ADdir_imp);       if(matriz.ADdir_imp != NULL) acoplamiento->ADdir_imp = Acoplamiento(matriz.ADdir_imp); 
         if(matriz.ADpilaimp != NULL) acoplamiento->ADpilaimp = Acoplamiento(matriz.ADpilaimp);       if(matriz.ADpilaimp != NULL) acoplamiento->ADpilaimp = Acoplamiento(matriz.ADpilaimp); 
         if(matriz.ADestadoimp != NULL) acoplamiento->ADestadoimp = Acoplamiento(matriz.ADestadoimp);       if(matriz.ADestadoimp != NULL) acoplamiento->ADestadoimp = Acoplamiento(matriz.ADestadoimp); 
   
         if(matriz.Sdatoexp != NULL) acoplamiento->Sdatoexp = Acoplamiento(matriz.Sdatoexp);       if(matriz.Sdatoexp != NULL) acoplamiento->Sdatoexp = Acoplamiento(matriz.Sdatoexp); 
         if(matriz.Sdir_exp != NULL) acoplamiento->Sdir_exp = Acoplamiento(matriz.Sdir_exp);       if(matriz.Sdir_exp != NULL) acoplamiento->Sdir_exp = Acoplamiento(matriz.Sdir_exp); 
         if(matriz.Spilaexp != NULL) acoplamiento->Spilaexp = Acoplamiento(matriz.Spilaexp);       if(matriz.Spilaexp != NULL) acoplamiento->Spilaexp = Acoplamiento(matriz.Spilaexp); 
         if(matriz.Sestadoexp != NULL) acoplamiento->Sestadoexp = Acoplamiento(matriz.Sestadoexp);       if(matriz.Sestadoexp != NULL) acoplamiento->Sestadoexp = Acoplamiento(matriz.Sestadoexp); 
                           
         if(matriz.Sdatoimp != NULL) acoplamiento->Sdatoimp = Acoplamiento(matriz.Sdatoimp);       if(matriz.Sdatoimp != NULL) acoplamiento->Sdatoimp = Acoplamiento(matriz.Sdatoimp); 
         if(matriz.Sdir_imp != NULL) acoplamiento->Sdir_imp = Acoplamiento(matriz.Sdir_imp);       if(matriz.Sdir_imp != NULL) acoplamiento->Sdir_imp = Acoplamiento(matriz.Sdir_imp); 
         if(matriz.Spilaimp != NULL) acoplamiento->Spilaimp = Acoplamiento(matriz.Spilaimp);       if(matriz.Spilaimp != NULL) acoplamiento->Spilaimp = Acoplamiento(matriz.Spilaimp); 
         if(matriz.Sestadoimp != NULL) acoplamiento->Sestadoimp = Acoplamiento(matriz.Sestadoimp);       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); 
 }  }
   
   
Line 771  void CalcularAcoplamiento(parametromatri Line 738  void CalcularAcoplamiento(parametromatri
   
 void CrearHistogramaPasos()  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)      if (distribucionpasos == NULL)
     {      {
         sprintf(mensaje, "[CrearHistogramaPasos] Memoria insuficiente");          sprintf(mensaje, "[CrearHistogramaPasos] Memoria insuficiente");
                 Notificar(mensaje, ERROR_SALIR, ECO_NO);          Notificar(mensaje, ERROR_SALIR, ECO_NO);
                 /* el programa finaliza si no hay memoria suficiente */          /* el programa finaliza si no hay memoria suficiente */
     }      }
 }  }
   
Line 787  void CrearHistogramaPasos() Line 754  void CrearHistogramaPasos()
   
 void IniciarHistogramaPasos()  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;
 }  }
   
   
Line 797  void IniciarHistogramaPasos() Line 764  void IniciarHistogramaPasos()
   
 void LiberarMemoriaHistogramaPasos()  void LiberarMemoriaHistogramaPasos()
 {  {
         free(distribucionpasos);      free(distribucionpasos);
 }  }
   
   
Line 805  void LiberarMemoriaHistogramaPasos() Line 772  void LiberarMemoriaHistogramaPasos()
   
 void ActualizarHistogramaPasos()  void ActualizarHistogramaPasos()
 {  {
         distribucionpasos[(unsigned int)pasos->D]++;      distribucionpasos[(unsigned int)pasos->D]++;
 }  }
   
Removed from v.1.1  
changed lines
  Added in v.1.2

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>