import java.io.*;
import java.util.*;
import java.lang.*;
/**
 * @author Carlos Guerra Alberti
 *
 */
public class vq_setas {

	/**
	 * @param args
	 * @throws Exception 
	 */
	

	public static void main(String[] args) throws Exception {
		
		
		//Declaramos variables:
		int particiones;
		int num_bolets;
		int atributos; 
		int atributosbin;
		int num_bolets_trainning;
		double minvalue;
		double inicia;
		double termina=0.0;
		Double [][] boletsbinari;
		Double [][] euclideas;
		Double [][] euclideasclas;
		Double [][] centroides;
		
		 //////////////////////////////////////////////////////////
		// Obtenemos los valores del fichero mushroom.csv y creamos un 
		// modelo de trainning a partir de un array bidimensional, en 
		// la variable num_bolets, determinaremos el número de setas que compondran
		// nuestro modelo de training. Ej. si num_bolets = 200, el training estará
		// compuesto por las 200 primeras setas del fichero csv.
		

			num_bolets = 8125; //8124 hongos + 1 linea encabezado
			atributos = 23; // 23 atributos
			atributosbin = 128; // 128 atributos binarios
			String [][] muestra = new String [num_bolets][atributos]; // Creamos un array bidimensional en donde almacenaremos 
		   															// los datos obtenidos del fichero csv.
			File file = new File("mushroom.csv"); //Indicamos el fichero a abrir.
			// Mediante el siguiente proceso, almacenamos los caracteres del fichero csv en una matriz llamada "muestra".
			BufferedReader bufRdr  = new BufferedReader(new FileReader(file));
			String line = null;
			int row = 0;
			int col = 0;
			//lee linea por linea del fichero de texto:
			while((line = bufRdr.readLine()) != null && row<num_bolets)
			{	
			StringTokenizer st = new StringTokenizer(line,",");
				while (st.hasMoreTokens())
				{
				muestra[row][col] = st.nextToken(); //almacena valor en la posición x y de la tabla.
				col++;
				}
			col = 0;
			row++;
			}
			//Creamos un array bidimensional numérico para poder realizar las operaciones aritmeticas, 
			// En este caso, el array se compone por 8124 filas, por lo que eliminamos la primera: la de los
			// encabezados (indican atributos).
			boletsbinari = new Double [num_bolets-1][atributosbin];
			for(int j=0;j<num_bolets-1;j++){
				for (int i=0;i<atributosbin;i++){
				boletsbinari[j][i]= 0.0; //Inicialmente llenamos el vector con 0.0
				}
			}
			
			// Iniciamos el proceso para binarizar los hongos.
			// Nota, el missing ? se ha tratado con un valor intermedio de 0.5
		for (int j=1;j<num_bolets;j++){ //con j=1 nos saltamos la primera linea que indica el nombre de los atributos.
			//Class: p, e
			if (muestra[j][0].equals("p")) boletsbinari[j-1][0] = 1.0;
			if (muestra[j][0].equals("e")) boletsbinari[j-1][1] = 1.0;
		    //cap-shape: b, c, x, f, k, s
			if (muestra[j][1].equals("b")) boletsbinari[j-1][2] = 1.0;
			if (muestra[j][1].equals("c")) boletsbinari[j-1][3] = 1.0;
			if (muestra[j][1].equals("x")) boletsbinari[j-1][4] = 1.0;
			if (muestra[j][1].equals("f")) boletsbinari[j-1][5] = 1.0;
			if (muestra[j][1].equals("k")) boletsbinari[j-1][6] = 1.0;
			if (muestra[j][1].equals("s")) boletsbinari[j-1][7] = 1.0;
			//cap-surface: f,g,y,s
			if (muestra[j][2].equals("f")) boletsbinari[j-1][8] = 1.0;
			if (muestra[j][2].equals("g")) boletsbinari[j-1][9] = 1.0;
			if (muestra[j][2].equals("y")) boletsbinari[j-1][10] = 1.0;
			if (muestra[j][2].equals("s")) boletsbinari[j-1][11] = 1.0;
			//cap-color: n,b,c,g,r,p,u,e,w,y
			if (muestra[j][3].equals("n")) boletsbinari[j-1][12] = 1.0;
			if (muestra[j][3].equals("b")) boletsbinari[j-1][13] = 1.0;
			if (muestra[j][3].equals("c")) boletsbinari[j-1][14] = 1.0;
			if (muestra[j][3].equals("g")) boletsbinari[j-1][15] = 1.0;
			if (muestra[j][3].equals("r")) boletsbinari[j-1][16] = 1.0;
			if (muestra[j][3].equals("p")) boletsbinari[j-1][17] = 1.0;
			if (muestra[j][3].equals("u")) boletsbinari[j-1][18] = 1.0;
			if (muestra[j][3].equals("e")) boletsbinari[j-1][19] = 1.0;
			if (muestra[j][3].equals("w")) boletsbinari[j-1][20] = 1.0;
			if (muestra[j][3].equals("y")) boletsbinari[j-1][21] = 1.0;
			//bruises: t,f
			if (muestra[j][4].equals("t")) boletsbinari[j-1][22] = 1.0;
			if (muestra[j][4].equals("f")) boletsbinari[j-1][23] = 1.0;
			//odor: a,l,c,y,f,m,n,p,s
			if (muestra[j][5].equals("a")) boletsbinari[j-1][24] = 1.0;
			if (muestra[j][5].equals("l")) boletsbinari[j-1][25] = 1.0;
			if (muestra[j][5].equals("c")) boletsbinari[j-1][26] = 1.0;
			if (muestra[j][5].equals("y")) boletsbinari[j-1][27] = 1.0;
			if (muestra[j][5].equals("f")) boletsbinari[j-1][28] = 1.0;
			if (muestra[j][5].equals("m")) boletsbinari[j-1][29] = 1.0;
			if (muestra[j][5].equals("n")) boletsbinari[j-1][30] = 1.0;
			if (muestra[j][5].equals("p")) boletsbinari[j-1][31] = 1.0;
			if (muestra[j][5].equals("s")) boletsbinari[j-1][32] = 1.0;
			//gill-attachment:a,d,f,n
			if (muestra[j][6].equals("a")) boletsbinari[j-1][33] = 1.0;
			if (muestra[j][6].equals("d")) boletsbinari[j-1][34] = 1.0;
			if (muestra[j][6].equals("f")) boletsbinari[j-1][35] = 1.0;
			if (muestra[j][6].equals("n")) boletsbinari[j-1][36] = 1.0;
			//gill-spacing: close=c,crowded=w,distant=d
			if (muestra[j][7].equals("c")) boletsbinari[j-1][37] = 1.0;
			if (muestra[j][7].equals("w")) boletsbinari[j-1][38] = 1.0;
			if (muestra[j][7].equals("d")) boletsbinari[j-1][39] = 1.0;
			//gill-size: broad=b,narrow=n
			if (muestra[j][8].equals("b")) boletsbinari[j-1][40] = 1.0;
			if (muestra[j][8].equals("n")) boletsbinari[j-1][41] = 1.0;
			//gill-color: black=k,brown=n,buff=b,chocolate=h,gray=g,green=r,orange=o,pink=p,purple=u,red=e,white=w,yellow=y
			if (muestra[j][9].equals("n")) boletsbinari[j-1][42] = 1.0;
			if (muestra[j][9].equals("b")) boletsbinari[j-1][43] = 1.0;
			if (muestra[j][9].equals("h")) boletsbinari[j-1][44] = 1.0;
			if (muestra[j][9].equals("g")) boletsbinari[j-1][45] = 1.0;
			if (muestra[j][9].equals("r")) boletsbinari[j-1][46] = 1.0;
			if (muestra[j][9].equals("o")) boletsbinari[j-1][47] = 1.0;
			if (muestra[j][9].equals("p")) boletsbinari[j-1][48] = 1.0;
			if (muestra[j][9].equals("u")) boletsbinari[j-1][49] = 1.0;
			if (muestra[j][9].equals("e")) boletsbinari[j-1][50] = 1.0;
			if (muestra[j][9].equals("w")) boletsbinari[j-1][51] = 1.0;
			if (muestra[j][9].equals("y")) boletsbinari[j-1][52] = 1.0;
			if (muestra[j][9].equals("k")) boletsbinari[j-1][53] = 1.0;
			//stalk-shape: enlarging=e,tapering=t
			if (muestra[j][10].equals("e")) boletsbinari[j-1][54] = 1.0;
			if (muestra[j][10].equals("t")) boletsbinari[j-1][55] = 1.0;
			//stalk-root: bulbous=b,club=c,cup=u,equal=e, rhizomorphs=z,rooted=r,missing=?
			if (muestra[j][11].equals("b")) boletsbinari[j-1][56] = 1.0;
			if (muestra[j][11].equals("c")) boletsbinari[j-1][57] = 1.0;
			if (muestra[j][11].equals("u")) boletsbinari[j-1][58] = 1.0;
			if (muestra[j][11].equals("e")) boletsbinari[j-1][59] = 1.0;
			if (muestra[j][11].equals("z")) boletsbinari[j-1][60] = 1.0;
			if (muestra[j][11].equals("r")) boletsbinari[j-1][61] = 1.0;
			if (muestra[j][11].equals("?")) boletsbinari[j-1][62] = 0.5;
			//stalk-surface-above-ring: ibrous=f,scaly=y,silky=k,smooth=s
			if (muestra[j][12].equals("f")) boletsbinari[j-1][63] = 1.0;
			if (muestra[j][12].equals("y")) boletsbinari[j-1][64] = 1.0;
			if (muestra[j][12].equals("k")) boletsbinari[j-1][65] = 1.0;
			if (muestra[j][12].equals("s")) boletsbinari[j-1][66] = 1.0;
			//stalk-surface-below-ring: ibrous=f,scaly=y,silky=k,smooth=s
			if (muestra[j][13].equals("f")) boletsbinari[j-1][67] = 1.0;
			if (muestra[j][13].equals("y")) boletsbinari[j-1][68] = 1.0;
			if (muestra[j][13].equals("k")) boletsbinari[j-1][69] = 1.0;
			if (muestra[j][13].equals("s")) boletsbinari[j-1][70] = 1.0;
			//stalk-color-above-ring:   brown=n,buff=b,cinnamon=c,gray=g,orange=o,pink=p,red=e,white=w,yellow=y
			if (muestra[j][14].equals("n")) boletsbinari[j-1][71] = 1.0;
			if (muestra[j][14].equals("b")) boletsbinari[j-1][72] = 1.0;
			if (muestra[j][14].equals("c")) boletsbinari[j-1][73] = 1.0;
			if (muestra[j][14].equals("g")) boletsbinari[j-1][74] = 1.0;
			if (muestra[j][14].equals("o")) boletsbinari[j-1][75] = 1.0;
			if (muestra[j][14].equals("p")) boletsbinari[j-1][76] = 1.0;
			if (muestra[j][14].equals("e")) boletsbinari[j-1][77] = 1.0;
			if (muestra[j][14].equals("w")) boletsbinari[j-1][78] = 1.0;
			if (muestra[j][14].equals("y")) boletsbinari[j-1][79] = 1.0;
			//stalk-color-bellow-ring:   brown=n,buff=b,cinnamon=c,gray=g,orange=o,pink=p,red=e,white=w,yellow=y
			if (muestra[j][15].equals("n")) boletsbinari[j-1][80] = 1.0;
			if (muestra[j][15].equals("b")) boletsbinari[j-1][81] = 1.0;
			if (muestra[j][15].equals("c")) boletsbinari[j-1][82] = 1.0;
			if (muestra[j][15].equals("g")) boletsbinari[j-1][83] = 1.0;
			if (muestra[j][15].equals("o")) boletsbinari[j-1][84] = 1.0;
			if (muestra[j][15].equals("p")) boletsbinari[j-1][85] = 1.0;
			if (muestra[j][15].equals("e")) boletsbinari[j-1][86] = 1.0;
			if (muestra[j][15].equals("w")) boletsbinari[j-1][87] = 1.0;
			if (muestra[j][15].equals("y")) boletsbinari[j-1][88] = 1.0;
			//veil-type: partial=p,universal=u
			if (muestra[j][16].equals("p")) boletsbinari[j-1][89] = 1.0;
			if (muestra[j][16].equals("u")) boletsbinari[j-1][90] = 1.0;
			//veil-color: brown=n,orange=o,white=w,yellow=y
			if (muestra[j][17].equals("n")) boletsbinari[j-1][91] = 1.0;
			if (muestra[j][17].equals("o")) boletsbinari[j-1][92] = 1.0;
			if (muestra[j][17].equals("w")) boletsbinari[j-1][93] = 1.0;
			if (muestra[j][17].equals("y")) boletsbinari[j-1][94] = 1.0;
			//ring-number: none=n,one=o,two=t
			if (muestra[j][18].equals("n")) boletsbinari[j-1][95] = 1.0;
			if (muestra[j][18].equals("o")) boletsbinari[j-1][96] = 1.0;
			if (muestra[j][18].equals("t")) boletsbinari[j-1][97] = 1.0;
			//ring-type: cobwebby=c,evanescent=e,flaring=f,large=l,none=n,pendant=p,sheathing=s,zone=z
			if (muestra[j][19].equals("c")) boletsbinari[j-1][98] = 1.0;
			if (muestra[j][19].equals("e")) boletsbinari[j-1][99] = 1.0;
			if (muestra[j][19].equals("f")) boletsbinari[j-1][100] = 1.0;
			if (muestra[j][19].equals("l")) boletsbinari[j-1][101] = 1.0;
			if (muestra[j][19].equals("n")) boletsbinari[j-1][102] = 1.0;
			if (muestra[j][19].equals("p")) boletsbinari[j-1][103] = 1.0;
			if (muestra[j][19].equals("s")) boletsbinari[j-1][104] = 1.0;
			if (muestra[j][19].equals("z")) boletsbinari[j-1][105] = 1.0;
			//spore-print-color:  black=k,brown=n,buff=b,chocolate=h,green=r,orange=o,purple=u,white=w,yellow=y
			if (muestra[j][20].equals("k")) boletsbinari[j-1][106] = 1.0;
			if (muestra[j][20].equals("n")) boletsbinari[j-1][107] = 1.0;
			if (muestra[j][20].equals("b")) boletsbinari[j-1][108] = 1.0;
			if (muestra[j][20].equals("h")) boletsbinari[j-1][109] = 1.0;
			if (muestra[j][20].equals("r")) boletsbinari[j-1][110] = 1.0;
			if (muestra[j][20].equals("o")) boletsbinari[j-1][111] = 1.0;
			if (muestra[j][20].equals("u")) boletsbinari[j-1][112] = 1.0;
			if (muestra[j][20].equals("w")) boletsbinari[j-1][113] = 1.0;
			if (muestra[j][20].equals("y")) boletsbinari[j-1][114] = 1.0;
			//population: abunfant=a,clustered=c,numerous=n,scattered=s,several=v,solitary=y
			if (muestra[j][21].equals("a")) boletsbinari[j-1][115] = 1.0;
			if (muestra[j][21].equals("c")) boletsbinari[j-1][116] = 1.0;
			if (muestra[j][21].equals("n")) boletsbinari[j-1][117] = 1.0;
			if (muestra[j][21].equals("s")) boletsbinari[j-1][118] = 1.0;
			if (muestra[j][21].equals("v")) boletsbinari[j-1][119] = 1.0;
			if (muestra[j][21].equals("y")) boletsbinari[j-1][120] = 1.0;
			//habitat: grasses=g,leaves=l,meadows=m,paths=p,urban=u,waste=w,woods=d
			if (muestra[j][22].equals("g")) boletsbinari[j-1][121] = 1.0;
			if (muestra[j][22].equals("l")) boletsbinari[j-1][122] = 1.0;
			if (muestra[j][22].equals("m")) boletsbinari[j-1][123] = 1.0;
			if (muestra[j][22].equals("p")) boletsbinari[j-1][124] = 1.0;
			if (muestra[j][22].equals("u")) boletsbinari[j-1][125] = 1.0;
			if (muestra[j][22].equals("w")) boletsbinari[j-1][126] = 1.0;
			if (muestra[j][22].equals("d")) boletsbinari[j-1][127] = 1.0;
		}
			
			// Mostramos los atributos en pantalla
			System.out.println("Detectados los siguientes atributos");
			for (int i=0;i<atributos;i++)
			{
				System.out.print(muestra[0][i] + " | ");
			}

///////////////////////////////////////////////////////////////////////////////	
/////////////// TRAINNING /////////////////////////////////////////////////////
			// Generamos una seta aleatoria a partir de la cual escogeremos las 1000 siguientes
			// que formaran nuestro trainning.
		
			num_bolets_trainning = 6770; // Las / partes de la muestra total compondrán el conjunto de trainning. 
										//Por lo tanto trainning = 6770 setas
			particiones=10;
			/*
			 * Tambien destacamos la posibilidad, e incluimos el código de cómo seleccionaríamos un trainning compuesto 
			 * por una seta elegida al azar y sus 999 siguientes setas formando un trainning de 1000 elementos:
			 * Buscamos una seta aleatoria a partir de la cual cogeremos un trainning de 999 más.
			 * 
			 * El codigo sería el siguiente:
			 * Elevamos al cuadrado y hacemos raiz cuadrada por si nos sale con signo negativo la pasamos a positivo:
			 * int setaAleatoria = (int) (Math.sqrt(Math.pow(Math.random()*num_bolets-num_bolets_trainning+1,2)));
			 * System.out.println("Seta Aleatoria: "+setaAleatoria);
			 * Double [][] trainning = new Double [num_bolets_trainning][atributosbin];
			 * for (int k=0;k<num_bolets_trainning;k++){
			 * 	for (int i=setaAleatoria;i<setaAleatoria+num_bolets_trainning;i++){ //Para la seta y sus siguientes
			 * 	 for (int j=0;j<atributosbin;j++){
			 * 	 trainning[k][j]=boletsbinari[setaAleatoria][j];
			 * 	 System.out.print("orig: "+boletsbinari[setaAleatoria][j]+" train: "+trainning[k][j]+"\n");
			 * 	 }
			 *  }
		   	 * }
			*/
			// Tras esta operación, obtendriamos un array multidimensional compuesto por 1000 setas consecutivas que 
			//compondría nuestra muestra de trainning.
			
/////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////CENTROIDES //////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////
			
			// CENTROIDES:Procedemos a calcular los centroides
			
			//Calculo de los centroides.

			int partbolets = num_bolets_trainning/particiones; // dividimos entre las particiones existentes
			double res=0.0;
			centroides = new Double [particiones][atributosbin]; 
			for (int k=1;k<particiones+1;k++)									
			{
			 for (int j=0;j<atributosbin;j++) 
			 {
				for (int i=partbolets*(k-1);i<partbolets*k;i++)
				{
					res += boletsbinari[i][j]; //sumatorio de los atributos de las setas de una particion
				}
				res=res/partbolets; //division del sumatorio para obtener la media.
				centroides[k-1][j]=res; //almacenaje de los centroides en el vector centroides
				res=0.0; // reseteamos la variable.
				//System.out.println("centroide"+(k-1)+"-"+j+" "+centroides[k-1][j]); //mostraria los centroides en pantalla
			 }
			}
			
/////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////// VECTOR QUANTIZATION ////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////	
			// Iniciamos un contador de tiempo, el cual nos permitirá conocer el tiempo de 
			// ejecución del algoritmo de VQ.
			inicia = 0.0;
			inicia = System.currentTimeMillis();
			
			// Vector Quantization sin penalizacion
			 
			// Tomo una seta al azar de las 6770
			int setaAleatoria = (int) (Math.sqrt(Math.pow(Math.random()*num_bolets_trainning-1000+1,2))); 
			//int setaAleatoria=0;
			int seta = setaAleatoria;
			int setaAleatoriaN=setaAleatoria;
			int iSeta=0; //usaremos iSeta para contar de 0 a 1000 setas ordinalmente (1ªseta,2ªseta,etc).
			double sumatorio=0.0;
			double total=0.0;
			int position;
			double min;
			euclideas = new Double [num_bolets_trainning][particiones]; 
			double c=0.5; //n(t)
		     while (iSeta<1000){		 
				for (int k=0;k<particiones;k++)
				{
				  for (int j=2;j<atributosbin;j++) //No se cuenta el primer y segundo atributo, es decir la clase (p o e)
				  {
					  sumatorio+=Math.pow(boletsbinari[seta][j]-centroides[k][j],2);
				  }
				  total=Math.sqrt(sumatorio); //Raiz cuadrada del sumatorio
				  euclideas[seta][k]=total; //Almacenamos en la primera columna del array euclideas
				  sumatorio=0.0;
				}
				min = euclideas[seta][0];
				position=0;
				  for (int i = 0; i < euclideas[0].length; i++) {
				//  System.out.println("Euclidea de "+seta+" pos "+(i+1)+" :"+euclideas[seta][i]);
				    if (euclideas[seta][i]<min) {
				      min = euclideas[seta][i];
				      position = i;
				    }
				  }
				//  System.out.println("distancia minima vector: "+min);
				//System.out.println("POSICION DEL CENTROIDE Q CAMBIAMOS: "+(position+1));

			//Acercamos el centroide:
			for (int j=2;j<atributosbin;j++)
			   {
				 //Modificamos el centroide:
				centroides[position][j]=centroides[position][j]+c*(boletsbinari[seta][j]-centroides[position][j]);
			   }
			//Alejamos centroides PENALIZACION
			for (int l=0; l<particiones;l++){
				if(l!=position){
					for (int j=2;j<atributosbin;j++)
					{
						//Modificamos el centroide:
					//	centroides[l][j]=centroides[l][j]-c*(boletsbinari[seta][j]-centroides[l][j]);
					}
				} 
		     }
			termina = System.currentTimeMillis() - inicia; //Termina el contador
			 System.out.println("C: "+c+" iSeta: "+(iSeta+1)+" seta num: "+seta+" position: "+(position+1)); 	
			  seta++; //siguiente seta
			  iSeta++; //siguiente iSeta
			  c=c-0.0005; //Reducimos el coeficiente.		  
			 }
			 // Tras hacer las 1000 setas, clasificamos las particiones para medir el éxito de la clasificación
		     System.out.println("-------------------------------------------------------");
/////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////CLASIFICACIÓN ////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////

/* Con los 1000 nuevos centroides, hallaremos las distancias euclideas y 
* clasificaremos las setas aleatorias, tras ello obtendremos la precisión
* de nuestro algoritmo.
*/
			double minN;
			int setaN=0;
			euclideasclas = new Double [num_bolets_trainning][particiones]; 
			Integer [][] posiciones = new Integer [1000][2];
			while (setaN<1000){
			for (int k=0;k<particiones;k++)
			{
				 for (int j=2;j<atributosbin;j++) //No se cuenta el primer y segundo atributo, es decir la clase (p o e)
				 {
					 sumatorio+=Math.pow(boletsbinari[setaAleatoriaN][j]-centroides[k][j],2);
				 }
				 total=Math.sqrt(sumatorio); //Raiz cuadrada del sumatorio
				 euclideasclas[setaAleatoriaN][k]=total; //Almacenamos en la primera columna del array euclideas
				 sumatorio=0.0;
				 // System.out.println("total: "+total+" "+setaN);
			}
			// Position nos dira ahora la menor distancia con una de las 1000 setas y clasificaremos segun su tipo
			minN = euclideasclas[setaAleatoriaN][0];
			position=0;
			for (int i = 0; i < euclideasclas[0].length; i++) {
				 if (euclideasclas[setaAleatoriaN][i]<minN) {
					 minN = euclideasclas[setaAleatoriaN][i];
					 position = i;
				 }
			}
			//Agrupamos las setas:
			
			posiciones[setaN][0]=setaAleatoriaN;
			posiciones[setaN][1]=position;
			//System.out.println("distancia minima vector: "+setaAleatoriaN+" "+minN+" particion elegida: "+posiciones[setaAleatoriaN][1]);
			minN=0.0;
			setaAleatoriaN++;
			setaN++;
			}
			int x=0;
			double e; //COMESTIBLES
			double p; //VENENOSAS
			double totalprecision=0.0;
			double precision_e=0.0;
			double precision_p=0.0;
			while (x<particiones){
			System.out.println("Setas en Particion "+(x+1)+":");
			 e=0;
			 p=0;
			  for (int h=0;h<posiciones.length;h++)
			  {
				 if (posiciones[h][1]==x){
				  if (boletsbinari[posiciones[h][0]][1]==1.0){ //Si encuentra 1.0 en la 2ª columna de la matriz de las setas,
					  											//se trata de una seta comestible: columna de la "e".
					  e++;
				  }
			      else{
			    	  p++;
			      }
				  
				 }
			   }
			
				  if (e>p){
					  System.out.println("e:"+e);
					  precision_e=(e/1000);
					//  System.out.println("e/num_bolets_trainning "+precision_e);
					  totalprecision += precision_e;
				  }
				  else{
					  System.out.println("p:"+p);
					  precision_p=(p/1000);
					//  System.out.println("p/num_bolets_trainning "+precision_p);
					  totalprecision += precision_p;	    		  
				  }
		    x++;
			}
			System.out.println("Precision total: "+totalprecision*100+"%"); // Mostramos la precisión de nuestro programa.
///////////////////////////////////////////////////////////////////////////////////////
			// Mostramos el tiempo de ejecución de nuestro algoritmo en milisegundos:
			
			System.out.println("Tiempo Ejecucion del Algoritmo: "+(termina/1000)+" segundos");
	}
}