// This is a Weka implementation of "Delegating Classifiers",
// See Ferri, Flach and Hernandez-Orallo ICML'04
// File writted by Cesar Ferri (cferri@dsic.upv.es)

import java.io.*;
import java.util.*;
//import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.lang.*;
import weka.classifiers.*;
import java.io.BufferedReader;
//import weka.classifiers.evaluation.*;
import weka.classifiers.functions.*;
import weka.classifiers.functions.neural.*;
import weka.classifiers.trees.*;
import weka.classifiers.trees.j48.*;
import weka.classifiers.bayes.*;
import weka.classifiers.rules.*;
import weka.classifiers.meta.*;
import weka.core.*;

//import Rank.*;

public class Delegating 
{

    
    // confianza m�nima aceptada
    static double threshold1=0.7;   //0.7 va prou be per a NBayes


        
    // M�ximo de divisiones 20
    static int numFolds=5;
    static int numReps=20;

    static int percent =99; //percentatge que es delega

    //    static int del_lim=5;

    


    static String [] nombArchi={
        //"iris",
 	"balance-scale",
        "breast-w",
         "breast-wdbc",
        "cmc",
        "dermatologyW",
        //"kr-vs-kp",
        "hayes-roth",
        "heart-disease-alltogether-UM",
        //"hepatitis",
        //"horse-colic-outcome-UMW",
        //"horse-colic-surgical-UMW",
        "house-vote",
        "iris",
        "monks1W",
        "monks2W",
        "monks3W",
        "new-thyroid",
        //"post-operativeW",
        "segment",
        "taeW",
        //"thyroid-ann",
        "tic-tacW",
        "wine",
        "spect",
        "carsW",
        //
        //"waveformW",
        //"abalone-morethan11.all",
        "optdigits",
        "spam",
        "thyroid-sick-eu-UM"


    };



    /** The PairedTTester object */
    //  protected PairedTTester m_TTester = new PairedCorrectedTTester();



    public static void main(String a[]) throws Exception
    {
	System.out.println("@relation ResultatsDelegating");
	
        System.out.print("@attribute Key_Dataset {" );
	for (int i=0; i<nombArchi.length;i++)
	    System.out.print (nombArchi[i]+ ",");
	System.out.println("}" );
        
        System.out.print(" @attribute Key_Run {");
        for (int i=0; i<numReps;i++)
	    System.out.print ((1+i)+ ",");
        System.out.println("}" );
           
        System.out.print(" @attribute Key_Fold {");
        for (int i=0; i<numFolds;i++)
	    System.out.print ((1+i)+ ",");
        System.out.println("}" );
        
	//System.out.println(" @attribute Key_Fold {1,2,3,4,5,6,7,8,9,10}");
	System.out.println("@attribute Key_Scheme {Delegating,Combinacio,Original,Bagging,AdaBoostM1}");
	System.out.println("@attribute Percent_correct numeric");
        System.out.println("@attribute Mean_squared_error numeric");
        System.out.println("@attribute AUC numeric");
        System.out.println("@attribute Training_time numeric");
	System.out.println("@data");

	for (int f=0; f<nombArchi.length; f++)
	    try{
   
		double preci[][] = new double [numFolds][numReps];
		double preci_org[][] = new double [numFolds][numReps];
		double preci_comb[][] = new double [numFolds][numReps];
                double preci_boos[][] = new double [numFolds][numReps];
                double preci_bagg[][] = new double [numFolds][numReps];
                
                
		double MSE[][] = new double [numFolds][numReps];
		double MSE_org[][] = new double [numFolds][numReps];
		double MSE_comb[][] = new double [numFolds][numReps];
                double MSE_boos[][] = new double [numFolds][numReps];
                double MSE_bagg[][] = new double [numFolds][numReps];
                
                
                double AUC[][] = new double [numFolds][numReps];
		double AUC_org[][] = new double [numFolds][numReps];
		double AUC_comb[][] = new double [numFolds][numReps];
                
                
                double time_train[][] = new double [numFolds][numReps];
		double time_train_org[][] = new double [numFolds][numReps];
		double time_train_comb[][] = new double [numFolds][numReps];
                double time_train_boos[][] = new double [numFolds][numReps];
                double time_train_bagg[][] = new double [numFolds][numReps];
                

		FileReader reader;
		Instances dataset;
		reader = new FileReader("wekasamples/"+nombArchi[f]+".arff");
		dataset = new Instances(new BufferedReader(reader));
		//califas=new double[dataset.numInstances() +totalGene];
                //System.out.println("llegides" + dataset.toString());
             

		//	System.out.println(nombArchi[f]);
		//--- El �ltimo atributo es la clase
		dataset.setClassIndex(dataset.numAttributes() - 1);


		// Instances data= new Instances(br);
		// data.setClassIndex(data.numAttributes()-1);


		//J48 classify=new J48();
		// classify.buildClassifier(data);
		//System.out.println("\nDataset:\n");
		//System.out.println(data);
		//System.out.println(classify.toString());
     
                int rn=1;
		for(int krep=0; krep<numReps; krep++)
		    {
                        Instances runInstances = new Instances(dataset);
                      //  System.out.println("el iter es="+rn);
			Random random=new Random(rn);
                        rn++;
			runInstances.randomize(random);
			runInstances.stratify(numFolds);
			for(int fold=0; fold<numFolds; fold++)
			    {
				Instances train = runInstances.trainCV(numFolds, fold);
                            	Instances test = runInstances.testCV(numFolds, fold);
                                
                                // for timing
                                long trainTimeStart = 0, trainTimeElapsed = 0;
                                
                         //       System.out.println("train orig" + runInstances.toString());
                         //       System.out.println("size train" + train.numInstances());
                        //        System.out.println(" train:" + train.toString());
                        //        System.out.println(" test:" + test.toString());
                         //       System.out.println("size test" + test.numInstances());
				// TRAIN!!!
				//NaiveBayes arbol= new NaiveBayes();
				//
				//   VotedPerceptron arbol = new VotedPerceptron();
				//  NeuralNetwork arbol = new NeuralNetwork();
				//  SimpleLogistic arbol =new SimpleLogistic();
				// String[] options = new String[] {"A","U"};   // NO va!!!!


				Instances deltrain =train;
				Vector Classifiers= new Vector();
				Vector Thresholds = new Vector();
				int numexem= train.numInstances()-(train.numInstances()*percent/100);  //numero de exemples que elimine en cada pas (els de més confidence)
				//  System.out.println("Numelements:"+train.numInstances());
				// System.out.println("Numexem:"+numexem);
				int num_exemples_delegated=train.numInstances();
        
				do {
                                
				    //NaiveBayes arbol = new NaiveBayes();
				    J48 arbol=new J48();
				    //options[2] = "-M 1";
				    //arbol.setOptions(options);  // No  VA!!!!!
				    //arbol.setMinNumObj(1);
                                    arbol.setUnpruned(true);
                                    arbol.setUseLaplace(true);
                                    
                                    trainTimeStart = System.currentTimeMillis();
				    arbol.buildClassifier(deltrain);
                                    trainTimeElapsed += System.currentTimeMillis() - trainTimeStart;
                                    
                                    
				    // Create the delegated dataset
				    Instances delegated;
				    delegated= new  Instances(train,0);
				    //fill delegated dataset
				    // fill_delegated_dataset_threshold(delegated,train,arbol);
				    //threshold1=fill_delegated_dataset_percent(delegated,deltrain,arbol);
				    if(num_exemples_delegated>numexem) //in the last iteration we haven't to delegate more...
					{
					    threshold1=fill_delegated_dataset_numexem(delegated,deltrain,arbol,numexem);
					    //                               System.out.println("exemples delegats:"+ delegated.numInstances());
					    num_exemples_delegated=delegated.numInstances();
					    deltrain=delegated;
					}
				    else num_exemples_delegated=0;
                                
                                
				    Classifiers.addElement(arbol);
				    Thresholds.addElement(new Double (threshold1));
                                
				    //learn the second classifier
				    // J48 arbol2=new J48();
				    //arbol2.setOptions(options);
				    //				 arbol2.setMinNumObj(1);

				    //NaiveBayes arbol2 = new NaiveBayes();
				    //   VotedPerceptron arbol2 = new VotedPerceptron();
				    //   NeuralNetwork arbol2 = new NeuralNetwork();
				    //   SimpleLogistic arbol2 =new SimpleLogistic();
				    //  				arbol2.buildClassifier(delegated);

				} while (num_exemples_delegated>0);

                                time_train[fold][krep] = trainTimeElapsed / 1000.0;
                                
                                
				// TEST!!
                                     
				//Instances delegated_test;
				//delegated_test= new  Instances(test,0);
				Evaluation eval_del = new Evaluation(test);
                                                
                                //int visit=0;
				int hits=0;
				//      System.out.println("acc2 ");
				for (int i=0; i<test.numInstances();i++)
				    {    //System.out.println("acc20 "+ i +" " + test.numInstances());
					double classt=-1;
					for (int  del=0; del<Classifiers.size();del++)
					    {
						classt = ((Classifier)Classifiers.elementAt(del)).classifyInstance(test.instance(i));
						// System.out.println("acc21 ");
						double [] confidences =((Classifier)Classifiers.elementAt(del)).distributionForInstance(test.instance(i));
						//	for (int h=0;h<test.numClasses();h++)
						//   System.out.print(formato(confidences[h])+ " ");
						//System.out.println();
						//System.out.println("Thres "+ threshold1);
						if (confidences [(int)classt]>=((Double)Thresholds.elementAt(del)).doubleValue())
						    { if ( classt== test.instance(i).classValue())
							hits++;
                                                      //if (del>visit) visit=del;
						    break;}
						else{ if (del==(Classifiers.size()-1)) //fem rebound, es a dire si hi ha exemples que no els vols ningu, que els classifique el pare ;-)
                                                {
                                                    if ( ((Classifier)Classifiers.elementAt(0)).classifyInstance(test.instance(i))== test.instance(i).classValue())hits++;}
                                                    classt = ((Classifier)Classifiers.elementAt(0)).classifyInstance(test.instance(i));
                                                }
					    }
                                        
					//int hitsd=0;
					//				for (int i=0; i<delegated_test.numInstances();i++)
					//	    {
                                        //double classt = arbol2.classifyInstance(delegated_test.instance(i));  //rebound

					//double [] confidences =arbol2.distributionForInstance(delegated_test.instance(i)); //rebound
                                        //if (confidences [(int)classt]>threshold1) //rebound
					//  {
					//                                              if ( arbol2.classifyInstance(delegated_test.instance(i))== delegated_test.instance(i).classValue())
					//                                                    hits++;
					//  }
					//        else if ( arbol.classifyInstance(delegated_test.instance(i))== delegated_test.instance(i).classValue())hits++; //rebound
					//if ( predictedClass== delegated_test.instance(i).classValue()){hits++;hitsd++;}
					// System.out.println("les classes son: meua"+arbol2.classifyInstance(delegated_test.instance(i))+"orig"+test.instance(i).classValue());
                                         
					//System.out.println("les classes son: meua"+predictedClass+"orig"+test.instance(i).classValue());
                                         
					eval_del.evaluateModelOnce(classt, test.instance(i));
				    }
                                //System.out.println("Classificadors"+ Classifiers.size()+"Visitats"+visit);
				//System.out.println("meu"+hits+ " Seu "+ eval_del.correct());
				//  Evaluation evalSimple0 = new Evaluation(delegated_test);
				// evalSimple0.evaluateModel(arbol2, delegated_test);
				//          System.out.println("meu"+ formato(100*(double)hitsd/delegated_test.numInstances())+"weka"+evalSimple0.pctCorrect());
				//System.out.println("meud"+ hitsd +"weka"+ evalSimple0.correct());

				// Combinaci�
				int hits2=0;
                                Evaluation eval_comb = new Evaluation(test);
                                
    
				for (int i=0; i<test.numInstances();i++)
				    {    //System.out.println("acc20 "+ i +" " + test.numInstances());
					//	double classt = arbol.classifyInstance(test.instance(i));
					//	double [] confidences =arbol.distributionForInstance(test.instance(i));

					//	double classt2 = arbol2.classifyInstance(test.instance(i));
					//	double [] confidences2 =arbol2.distributionForInstance(test.instance(i));
					double votacions [];
					votacions =new double [train.numClasses()];
					for (int  del=0; del<Classifiers.size();del++)
					    { double classt = ((Classifier)Classifiers.elementAt(del)).classifyInstance(test.instance(i));
					    votacions[(int)classt]+=Classifiers.size()-del;
					    votacions[(int)classt]+=((Double)Thresholds.elementAt(del)).doubleValue();
					    //System.out.println("classe"+ classt);
					    }
					double classf=-1;
					double valc=-1;
					//System.out.println("votacions:");
					for (int  k=0; k<train.numClasses();k++)
					    {
						// System.out.print(votacions[k]);
						if (votacions[k]>valc)
						    {
							valc=votacions[k];
							classf=k;
						    }
					    }
             
					// classf=((J48)Classifiers.elementAt(0)).classifyInstance(test.instance(i));

					//if (classt==classt2) classf=classt;
					//else if (confidences [(int)classt]>(threshold1*confidences2 [(int)classt2]))   classf=classt;
					//else classf=classt2;
					//                      System.out.println("Classe comb:"+classf +"Classe true:" +test.instance(i).classValue());
					if (classf== test.instance(i).classValue())hits2++;
                                        eval_comb.evaluateModelOnce(classf, test.instance(i));
				    }

				//ORIGINAL
				J48 arbolorg=new J48();
				//arbolorg.setOptions(options);
                                
                                arbolorg.setUnpruned(true);
                                arbolorg.setUseLaplace(true);
				//arbolorg.setMinNumObj(1);

				//NaiveBayes arbolorg= new NaiveBayes();

				//   VotedPerceptron arbolorg = new VotedPerceptron();
				//    NeuralNetwork arbolorg = new NeuralNetwork();
				//  SimpleLogistic arbolorg =new SimpleLogistic();
                                trainTimeStart = 0; 
                                trainTimeElapsed = 0;
                                trainTimeStart = System.currentTimeMillis();
				arbolorg.buildClassifier(train);
                                trainTimeElapsed = System.currentTimeMillis() - trainTimeStart;
                                
                                time_train_org[fold][krep] = trainTimeElapsed / 1000.0;
                                
				Evaluation evalSimple = new Evaluation(test);
				evalSimple.evaluateModel(arbolorg, test);
				//System.out.println("Accuracy" +evalSimple.pctCorrect());
                                 //System.out.println("opcions");
                                 //String [] opcions = arbolorg.getOptions();
                                 //for (int i=0;i<opcions.length;i++)
                                 //   System.out.println(opcions[i]);
				 //System.out.println();

                                //bagging
                                
                                  J48 arbolorg2=new J48();
				//arbolorg.setOptions(options);
                                
                                arbolorg2.setUnpruned(true);
                                arbolorg2.setUseLaplace(true);
                                Bagging bagg=new Bagging();
                                
                                bagg.setClassifier(arbolorg2);
                                bagg.setNumIterations(20);
                                
                                trainTimeStart = 0; 
                                trainTimeElapsed = 0;
                                trainTimeStart = System.currentTimeMillis();
				                                
                                bagg.buildClassifier(train);
                                
                                trainTimeElapsed = System.currentTimeMillis() - trainTimeStart;
                                
                                time_train_bagg[fold][krep] = trainTimeElapsed / 1000.0;
                                
				Evaluation evalbagg = new Evaluation(test);
				evalbagg.evaluateModel(bagg, test);
                                
                                

                                //boosting
                                
                                J48 arbolorgnp=new J48();
				//arbolorg.setOptions(options);
                                
                                
                                arbolorgnp.setUseLaplace(true);
                                
                                AdaBoostM1 boos=new AdaBoostM1();
                                boos.setClassifier(arbolorgnp);
                                boos.setMaxIterations(20);
                                
                                trainTimeStart = 0; 
                                trainTimeElapsed = 0;
                                trainTimeStart = System.currentTimeMillis();
				                                
                                boos.buildClassifier(train);
                                
                                trainTimeElapsed = System.currentTimeMillis() - trainTimeStart;
                                
                                time_train_boos[fold][krep] = trainTimeElapsed / 1000.0;
                                
                                
				
                                
                                
                                Evaluation evalboos = new Evaluation(test);
				evalboos.evaluateModel(boos, test);
                                
                                
                                //Precision
                                preci[fold][krep]=eval_del.pctCorrect();
                                preci_comb[fold][krep]=eval_comb.pctCorrect();
                                preci_org[fold][krep]=evalSimple.pctCorrect();
                                preci_bagg[fold][krep]=evalbagg.pctCorrect();
                                preci_boos[fold][krep]=evalboos.pctCorrect();
                                
                                //MSE
                                MSE[fold][krep]=Math.pow(eval_del.rootMeanSquaredError(),2.0);
                                MSE_comb[fold][krep]=Math.pow(eval_comb.rootMeanSquaredError(),2.0);
                                MSE_org[fold][krep]=Math.pow(evalSimple.rootMeanSquaredError(),2.0);
                                MSE_bagg[fold][krep]=Math.pow(evalbagg.rootMeanSquaredError(),2.0);
                                MSE_boos[fold][krep]=Math.pow(evalboos.rootMeanSquaredError(),2.0);
                                
                                //AUC
                                //Vector mypredictions_org = new Vector();
                                //for (int jj=0;jj<test.numInstances();jj++) 
                                //    {classifierPrediction(test.instance(jj), arbolorg, mypredictions_org);}
                                //AUC_org[fold][krep]=computeAUCN(mypredictions_org, test.numClasses());
                                AUC_org[fold][krep]=0;

                                AUC_comb[fold][krep]=0;
                                AUC_org[fold][krep]=0;
                                

				//        int hitsf=0;
				// 				for (int i=0; i<test.numInstances();i++)
				//            if (arbolorg.classifyInstance(test.instance(i))== test.instance(i).classValue())hitsf++;
				//        System.out.println("meu"+ hitsf +"weka"+ evalSimple.correct());

				//preci[fold][krep]=(double)hits/test.numInstances();
				//preci_comb[fold][krep]=(double)hits2/test.numInstances();
                                //System.out.println("meua"+preci_comb[fold][krep]+ " Seua "+ eval_comb.rootMeanSquaredError());
				//      System.out.println("acc "+ preci[fold][0] + "acc_org" +acc_org);
				// Create the delegated dataset
				//Evaluation evalSimple = new Evaluation(test);
				//evalSimple.evaluateModel(arbol, test);
				//preci[fold][0]=evalSimple.pctCorrect();
			    }
		    }
		double mpreci=0;
		double mpreci_org=0;
		double mpreci_comb=0;



		for (int kr=0; kr<numReps; kr++)
		    for (int ip=0; ip<numFolds; ip++)
			{
			    mpreci+=preci[ip][kr];
			    mpreci_org+=preci_org[ip][kr];
			    mpreci_comb+=preci_comb[ip][kr];
			    System.out.println( nombArchi[f]+ "," + (kr+1) + "," +(ip+1)+","+"Delegating"+","+formato(preci[ip][kr])+","+formato(MSE[ip][kr])+","+formato(AUC[ip][kr])+","+formato(time_train[ip][kr]));
                            System.out.println( nombArchi[f]+ "," + (kr+1) + "," +(ip+1)+","+"Combinacio"+","+formato(preci_comb[ip][kr])+","+formato(MSE_comb[ip][kr])+","+formato(AUC_comb[ip][kr])+","+formato(time_train[ip][kr]));
			    System.out.println( nombArchi[f]+ "," + (kr+1) + "," +(ip+1)+","+"Original"+","+formato(preci_org[ip][kr])+","+formato(MSE_org[ip][kr])+","+formato(AUC_org[ip][kr])+","+formato(time_train_org[ip][kr]));
                            System.out.println( nombArchi[f]+ "," + (kr+1) + "," +(ip+1)+","+"Bagging"+","+formato(preci_bagg[ip][kr])+","+formato(MSE_bagg[ip][kr])+","+formato(AUC_org[ip][kr])+","+formato(time_train_bagg[ip][kr]));	
                            System.out.println( nombArchi[f]+ "," + (kr+1) + "," +(ip+1)+","+"AdaBoostM1"+","+formato(preci_boos[ip][kr])+","+formato(MSE_boos[ip][kr])+","+formato(AUC_org[ip][kr])+","+formato(time_train_boos[ip][kr]));	

			    //System.out.println(formato(100*preci[ip][kr])+","+ formato(100*preci_comb[ip][kr])+","+ formato(preci_org[ip][kr]));
			}
		//System.out.println("El resultat es: Delegated "+ formato(100*mpreci/(numReps*numFolds))
		//   +" Combinacio"+ formato(100*mpreci_comb/(numReps*numFolds))+
		//   " Original"+ formato(mpreci_org/(numReps*numFolds)));
		//			    System.exit(0);
                
	    }
	    catch (Exception erro){System.out.println("Problemas al abrir el archivo");}

    }



    static void fill_delegated_dataset_threshold(Instances delegated,Instances train, Classifier arbol)
    {
	try{
	    for (int i=0; i<train.numInstances();i++)
		{
		    double classt = arbol.classifyInstance(train.instance(i));
		    double [] confidences =arbol.distributionForInstance(train.instance(i));
		    if (confidences [(int)classt]<threshold1)
			delegated.add(train.instance(i));
		}
	    // System.out.println(// " Totals: "+ dataset.numInstances()+
	    //      " train: " + train.numInstances()+
	    //   " delegated: " + delegated.numInstances());
	}
	catch (Exception erro){System.out.println("Problemas al clasificar instancia");}
    }

    // selecciona el percentatge d'examples (donat per una constant) amb menor
    // confian�a, i crea ompli el conjunt de dades delegated amb eixos exemples

    static double fill_delegated_dataset_percent(Instances delegated,Instances train, Classifier arbol)
    {
	try{
	    Vector ordered_instances=null;
	    ordered_instances= new Vector();

	    Vector ordered_confidences=null;
	    ordered_confidences= new Vector();
	    for (int i=0; i<train.numInstances();i++)
		{
       

		    double classt = arbol.classifyInstance(train.instance(i));
		    double [] confidences =arbol.distributionForInstance(train.instance(i));
                    // ordenem els exemples per confian�a el primer es el de menor confian�a
		    if (ordered_confidences.isEmpty()) 
			{ordered_confidences.add(new Double (confidences[(int)classt]));
			ordered_instances.add(train.instance(i));}
		    else
			{  int elempos=-1;
			for (int k=0;(elempos==-1&&k<ordered_confidences.size());k++)
			    {
				double temp=((Double)ordered_confidences.elementAt(k)).doubleValue();
				if (confidences [(int)classt]<=temp)
				    {  ordered_confidences.insertElementAt(new Double (confidences [(int)classt]),k);
				    ordered_instances.insertElementAt(train.instance(i),k);
				    elempos=k;
				    //break;
				    }
                            }

			if (elempos==-1)
			    {
				ordered_confidences.add(new Double ( confidences [(int)classt]));
				ordered_instances.add(train.instance(i));}

			}


		    //          System.out.println(" conf:" +i +" "+ confidences[(int)classt]);
		}
	    //          if (confidences [(int)classt]<threshold1)
	    //            delegated.add(train.instance(i));
	    //          }
	    // we select the delegated set by default, i.e extracting the instances with confidence minor to the
	    // value of the instance selected by the percentatge       
	    int talla= ordered_confidences.size()*percent/100;
	    double valortalla=((Double)ordered_confidences.elementAt(talla)).doubleValue();
	    int talladefault=0;
	    for (int k=talla;k>=0;k--)
		{
		    double temp=((Double)ordered_confidences.elementAt(k)).doubleValue();
		    if (temp!=valortalla) 
			{ talladefault=k;
			break;}
		}      
    
	    //	    if (talladefault==0) {System.out.println("Error, no examples delegated"); 
	    //	    System.exit(0);}
    
	    for (int k=0;k<=talladefault;k++)
		{ delegated.add(((Instance)ordered_instances.elementAt(k)));}
            
	    //	    System.out.println("valortalla"+ valortalla);
	    return (valortalla);   

    
    
    
	    // System.out.println("Ranked Confidences");
     
	    // for (int k=0;k<ordered_confidences.size();k++)
	    //       {double temp=((Double)ordered_confidences.elementAt(k)).doubleValue();
	    //      System.out.println(" conford:"+k +" " + temp);
	    //    }
	    //     System.out.println(// " Totals: "+ dataset.numInstances()+
	    // " train: " + train.numInstances()+
	    //" delegated: " + delegated.numInstances());
	}
	catch (Exception erro){System.out.println("Problemas al clasificar instancia"); return 0;}
    }


    // crea un nou dataset eleminant a partir del dataset train eliminant els numexem exemples amb més confidence
    static double fill_delegated_dataset_numexem(Instances delegated,Instances train, Classifier arbol, int numexem)
    {
	try{
	    Vector ordered_instances=null;
	    ordered_instances= new Vector();

	    Vector ordered_confidences=null;
	    ordered_confidences= new Vector();
	    for (int i=0; i<train.numInstances();i++)
		{
       

		    double classt = arbol.classifyInstance(train.instance(i));
		    double [] confidences =arbol.distributionForInstance(train.instance(i));
                    // ordenem els exemples per confian�a el primer es el de menor confian�a
		    if (ordered_confidences.isEmpty()) 
			{ordered_confidences.add(new Double (confidences[(int)classt]));
			ordered_instances.add(train.instance(i));}
		    else
			{  int elempos=-1;
			for (int k=0;(elempos==-1&&k<ordered_confidences.size());k++)
			    {
				double temp=((Double)ordered_confidences.elementAt(k)).doubleValue();
				if (confidences [(int)classt]<=temp)
				    {  ordered_confidences.insertElementAt(new Double (confidences [(int)classt]),k);
				    ordered_instances.insertElementAt(train.instance(i),k);
				    elempos=k;
				    //break;
				    }
                            }

			if (elempos==-1)
			    {
				ordered_confidences.add(new Double ( confidences [(int)classt]));
				ordered_instances.add(train.instance(i));}

			}


		    //          System.out.println(" conf:" +i +" "+ confidences[(int)classt]);
		}
	    //          if (confidences [(int)classt]<threshold1)
	    //            delegated.add(train.instance(i));
	    
            int numtalla =ordered_instances.size()-numexem;   
            if (numtalla<0) numtalla=0;
            // el pico de l'ultima iteració se l'afegim a la penultima
            //if (ordered_instances.size()<numexem*2) numtalla =ordered_instances.size();
	    //for (int k=0;k<=numtalla;k++)
	    //	{ delegated.add(((Instance)ordered_instances.elementAt(k)));}
            
	    //	    System.out.println("valortalla"+ valortalla);
	    double valortalla =((Double)ordered_confidences.elementAt(numtalla)).doubleValue();   

          
             
	    int talladefault=0;
	    for (int k=numtalla;k>=0;k--)
		{
		    double temp=((Double)ordered_confidences.elementAt(k)).doubleValue();
		    if (temp!=valortalla) 
			{ talladefault=k;
			break;}
		}      
    
	    //	    if (talladefault==0) {System.out.println("Error, no examples delegated"); 
	    //	    System.exit(0);}
    
	    for (int k=0;k<=talladefault;k++)
		{ delegated.add(((Instance)ordered_instances.elementAt(k)));}
            
	    //	    System.out.println("valortalla"+ valortalla);
	    return (valortalla);   

    
    
	    // System.out.println("Ranked Confidences");
     
	    // for (int k=0;k<ordered_confidences.size();k++)
	    //       {double temp=((Double)ordered_confidences.elementAt(k)).doubleValue();
	    //      System.out.println(" conford:"+k +" " + temp);
	    //    }
	    //     System.out.println(// " Totals: "+ dataset.numInstances()+
	    // " train: " + train.numInstances()+
	    //" delegated: " + delegated.numInstances());
	}
	catch (Exception erro){System.out.println("Problemas al clasificar instancia"); return 0;}
    }

    

    // adaptado para sacar resultados con, s�mbolo de separaci�n de decimales
    public static String formato(double value)
    {
	int afterDecimalPoint=3;

	StringBuffer stringBuffer;
	double temp;
	int i,dotPosition;
	long precisionValue;

	temp = value * Math.pow(10.0, afterDecimalPoint);
	if (Math.abs(temp) < Long.MAX_VALUE) {
	    precisionValue = 	(temp > 0) ? (long)(temp + 0.5)
		: -(long)(Math.abs(temp) + 0.5);
	    if (precisionValue == 0) {
		stringBuffer = new StringBuffer(String.valueOf(0));
	    } else {
		stringBuffer = new StringBuffer(String.valueOf(precisionValue));
	    }
	    if (afterDecimalPoint == 0) {
		return stringBuffer.toString();
	    }
	    dotPosition = stringBuffer.length() - afterDecimalPoint;
	    while (((precisionValue < 0) && (dotPosition < 1)) ||
		   (dotPosition < 0)) {
		if (precisionValue < 0) {
		    stringBuffer.insert(1, '0');
		} else {
		    stringBuffer.insert(0, '0');
		}
		dotPosition++;
	    }
	    stringBuffer.insert(dotPosition, '.');
	    if ((precisionValue < 0) && (stringBuffer.charAt(1) == '.')) {
		stringBuffer.insert(1, '0');
	    } else if (stringBuffer.charAt(0) == '.') {
		stringBuffer.insert(0, '0');
	    }
	    int currentPos = stringBuffer.length() - 1;
	    /*   //  while ((currentPos > dotPosition) &&
		 (stringBuffer.charAt(currentPos) == '0')) {
		 stringBuffer.setCharAt(currentPos--, ' ');
		 }
	    */    if (stringBuffer.charAt(currentPos) == '.') {
		stringBuffer.setCharAt(currentPos, ' ');
	    }

	    return stringBuffer.toString().trim();
	}
	return new String("" + value);
    }
    
    
    
}