/****************************************************
Nombre del modulo: Ejercicio 2b, practica 1
Descripcion: ---
Autor: David Lopez y Alvaro Gomez
Fecha: 27-02-08
Modulos propios que necesita: Ninguno
Notas: Ninguna
Modificaciones: Ninguna
Mejoras pendientes: ---
****************************************************/

#include <stdio.h>
#include <string.h>
#include <math.h>
#define OK   1
#define ERR -1
#define MAX_ALUMNOS 50
#define MAX_CHAR    256

int leeContenidoFichero(const char * nombreFichero, int num_notas, float * notas);
int ordenaBurbuja(const float * notas_in, float * notas_out, int num_notas);

int percent(const float * notas, int num_notas, int percentil, float * result);
int mediana(const float * notas, int num_notas, float * result);
float media(const float * notas, int num_notas, float * result);
int desviacion(const float * notas, int num_notas, float *result);

int main () {
	int   num_notas, i,control;
	char  tmp[MAX_CHAR],nombreFichero[MAX_CHAR];
	float notaMax, notaMin,notas[MAX_ALUMNOS],notas_ord[MAX_ALUMNOS], result;
	
	/* Peticion del numero de alumnos a solicitar */
	printf("Cuantos alumnos son?\t");
	fgets(tmp, MAX_CHAR, stdin);
	sscanf(tmp,"%d",&num_notas);

		/* En caso de que se introduzca un numero erroneo */
		while (num_notas > MAX_ALUMNOS || num_notas <= 0){
			printf("Parametro no valido, el numero de alumnos ha de ser mayor que cero y menor que %d \n", MAX_ALUMNOS);
			printf("Cuantos alumnos son?\t");
			fgets(tmp, MAX_CHAR, stdin);
			sscanf(tmp,"%d",&num_notas);
		}

	//Peticion del nombre del archivo
	printf("Escriba el nombre del fichero:\t");
	gets(nombreFichero);
	fflush(stdin);
	printf("\n");	
	
	//Lectura del fichero
	control=leeContenidoFichero(nombreFichero,num_notas,notas);

	switch(control){
		case 1:
			printf("Error abriendo el fichero de entrada!\n");
			return ERR;
			break;
		case 2:
			printf("Error en el formato del fichero!\n");
			return ERR;
			break;
	}

	//Obtener la nota maxima y minima
	notaMax = notas[0];
	notaMin = notas[0];
	for(i=1; i<num_notas; i++) {
		if (notas[i] > notaMax) notaMax = notas[i];
			else if (notas[i] < notaMin) notaMin = notas[i];
	}

	/* Salida de la nota mas alta y la mas baja de todos los alumnos inscritos 
	y con la cadena ordenada! */
	printf("No hay mas alumnos...\n\n");
	printf("La nota mas alta ha sido un %2.2f\n", notaMax);
	printf("La nota mas baja ha sido un %2.2f\n", notaMin);
	printf("Las notas, ordenadas: ");
	ordenaBurbuja(notas,notas_ord,num_notas);
	for(i=0; i< num_notas-1; i++) printf("%2.2f, ",notas_ord[i]);
	printf("%2.2f", notas_ord[num_notas-1]);

	/* Estadisticas */
	printf("\n\nEstadisticas:\n");

	/* Percentil */
	percent(notas_ord, num_notas, 75, &result);
	printf("\t* El percentil al 75%% es: %2.2f\n", result);
	
	/* Mediana */	
	mediana(notas_ord, num_notas, &result);
	printf("\t* La mediana es: %2.2f\n", result);

	/* Media */	
	media(notas_ord, num_notas, &result);
	printf("\t* La media es: %2.2f\n", result);
	
	/* Desviacion */
	desviacion(notas_ord, num_notas, &result);
	printf("\t* La desviacion tipica es: %2.2f\n", result);

	return OK;
}

/*------------------------------
Nombre: Leer contenido de Fichero
Descripción: Lee el contenido de un fichero formateado de acuerdo con el enunciado
Argumentos de entrada: El nombre del fichero, el numero de notas y el array donde se guardaran.
Retorno: El array de notas ya lleno de notas.
---------------------------------*/
int leeContenidoFichero(const char * nombreFichero, int num_notas, float * notas) {
	FILE *fich=NULL;
	int i;
	char temp[MAX_CHAR];

	if((fich=fopen(nombreFichero,"r"))==NULL){
		return 1; //Salida de la funcion por error de apertura
	}
	
	for (i=0; i< num_notas;i++){
		if ((fscanf(fich,"%s %f",temp,&notas[i])) == EOF) {
			return 2; //Salida de la funcion por error de lectura
		}
		
		printf("Alumno: %s\t Nota: %2.2f\n",temp,notas[i]);
	}

	return 0;

}

/*------------------------------
Nombre: Ordenamiento de burbuja
Descripción: Dado un array de flotantes desordenado, los ordena de menor a mayor.
Argumentos de entrada: El array desordenado, el array de salida y el numero de flotantes a ordenar.
Retorno: El array de salida con los flotantes del de entrada ordenados de menor a mayor.
---------------------------------*/
int ordenaBurbuja(const float * notas_in, float * notas_out, int num_notas) {
	int i,otraVez;
	float temp;
	
	for (i=0; i< num_notas; i++) notas_out[i]=notas_in[i];
	for(otraVez = 1; otraVez;){
		for(otraVez=0, i = 0; i < (num_notas - 1) ; i++){
			if(notas_out[i]>notas_out[i+1]){
				temp=notas_out[i];
				notas_out[i]=notas_out[i+1];
				notas_out[i+1]=temp;
				otraVez = 1;
			}
		}
	}
	return OK;
}

/*------------------------------
Nombre: Percentil
Descripción: Calcula el percentil de una serie de flotantes.
Argumentos de entrada: El array de flotantes ordenados a calcular el percentil,
el percentil, el numero de flotantes y la variable donde almacenar el resultado
Retorno: El percentil estipulado por el usuario de dichos flotantes ordenados
---------------------------------*/
int percent(const float * notas, int num_notas, int percentil, float * result) {
	int posMedia;
	if ((notas==NULL) || (result == NULL) || (num_notas < 0 )) return ERR;
	posMedia = num_notas/(100/percentil);
	*result = notas[posMedia-1];
	return OK;
}

/*------------------------------
Nombre: Mediana
Descripción: Calcula el elemento central de un array de flotantes
Argumentos de entrada: Un array de flotantes ordenados, el numero
de flotantes y la variable donde almacenar el resultado
Retorno: El valor del flotante situado en la posicion media del array.
---------------------------------*/
int mediana(const float * notas, int num_notas, float * result) {
	int posMedia;
	
	if ((notas==NULL) || (result == NULL) || (num_notas < 0 )) return ERR;
	posMedia = num_notas/2;
	*result = notas[posMedia];
	return OK;
}

/*------------------------------
Nombre: Media
Descripción: Calcula la media entre los flotantes de un array
Argumentos de entrada: Un array de flotantes, el numero de flotantes
y la variable donde almacenar el resultado
Retorno: La media entre todos los flotantes del mismo array
---------------------------------*/
float media(const float * notas, int num_notas, float * result) {
	int i;
	float aux=0;
	
	if ((notas==NULL) || (result == NULL) || (num_notas < 0 )) return ERR;
	
	for(i=0;i<num_notas; i++) {
		aux+=notas[i];
	}
 	*result = aux/num_notas;
	return *result;
}

/*------------------------------
Nombre: Desviacion
Descripción: Calcula la desviacion atipica de la serie de flotantes
Argumentos de entrada: El array de flotantes, el numero de ellos en el mismo
y la variable donde almacenar el resultado
Retorno: La desviacion atipica de la serie de flotantes del array
---------------------------------*/
int desviacion(const float * notas, int num_notas, float *result) {
	int i;
	float sumatorio=0;
	if ((notas==NULL) || (result == NULL) || (num_notas < 0 )) return ERR;
	
	for(i=0;i<num_notas; i++) {
		sumatorio+=(notas[i]-media(notas, num_notas, result))*(notas[i]-media(notas, num_notas, result));
	}
	*result = (float)sqrt(fabs((1.0/(num_notas -1))*sumatorio));
	return OK;
}