1 Especificaciones y Análisis

Transcripción

1 : Práctica 1

2 1 Especificaciones y Análisis 1.1 Especificaciones La práctica se centra en dominar los conceptos más elementales de C (Bucles, Vectores, Ficheros, Funciones con argumentos por valor y referencia, creación de todos estos elementos mediante prototipos separados del programa principal), para su uso posterior en practicas futuras Especificaciones Particulares Ejercicio 1 El primer ejercicio pide generar una rutina que genere un numero aleatorio equiprobable entre dos valores (MAX,MIN) que se le pasan a la función. La forma de resolución de este programa reside en encontrar una formula que permita dar números aleatorios por igual: return ip + (int) ( ( (double) (iu-ip+1) * rand() ) / (RAND_MAX+1.0) ); Con esta ecuación obtenemos valores aleatorios equiprobables entre iu e ip, la explicación es bien sencilla, al restar el Max-Min y sumarle uno obtenemos el rango de posibles valores, si multiplicamos por rand() y dividimos por el valor máximo de rand() + 1 el resultado, como máximo va a ser iu-ip y como mínimo va a ser cero, por lo que al sumar el Min siempre va a dar un numero entre ambos valores Especificaciones Particulares Ejercicio 2 Este ejercicio nos pide una rutina que genere permutaciones aleatorias entre 0 y N, para generar dicha rutina se nos facilita el siguiente pseudocódigo: para i de 1 a N: perm[i] = i; para i de 1 a N: intercambiar perm[i] con perm[aleator(i, N)]; Especificaciones Particulares Ejercicio 3 El tercer programa nos pide generar una rutina que llame a la rutina del ejercicio 2, pasándole a la rutina del ejercicio 2, el valor M, nos generara tantas permutaciones como veces se la llame mediante el parámetro N Especificaciones Particulares Ejercicio 4 Éste apartado nos pide dar el código de una rutina que ordene las permutaciones generadas por los ejercicios anteriores Especificaciones Particulares Ejercicio 5 Éste programa tiene como finalidad determinar experimentalmente el tiempo medio de ejecución por inserción sobre tablas de diferentes tamaños, para ello la rutina recurre a las rutinas generadas en los ejercicios anteriores para generar las permutaciones y ordenarlas, además de la rutina Driver_Ordena, en este ejercicio se pide generar una 2

3 rutina que escriba en un fichero el tiempo medio de ejecución del algoritmo de ordenación para n_perms. 1.2 Análisis Análisis Particular Ejercicio 1 Para realizar el histograma, se nos planteo la posibilidad de hacerlo mediante el Gnuplot, los datos se los podíamos pasar de dos maneras generando en la propia función un fichero donde guardar los valores y las veces que se repiten, o mediante la siguiente línea de código en Linux vamos metiendo en un fichero las veces que se repite cada numero: Grep numero salida.txt wc l >>distribución.txt, se generaba el fichero, esta segunda forma es la que hemos usado para generar las graficas en el Gnuplot y de esta forma no modificar la función Análisis Particular Ejercicio 2 En este ejercicio no se encontraba dificultad aparente si el primer ejercicio poseía un algoritmo correcto Análisis Particular Ejercicio 3 El trabajo con punteros es el elemento principal de éste ejercicio. Lo más importante es cubrir los casos para errores en la reserva de memoria y su posterior liberación Análisis Particular Ejercicio 4 En este ejercicio la principal dificultad se podía encontrar en el diseño del código de ordenación Análisis Particular Ejercicio 5 La principal característica de este ejercicio es la medición del tiempo de ejecución de un método, teniendo claro los ejercicios anteriores este ejercicio solo planteaba la dificultad de medir el tiempo que se solucionaba mediante la instrucción clock(). 2 Diseño 2.1 Estructuras y Tipos Abstractos de Datos Estructura de ordena.h typedef int (*pfunc_pivote) (int, int); typedef int (*pfunc_ordena) (int *, int, int, pfunc_pivote); int aleator(int ip,int iu); int *genera_perm(int n); int **driver(int N,int M); int InsertSort(int *tabla,int P,int U,pfunc_pivote pivote); double Driver_Ordena(pfunc_ordena metodo, pfunc_pivote pivote, int n_perms, int tamanio); 3

4 int Time_Ordena(pfunc_ordena metodo, pfunc_pivote pivote, char *fichero, int num_min, int num_max, int incr, int n_perms); short GuardaTabla_double(char *fichero, double *tiempo, int *tamanio, int N); 2.2 Algoritmo A continuación adjuntamos el código de las funciones con los algoritmos Fichero ordenar.c /*FUNCIÓN: aleator*/ int aleator(int ip,int iu) return ip + (int) ( ( (double) (iu-ip+1) * rand() ) / (RAND_MAX+1.0) ); /*FUNCIÓN: genera_perm*/ int *genera_perm(int n) int i, aleat, temp; int *perm = NULL; if(n<=0) return NULL; perm = (int *) malloc(n*sizeof (int)); if(perm == NULL) return NULL; for(i=0; i<n; i++) perm[i] = i; for(i=0; i<n; i++) aleat = aleator(0, n-1); temp=perm[i]; 4

5 perm[i]=perm[aleat]; perm[aleat]=temp; return perm; /*FUNCIÓN: driver*/ int **driver(int N,int M) int i; int **perms; if(n<=0 M <=0) return NULL; perms=(int **) malloc(n*sizeof(int *)); if(perms == NULL) return NULL; for(i=0; i<n; i++) perms[i]=genera_perm(m); if(perms[i] == NULL) for(--i; i>=0; i--) free((void *)perms[i]); return NULL; return perms; /*FUNCIÓN: InsertSort*/ int InsertSort(int *tabla,int P,int U,pfunc_pivote pivote) int i, j, temp; 5

6 if(p<0 U<0 P>U) return ERR; if(p==u) return OK; for(i=1; i<(u-p+1); i++) for(j=i; (j>0) && (tabla[j-1] > tabla[j]); j--) temp=tabla[j]; tabla[j]=tabla[j-1]; tabla[j-1]=temp; return OK; /*FUNCIÓN: Driver_Ordena*/ double Driver_Ordena(pfunc_ordena metodo, pfunc_pivote pivote, int n_perms, int tamanio) int i; int **perms = NULL; clock_t start, end; if(metodo == NULL n_perms<0 tamanio<0) return (double)err_time; perms=driver(n_perms, tamanio); if(perms == NULL) return (double)err_time; start = clock(); for(i=0; i<n_perms; i++) if(metodo(perms[i], 0, tamanio, pivote)!= OK) for(i=0; i<n_perms; i++) 6

7 if(perms[i]!= NULL) free((void *)perms[i]); free((void *)perms); return (double)err_time; end = clock(); for(i=0; i<n_perms; i++) if(perms[i]!= NULL) free((void *)perms[i]); free((void *)perms); return (double) (end - start) / (CLOCKS_PER_SEC * n_perms); /*FUNCIÓN: Time_Ordena*/ int Time_Ordena(pfunc_ordena metodo, pfunc_pivote pivote, char *fichero, int num_min, int num_max, int incr, int n_perms) int i, size, num; int *sizes = NULL; double *times = NULL; if(metodo == NULL fichero == NULL num_min<=0 num_max<=0 num_min>num_max) return ERR_TIME; num = (num_max - num_min) / incr + 1; sizes=(int *)malloc(num*sizeof(int)); if(sizes == NULL) return ERR_TIME; times=(double *)malloc(num*sizeof(double)); 7

8 if(times == NULL) return ERR_TIME; for(i=0, size=num_min; i<num; i++, size+=incr) sizes[i]=size; times[i]=driver_ordena(metodo, pivote, n_perms, size); if(times[i] == ERR_TIME) return ERR_TIME; if(guardatabla_double(fichero, times, sizes, num)!= OK) free((void *)sizes); free((void *)times); return ERR_TIME; free((void *)sizes); free((void *)times); return OK; /*FUNCIÓN: GuardaTabla_double */ short GuardaTabla_double(char *fichero, double *tiempo, int *tamanio, int N) int i; FILE *f_handler = NULL; f_handler = fopen(fichero, "w+"); if(f_handler == NULL) return (short) ERR; for(i=0; i<n; i++) fprintf(f_handler, "%d %f\n", tamanio[i], tiempo[i]); fclose(f_handler); return (short) OK; 8

9 2.3 Organización Módulos y Ficheros Los ejercicios correspondientes a cada uno de los ejercicios de prueba de cada una de las rutinas estan estructurados y compilados mediante el MakeFile: CC=gcc INC_DIRS = LIB_DIRS = LIBS = CFLAGS = $(INC_DIRS) -ggdb -Wall LDFLAGS = $(LIB_DIRS) $(LIB) all: ej1 ej2 ej3 ej4 ej5 clean: rm -rf ej1 ej2 ej3 ej4 ej5 *.o core ej1: ej1.o ordenar.o $(CC) $(LDFLAGS) -o $@ $^ ej2: ej2.o ordenar.o $(CC) $(LDFLAGS) -o $@ $^ ej3: ej3.o ordenar.o $(CC) $(LDFLAGS) -o $@ $^ ej4: ej4.o ordenar.o $(CC) $(LDFLAGS) -o $@ $^ ej5: ej5.o ordenar.o $(CC) $(LDFLAGS) -o $@ $^ ordenar.o: ordenar.c ordenar.h ej1.o: ej1.c ordenar.h ej2.o: ej2.c ordenar.h ej3.o: ej3.c ordenar.h ej4.o: ej4.c ordenar.h ej5.o: ej5.c ordenar.h 2.4 Documentación Funciones Importantes /*FUNCIÓN: aleator*/ /*ENTRADA: int ip: limite inferior int iu: limite superior */ /*SALIDA: int: numero aleatorio */ 9

10 /*DESCRIPCIÓN: Rutina que genera un numero aleatorio entre dos numeros dados */ /*FUNCIÓN: genera_perm*/ /*ENTRADA: int n: Numero de elementos de la permutación */ /*SALIDA: int *: puntero a un array de entero que contiene a la permutación o NULL en caso de error */ /*DESCRIPCIÓN: Rutina que genera una permutación aleatoria */ /*FUNCIÓN: driver*/ /*ENTRADA: int N: Numero de permutaciones int M: Numero de elementos de cada permutacion */ /*SALIDA: int **:array de punteros a enteros que apuntan a cada una de las permutaciones NULL en caso de error */ /*DESCRIPCIÓN: Rutina que genera N permutaciones aleatorias de M elementos*/ /*FUNCIÓN: InsertSort*/ /*ENTRADA: int *tabla: Direccion del primer elemento de la tabla, int P: Primer elemento de la tabla, int U: Ultimo elemento de la tabla, pfunc_pivot pivote: Metodo de ordenacion (en esta practica NULL) */ /*SALIDA: OK: Ordenación correcta ERR: Se ha producido un error */ /*DESCRIPCIÓN: Rutina que ordena una tabla, que va desde un primer elemento P, hasta un ultimo U */ /*FUNCIÓN: Driver_Ordena*/ /*ENTRADA: pfunc_ordena metodo: Puntero a la función de ordenación, pfunc_pivote pivote: Método de ordenación (en esta practica NULL), int n_perms: numero de permutaciones a generar y ordenar, int tamanio:tamaño de las permutaciones */ /*SALIDA: Double: Tiempo medio de ejecución o -1 en caso de ERR */ /*DESCRIPCIÓN: Rutina que calcula el tiempo medio de ejecución del algoritmo de ordenación sobre una permutación */ /*FUNCIÓN: Time_Ordena*/ 10

11 /*ENTRADA: pfunc_ordena metodo: Puntero a la funcion de ordenacion, pfunc_pivote pivote: Metodo de ordenacion (en esta practica NULL), char *fichero: Nombre del fichero, int num_min: Numero minimo, int num_max: Numero maximo, int incr: Incremento del tamaño de las permutaciones, int n_perms: Numero de permutaciones a generar y ordenar */ /*SALIDA: OK: El proceso a sido correcto, ERR: Se ha producido algún error */ /*DESCRIPCIÓN: Escribe en un fichero los tiempos medios de ejecución */ /*FUNCIÓN: GuardaTabla_double */ /*ENTRADA: char * fichero: Nombre del fichero, double *tiempo: Puntero a la tabla que contiene el valor de los tiempos de ejecucion, int *tamanio: Puntero a la tabla que contiene el tamaño de las permutaciones, int N: Tamaño de los Arrays */ /*SALIDA: OK : Guardado satisfactoriamente ERR Error durante al guardar */ /*DESCRIPCIÓN: Rutina que almacena en un archivo los tiempos medios de ejecución */ 11

12 3 Resultado /*FUNCIÓN: aleator*/ Los resultados obtenidos se han representado en una grafica mediante el Gnuplot: Como se puede ver la función que hemos implementado es totalmente equiprobable, ya q los valores se repiten por igual. 12

13 /*FUNCIÓN: Time_Ordena*/ La función time_ordena, devuelve el tiempo que tarda la función insert_short en ordenar las permutaciones, con esta grafica se ve que los valores de tiempo aumentan de igual manera que la función x*x: 13