Changeset 135 for trunk/CrossPare/src/de/ugoe/cs/cpdp/training

Timestamp:

07/18/16 12:26:03 (8 years ago)

Author:

sherbold

Message:

• code documentation and formatting

Location:

trunk/CrossPare/src/de/ugoe/cs/cpdp/training

Files:

• FixClass.java (modified) (4 diffs)
• GPTraining.java (modified) (23 diffs)
• ISetWiseTestdataAwareTrainingStrategy.java (modified) (2 diffs)
• ISetWiseTrainingStrategy.java (modified) (1 diff)
• ITestAwareTrainingStrategy.java (modified) (1 diff)
• ITrainer.java (modified) (1 diff)
• ITrainingStrategy.java (modified) (1 diff)
• IWekaCompatibleTrainer.java (modified) (1 diff)
• QuadTree.java (modified) (18 diffs)
• WekaBaggingTraining.java (modified) (6 diffs)
• WekaBaseTraining.java (modified) (5 diffs)
• WekaLASERTraining.java (modified) (7 diffs)
• WekaLocalEMTraining.java (modified) (5 diffs)
• WekaLocalFQTraining.java (modified) (25 diffs)
• WekaTestAwareTraining.java (modified) (1 diff)
• WekaTraining.java (modified) (1 diff)

trunk/CrossPare/src/de/ugoe/cs/cpdp/training/FixClass.java

@@ -29 +29 @@
 public class FixClass extends AbstractClassifier {
 
+    /**
+     * default serial ID
+     */
     private static final long serialVersionUID = 1L;
 
+    /**
+     * default prediction: non-defective
+     */
     private double fixedClassValue = 0.0d;
 
@@ -62 +68 @@
     }
 
+    /*
+     * (non-Javadoc)
+     * 
+     * @see weka.classifiers.AbstractClassifier#setOptions(java.lang.String[])
+     */
     @Override
     public void setOptions(String[] options) throws Exception {
@@ -67 +78 @@
     }
 
+    /*
+     * (non-Javadoc)
+     * 
+     * @see weka.classifiers.AbstractClassifier#classifyInstance(weka.core.Instance)
+     */
     @Override
     public double classifyInstance(Instance instance) {
@@ -72 +88 @@
     }
 
+    /*
+     * (non-Javadoc)
+     * 
+     * @see weka.classifiers.Classifier#buildClassifier(weka.core.Instances)
+     */
     @Override
     public void buildClassifier(Instances traindata) throws Exception {

trunk/CrossPare/src/de/ugoe/cs/cpdp/training/GPTraining.java

@@ +1 @@
+
 package de.ugoe.cs.cpdp.training;
 
@@ -45 +46 @@
  * Genetic Programming Trainer
  * 
- * Implementation (mostly) according to Liu et al. Evolutionary Optimization of Software Quality Modeling with Multiple Repositories.
+ * Implementation (mostly) according to Liu et al. Evolutionary Optimization of Software Quality
+ * Modeling with Multiple Repositories.
  * 
- * - GPRun is a Run of a complete Genetic Programm Evolution, we want several complete runs.
- * - GPVClassifier is the Validation Classifier
- * - GPVVClassifier is the Validation-Voting Classifier
+ * - GPRun is a Run of a complete Genetic Programm Evolution, we want several complete runs. -
+ * GPVClassifier is the Validation Classifier - GPVVClassifier is the Validation-Voting Classifier
  * 
- *  config: <setwisetrainer name="GPTraining" param="populationSize:1000,numberRuns:10" />
+ * config: <setwisetrainer name="GPTraining" param="populationSize:1000,numberRuns:10" />
+ * 
+ * @author Alexander Trautsch
  */
-public class GPTraining implements ISetWiseTrainingStrategy, IWekaCompatibleTrainer  {
-    
+public class GPTraining implements ISetWiseTrainingStrategy, IWekaCompatibleTrainer {
+
+    /**
+     * the interal validation-and-voting classifier
+     */
     private GPVVClassifier classifier = null;
-    
-    // default values from the paper
+
+    /**
+     * size of the population of the genetic program; default from the paper is 1000
+     */
     private int populationSize = 1000;
+
+    /**
+     * minimal depth of the S-expression tree at the start of the training; default from the paper
+     * is 2
+     */
     private int initMinDepth = 2;
+
+    /**
+     * maximal depth of the S-expression tree at the start of the training; default from the paper
+     * is 6
+     */
     private int initMaxDepth = 6;
+
+    /**
+     * size of the tournaments used for selection; default from the paper is 7
+     */
     private int tournamentSize = 7;
+
+    /**
+     * number of genetic generations considered (i.e., number of iterations; default from the paper
+     * is 50
+     */
     private int maxGenerations = 50;
+
+    /**
+     * weight factor for the prediction errors for cost estimation; default from the paper is 15
+     */
     private double errorType2Weight = 15;
-    private int numberRuns = 20;  // im paper 20 per errorType2Weight then additional 20
-    private int maxDepth = 20;  // max depth within one program
-    private int maxNodes = 100;  // max nodes within one program
-
+
+    /**
+     * number of internal replications from which the best result is picked; default from the paper
+     * is 20
+     */
+    private int numberRuns = 20;
+
+    /**
+     * maximal depth of the S-expression tree; default from the paper is 20
+     */
+    private int maxDepth = 20;
+
+    /**
+     * maximal number of nodes of the S-expression tree; default from the paper is 100
+     */
+    private int maxNodes = 100;
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see de.ugoe.cs.cpdp.IParameterizable#setParameter(java.lang.String)
+     */
     @Override
     public void setParameter(String parameters) {
-        
+
         String[] params = parameters.split(",");
         String[] keyvalue = new String[2];
 
-        for(int i=0; i < params.length; i++) {
+        for (int i = 0; i < params.length; i++) {
             keyvalue = params[i].split(":");
-            
-            switch(keyvalue[0]) {
+
+            switch (keyvalue[0])
+            {
                 case "populationSize":
                     this.populationSize = Integer.parseInt(keyvalue[1]);
-                break;
-                
+                    break;
+
                 case "initMinDepth":
                     this.initMinDepth = Integer.parseInt(keyvalue[1]);
-                break;
-                
+                    break;
+
                 case "tournamentSize":
                     this.tournamentSize = Integer.parseInt(keyvalue[1]);
-                break;
-                
+                    break;
+
                 case "maxGenerations":
                     this.maxGenerations = Integer.parseInt(keyvalue[1]);
-                break;
-                
+                    break;
+
                 case "errorType2Weight":
                     this.errorType2Weight = Double.parseDouble(keyvalue[1]);
-                break;
-                
+                    break;
+
                 case "numberRuns":
                     this.numberRuns = Integer.parseInt(keyvalue[1]);
-                break;
-                
+                    break;
+
                 case "maxDepth":
                     this.maxDepth = Integer.parseInt(keyvalue[1]);
-                break;
-                
+                    break;
+
                 case "maxNodes":
                     this.maxNodes = Integer.parseInt(keyvalue[1]);
-                break;
-            }
-        }
-        
+                    break;
+            }
+        }
+
         this.classifier = new GPVVClassifier();
-        ((GPVClassifier)this.classifier).configure(populationSize, initMinDepth, initMaxDepth, tournamentSize, maxGenerations, errorType2Weight, numberRuns, maxDepth, maxNodes);
+        ((GPVClassifier) this.classifier)
+            .configure(populationSize, initMinDepth, initMaxDepth, tournamentSize, maxGenerations,
+                       errorType2Weight, numberRuns, maxDepth, maxNodes);
     }
 
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * de.ugoe.cs.cpdp.training.ISetWiseTrainingStrategy#apply(org.apache.commons.collections4.list.
+     * SetUniqueList)
+     */
     @Override
     public void apply(SetUniqueList<Instances> traindataSet) {
         try {
             classifier.buildClassifier(traindataSet);
-        }catch(Exception e) {
+        }
+        catch (Exception e) {
             throw new RuntimeException(e);
         }
     }
 
+    /*
+     * (non-Javadoc)
+     * 
+     * @see de.ugoe.cs.cpdp.training.ISetWiseTrainingStrategy#getName()
+     */
     @Override
     public String getName() {
@@ -130 +195 @@
     }
 
+    /*
+     * (non-Javadoc)
+     * 
+     * @see de.ugoe.cs.cpdp.training.IWekaCompatibleTrainer#getClassifier()
+     */
     @Override
     public Classifier getClassifier() {
         return this.classifier;
     }
-    
+
+    /**
+     * <p>
+     * Internal helper class that stores the data in a format that can be used by the genetic
+     * program.
+     * </p>
+     * 
+     * @author Alexander Trautsch
+     */
     public class InstanceData {
+
+        /**
+         * instances values
+         */
         private double[][] instances_x;
+
+        /**
+         * class labels
+         */
         private boolean[] instances_y;
-        
+
+        /**
+         * <p>
+         * Constructor. Creates the internal data representation.
+         * </p>
+         *
+         * @param instances
+         */
         public InstanceData(Instances instances) {
-            this.instances_x = new double[instances.numInstances()][instances.numAttributes()-1];
+            this.instances_x = new double[instances.numInstances()][instances.numAttributes() - 1];
             this.instances_y = new boolean[instances.numInstances()];
-            
+
             Instance current;
-            for(int i=0; i < this.instances_x.length; i++) {
+            for (int i = 0; i < this.instances_x.length; i++) {
                 current = instances.get(i);
                 this.instances_x[i] = WekaUtils.instanceValues(current);
@@ -150 +243 @@
             }
         }
-        
+
+        /**
+         * <p>
+         * returns the instance values
+         * </p>
+         *
+         * @return
+         */
         public double[][] getX() {
             return instances_x;
         }
+
+        /**
+         * <p>
+         * returns the instance labels
+         * </p>
+         *
+         * @return
+         */
         public boolean[] getY() {
             return instances_y;
         }
     }
-    
+
     /**
      * One Run executed by a GP Classifier
      */
     public class GPRun extends AbstractClassifier {
+
+        /**
+         * generated serialization ID
+         */
         private static final long serialVersionUID = -4250422550107888789L;
 
+        /**
+         * size of the population of the genetic program
+         */
         private int populationSize;
+
+        /**
+         * minimal depth of the S-expression tree at the start of the training
+         */
         private int initMinDepth;
+
+        /**
+         * maximal depth of the S-expression tree at the start of the training
+         */
         private int initMaxDepth;
+
+        /**
+         * size of the tournaments used for selection
+         */
         private int tournamentSize;
+
+        /**
+         * number of genetic generations considered (i.e., number of iterations
+         */
         private int maxGenerations;
+
+        /**
+         * weight factor for the prediction errors for cost estimation
+         */
         private double errorType2Weight;
+
+        /**
+         * maximal depth of the S-expression tree
+         */
         private int maxDepth;
+
+        /**
+         * maximal number of nodes of the S-expression tree
+         */
         private int maxNodes;
-        
+
+        /**
+         * genetic program
+         */
         private GPGenotype gp;
+
+        /**
+         * description of the problem to be solved by the genetic program
+         */
         private GPProblem problem;
-        
-        public void configure(int populationSize, int initMinDepth, int initMaxDepth, int tournamentSize, int maxGenerations, double errorType2Weight, int maxDepth, int maxNodes) {
+
+        /**
+         * <p>
+         * Configures the runner
+         * </p>
+         *
+         * @param populationSize
+         *            the population size
+         * @param initMinDepth
+         *            the initial minimal depth of the S-expression tree
+         * @param initMaxDepth
+         *            the initial maximal depth of the S-expression tree
+         * @param tournamentSize
+         *            the tournament size for selection
+         * @param maxGenerations
+         *            the number of generations created
+         * @param errorType2Weight
+         *            weigth factor for the prediction errors
+         * @param maxDepth
+         *            maximal depth of the S-expression tree
+         * @param maxNodes
+         *            maximal number of nodes of the S-expression tree
+         */
+        public void configure(int populationSize,
+                              int initMinDepth,
+                              int initMaxDepth,
+                              int tournamentSize,
+                              int maxGenerations,
+                              double errorType2Weight,
+                              int maxDepth,
+                              int maxNodes)
+        {
             this.populationSize = populationSize;
             this.initMinDepth = initMinDepth;
@@ -187 +367 @@
             this.maxNodes = maxNodes;
         }
-        
+
+        /**
+         * <p>
+         * returns the genetic program
+         * </p>
+         *
+         * @return the genetic program
+         */
         public GPGenotype getGp() {
             return this.gp;
         }
-        
+
+        /**
+         * <p>
+         * returns the variables of the genetic program
+         * </p>
+         *
+         * @return the variables
+         */
         public Variable[] getVariables() {
-            return ((CrossPareGP)this.problem).getVariables();
-        }
-
+            return ((CrossPareGP) this.problem).getVariables();
+        }
+
+        /*
+         * (non-Javadoc)
+         * 
+         * @see weka.classifiers.Classifier#buildClassifier(weka.core.Instances)
+         */
         @Override
         public void buildClassifier(Instances traindata) throws Exception {
-            InstanceData train = new InstanceData(traindata);            
-            this.problem = new CrossPareGP(train.getX(), train.getY(), this.populationSize, this.initMinDepth, this.initMaxDepth, this.tournamentSize, this.errorType2Weight, this.maxDepth, this.maxNodes);
+            InstanceData train = new InstanceData(traindata);
+            this.problem =
+                new CrossPareGP(train.getX(), train.getY(), this.populationSize, this.initMinDepth,
+                                this.initMaxDepth, this.tournamentSize, this.errorType2Weight,
+                                this.maxDepth, this.maxNodes);
             this.gp = problem.create();
             this.gp.evolve(this.maxGenerations);
         }
-        
+
         /**
          * GPProblem implementation
+         * 
+         * @author Alexander Trautsch
          */
         class CrossPareGP extends GPProblem {
+
+            /**
+             * Instance values of the training data
+             */
             private double[][] instances;
+
+            /**
+             * Classifications of the training data
+             */
             private boolean[] output;
 
+            /**
+             * maximal depth of the S-expression tree
+             */
             private int maxDepth;
+
+            /**
+             * maximal number of nodes of the S-expression tree
+             */
             private int maxNodes;
-            
+
+            /**
+             * variables of the genetic program
+             */
             private Variable[] x;
 
-            public CrossPareGP(double[][] instances, boolean[] output, int populationSize, int minInitDept, int maxInitDepth, int tournamentSize, double errorType2Weight, int maxDepth, int maxNodes) throws InvalidConfigurationException {
+            /**
+             * 
+             * <p>
+             * Constructor. Creates a new genetic program.
+             * </p>
+             *
+             * @param instances
+             *            instance values of the training data
+             * @param output
+             *            classifications of the training data
+             * @param populationSize
+             *            the population size
+             * @param initMinDepth
+             *            the initial minimal depth of the S-expression tree
+             * @param initMaxDepth
+             *            the initial maximal depth of the S-expression tree
+             * @param tournamentSize
+             *            the tournament size for selection
+             * @param maxGenerations
+             *            the number of generations created
+             * @param errorType2Weight
+             *            weigth factor for the prediction errors
+             * @param maxDepth
+             *            maximal depth of the S-expression tree
+             * @param maxNodes
+             *            maximal number of nodes of the S-expression tree
+             * @throws InvalidConfigurationException
+             *             thrown in case the problem cannot be created
+             */
+            public CrossPareGP(double[][] instances,
+                               boolean[] output,
+                               int populationSize,
+                               int minInitDept,
+                               int maxInitDepth,
+                               int tournamentSize,
+                               double errorType2Weight,
+                               int maxDepth,
+                               int maxNodes)
+                throws InvalidConfigurationException
+            {
                 super(new GPConfiguration());
-                
+
                 this.instances = instances;
                 this.output = output;
@@ -226 +487 @@
                 Configuration.reset();
                 GPConfiguration config = this.getGPConfiguration();
-                
+
                 this.x = new Variable[this.instances[0].length];
-               
-                for(int j=0; j < this.x.length; j++) {
-                    this.x[j] = Variable.create(config, "X"+j, CommandGene.DoubleClass);    
-                }
-
-                config.setGPFitnessEvaluator(new DeltaGPFitnessEvaluator()); // smaller fitness is better
-                //config.setGPFitnessEvaluator(new DefaultGPFitnessEvaluator()); // bigger fitness is better
+
+                for (int j = 0; j < this.x.length; j++) {
+                    this.x[j] = Variable.create(config, "X" + j, CommandGene.DoubleClass);
+                }
+
+                config.setGPFitnessEvaluator(new DeltaGPFitnessEvaluator()); // smaller fitness is
+                                                                             // better
+                // config.setGPFitnessEvaluator(new DefaultGPFitnessEvaluator()); // bigger fitness
+                // is better
 
                 config.setMinInitDepth(minInitDept);
                 config.setMaxInitDepth(maxInitDepth);
-                
-                config.setCrossoverProb((float)0.60);
-                config.setReproductionProb((float)0.10);
-                config.setMutationProb((float)0.30);
+
+                config.setCrossoverProb((float) 0.60);
+                config.setReproductionProb((float) 0.10);
+                config.setMutationProb((float) 0.30);
 
                 config.setSelectionMethod(new TournamentSelector(tournamentSize));
@@ -248 +511 @@
 
                 config.setMaxCrossoverDepth(4);
-                config.setFitnessFunction(new CrossPareFitness(this.x, this.instances, this.output, errorType2Weight));
+                config.setFitnessFunction(new CrossPareFitness(this.x, this.instances, this.output,
+                                                               errorType2Weight));
                 config.setStrictProgramCreation(true);
             }
 
-            // used for running the fitness function again for testing
+            /**
+             * <p>
+             * Returns the variables of the problem. Used for running the fitness function again for
+             * testing.
+             * </p>
+             *
+             * @return the variables
+             */
             public Variable[] getVariables() {
                 return this.x;
             }
 
-
+            /**
+             * creates the genetic program
+             */
+            @SuppressWarnings("rawtypes")
             public GPGenotype create() throws InvalidConfigurationException {
                 GPConfiguration config = this.getGPConfiguration();
 
                 // return type
-                Class[] types = {CommandGene.DoubleClass};
+                Class[] types =
+                    { CommandGene.DoubleClass };
 
                 // Arguments of result-producing chromosome: none
-                Class[][] argTypes = { {} };
+                Class[][] argTypes =
+                    { { } };
 
                 // variables + functions, we set the variables with the values of the instances here
                 CommandGene[] vars = new CommandGene[this.instances[0].length];
-                for(int j=0; j < this.instances[0].length; j++) {
+                for (int j = 0; j < this.instances[0].length; j++) {
                     vars[j] = this.x[j];
                 }
-                CommandGene[] funcs = {
-                    new Add(config, CommandGene.DoubleClass),
-                    new Subtract(config, CommandGene.DoubleClass),
-                    new Multiply(config, CommandGene.DoubleClass),
-                    new Divide(config, CommandGene.DoubleClass),
-                    new Sine(config, CommandGene.DoubleClass),
-                    new Cosine(config, CommandGene.DoubleClass),
-                    new Exp(config, CommandGene.DoubleClass),
-                    new Log(config, CommandGene.DoubleClass),
-                    new GT(config, CommandGene.DoubleClass),
-                    new Max(config, CommandGene.DoubleClass),
-                    new Terminal(config, CommandGene.DoubleClass, -100.0, 100.0, true), // min, max, whole numbers
-                };
-
-                CommandGene[] comb = (CommandGene[])ArrayUtils.addAll(vars, funcs);
-                CommandGene[][] nodeSets = {
-                    comb,
-                };
-                
+                CommandGene[] funcs =
+                    { new Add(config, CommandGene.DoubleClass),
+                        new Subtract(config, CommandGene.DoubleClass),
+                        new Multiply(config, CommandGene.DoubleClass),
+                        new Divide(config, CommandGene.DoubleClass),
+                        new Sine(config, CommandGene.DoubleClass),
+                        new Cosine(config, CommandGene.DoubleClass),
+                        new Exp(config, CommandGene.DoubleClass),
+                        new Log(config, CommandGene.DoubleClass),
+                        new GT(config, CommandGene.DoubleClass),
+                        new Max(config, CommandGene.DoubleClass),
+                        new Terminal(config, CommandGene.DoubleClass, -100.0, 100.0, true), // min,
+                                                                                            // max,
+                                                                                            // whole
+                                                                                            // numbers
+                    };
+
+                CommandGene[] comb = (CommandGene[]) ArrayUtils.addAll(vars, funcs);
+                CommandGene[][] nodeSets =
+                    { comb, };
+
                 // we only have one chromosome so this suffices
-                int minDepths[] = {config.getMinInitDepth()};
-                int maxDepths[] = {this.maxDepth};
-                GPGenotype result = GPGenotype.randomInitialGenotype(config, types, argTypes, nodeSets, minDepths, maxDepths, this.maxNodes, false); // 40 = maxNodes, true = verbose output
+                int minDepths[] =
+                    { config.getMinInitDepth() };
+                int maxDepths[] =
+                    { this.maxDepth };
+                GPGenotype result =
+                    GPGenotype.randomInitialGenotype(config, types, argTypes, nodeSets, minDepths,
+                                                     maxDepths, this.maxNodes, false); // 40 =
+                                                                                       // maxNodes,
+                                                                                       // true =
+                                                                                       // verbose
+                                                                                       // output
 
                 return result;
@@ -300 +586 @@
         }
 
-        
-        /**
-         * Fitness function
+        /**
+         * Internal helper class for the fitness function.
+         * 
+         * @author Alexander Trautsch
          */
         class CrossPareFitness extends GPFitnessFunction {
-            
+
+            /**
+             * generated serialization ID
+             */
             private static final long serialVersionUID = 75234832484387L;
 
+            /**
+             * variables of the genetic program
+             */
             private Variable[] x;
 
+            /**
+             * instance values of the training data
+             */
             private double[][] instances;
+
+            /**
+             * classifications of the training data
+             */
             private boolean[] output;
 
+            /**
+             * weight of the error costs
+             */
             private double errorType2Weight = 1.0;
 
             // needed in evaluate
-            //private Object[] NO_ARGS = new Object[0];
-
+            // private Object[] NO_ARGS = new Object[0];
+
+            /**
+             * fitness value
+             */
             private double sfitness = 0.0f;
+
+            /**
+             * type I error
+             */
             private int errorType1 = 0;
+
+            /**
+             * type II error
+             */
             private int errorType2 = 0;
 
-            public CrossPareFitness(Variable[] x, double[][] instances, boolean[] output, double errorType2Weight) {
+            /**
+             * <p>
+             * Constructor. Creates a new fitness function.
+             * </p>
+             *
+             * @param x
+             *            variables of the genetic program
+             * @param instances
+             *            instance values of the training data
+             * @param output
+             *            classification of the training data
+             * @param errorType2Weight
+             *            weight of the error costs
+             */
+            public CrossPareFitness(Variable[] x,
+                                    double[][] instances,
+                                    boolean[] output,
+                                    double errorType2Weight)
+            {
                 this.x = x;
                 this.instances = instances;
@@ -329 +661 @@
             }
 
+            /**
+             * <p>
+             * returns the type I error
+             * </p>
+             *
+             * @return type I error
+             */
             public int getErrorType1() {
                 return this.errorType1;
             }
 
+            /**
+             * <p>
+             * returns the type II error
+             * </p>
+             *
+             * @return type II error
+             */
             public int getErrorType2() {
                 return this.errorType2;
             }
 
+            /**
+             * <p>
+             * returns the value of the secondary fitness function
+             * </p>
+             *
+             * @return secondary fitness
+             */
             public double getSecondFitness() {
                 return this.sfitness;
             }
 
+            /**
+             * <p>
+             * returns the number of training instances
+             * </p>
+             *
+             * @return number of instances
+             */
             public int getNumInstances() {
                 return this.instances.length;
@@ -346 +706 @@
 
             /**
-             * This is the fitness function
+             * <p>
+             * The fitness function. Our fitness is best if we have the less wrong classifications,
+             * this includes a weight for type2 errors.
+             * </p>
              * 
-             * Our fitness is best if we have the less wrong classifications, this includes a weight for type2 errors
+             * @param program
+             *            the genetic program whose fitness is evaluated.
+             * 
+             * @see org.jgap.gp.GPFitnessFunction#evaluate(org.jgap.gp.IGPProgram)
              */
             @Override
@@ -360 +726 @@
                 this.errorType2 = 0;
 
-                for(int i=0; i < this.instances.length; i++) {
-
-                    // requires that we have a variable for each column of our dataset (attribute of instance)
-                    for(int j=0; j < this.x.length; j++) {
+                for (int i = 0; i < this.instances.length; i++) {
+
+                    // requires that we have a variable for each column of our dataset (attribute of
+                    // instance)
+                    for (int j = 0; j < this.x.length; j++) {
                         this.x[j].set(this.instances[i][j]);
                     }
@@ -370 +737 @@
                     value = program.execute_double(0, this.x);
 
-                    if(value < 0.5) {
-                        if(this.output[i] != true) {
+                    if (value < 0.5) {
+                        if (this.output[i] != true) {
                             this.errorType1 += 1;
                         }
-                    }else {
-                        if(this.output[i] == true) {
+                    }
+                    else {
+                        if (this.output[i] == true) {
                             this.errorType2 += 1;
                         }
@@ -382 +750 @@
 
                 // now calc pfitness
-                pfitness = (this.errorType1 + this.errorType2Weight * this.errorType2) / this.instances.length;
+                pfitness = (this.errorType1 + this.errorType2Weight * this.errorType2) /
+                    this.instances.length;
 
                 // number of nodes in the programm, if lower then 10 we assign sFitness of 10
                 // we can set metadata with setProgramData to save this
-                if(program.getChromosome(0).getSize(0) < 10) {
+                if (program.getChromosome(0).getSize(0) < 10) {
                     program.setApplicationData(10.0f);
                 }
@@ -393 +762 @@
             }
         }
-        
+
         /**
          * Custom GT implementation used in the GP Algorithm.
-         */
-         public class GT extends MathCommand implements ICloneable {
-             
-             private static final long serialVersionUID = 113454184817L;
-
-             public GT(final GPConfiguration a_conf, java.lang.Class a_returnType) throws InvalidConfigurationException {
-                 super(a_conf, 2, a_returnType);
-             }
-
-             public String toString() {
-                 return "GT(&1, &2)";
-             }
-
-             public String getName() {
-                 return "GT";
-             }   
-
-             public float execute_float(ProgramChromosome c, int n, Object[] args) {
-                 float f1 = c.execute_float(n, 0, args);
-                 float f2 = c.execute_float(n, 1, args);
-
-                 float ret = 1.0f;
-                 if(f1 > f2) {
-                     ret = 0.0f;
-                 }
-
-                 return ret;
-             }
-
-             public double execute_double(ProgramChromosome c, int n, Object[] args) {
-                 double f1 = c.execute_double(n, 0, args);
-                 double f2 = c.execute_double(n, 1, args);
-
-                 double ret = 1;
-                 if(f1 > f2)  {
-                     ret = 0;
-                 }
-                 return ret;
-             }
-
-             public Object clone() {
-                 try {
-                     GT result = new GT(getGPConfiguration(), getReturnType());
-                     return result;
-                 }catch(Exception ex) {
-                     throw new CloneException(ex);
-                 }
-             }
-         }
+         * 
+         * @author Alexander Trautsch
+         */
+        public class GT extends MathCommand implements ICloneable {
+
+            /**
+             * generated serialization ID.
+             */
+            private static final long serialVersionUID = 113454184817L;
+
+            /**
+             * <p>
+             * Constructor. Creates a new GT.
+             * </p>
+             *
+             * @param a_conf
+             *            the configuration of the genetic program
+             * @param a_returnType
+             *            the return type
+             * @throws InvalidConfigurationException
+             *             thrown is there is a problem during the initialization of the super class
+             * 
+             * @see MathCommand
+             */
+            public GT(final GPConfiguration a_conf, @SuppressWarnings("rawtypes") java.lang.Class a_returnType)
+                throws InvalidConfigurationException
+            {
+                super(a_conf, 2, a_returnType);
+            }
+
+            /*
+             * (non-Javadoc)
+             * 
+             * @see org.jgap.gp.CommandGene#toString()
+             */
+            @Override
+            public String toString() {
+                return "GT(&1, &2)";
+            }
+
+            /*
+             * (non-Javadoc)
+             * 
+             * @see org.jgap.gp.CommandGene#getName()
+             */
+            @Override
+            public String getName() {
+                return "GT";
+            }
+
+            /*
+             * (non-Javadoc)
+             * 
+             * @see org.jgap.gp.CommandGene#execute_float(org.jgap.gp.impl.ProgramChromosome, int,
+             * java.lang.Object[])
+             */
+            @Override
+            public float execute_float(ProgramChromosome c, int n, Object[] args) {
+                float f1 = c.execute_float(n, 0, args);
+                float f2 = c.execute_float(n, 1, args);
+
+                float ret = 1.0f;
+                if (f1 > f2) {
+                    ret = 0.0f;
+                }
+
+                return ret;
+            }
+
+            /*
+             * (non-Javadoc)
+             * 
+             * @see org.jgap.gp.CommandGene#execute_double(org.jgap.gp.impl.ProgramChromosome, int,
+             * java.lang.Object[])
+             */
+            @Override
+            public double execute_double(ProgramChromosome c, int n, Object[] args) {
+                double f1 = c.execute_double(n, 0, args);
+                double f2 = c.execute_double(n, 1, args);
+
+                double ret = 1;
+                if (f1 > f2) {
+                    ret = 0;
+                }
+                return ret;
+            }
+
+            /*
+             * (non-Javadoc)
+             * 
+             * @see java.lang.Object#clone()
+             */
+            @Override
+            public Object clone() {
+                try {
+                    GT result = new GT(getGPConfiguration(), getReturnType());
+                    return result;
+                }
+                catch (Exception ex) {
+                    throw new CloneException(ex);
+                }
+            }
+        }
     }
-    
+
     /**
      * GP Multiple Data Sets Validation-Voting Classifier
      * 
-     * Basically the same as the GP Multiple Data Sets Validation Classifier.
-     * But here we do keep a model candidate for each training set which may later vote
+     * Basically the same as the GP Multiple Data Sets Validation Classifier. But here we do keep a
+     * model candidate for each training set which may later vote
      *
      */
     public class GPVVClassifier extends GPVClassifier {
 
+        /**
+         * generated serialization ID
+         */
         private static final long serialVersionUID = -654710583852839901L;
+
+        /**
+         * classifiers for each validation set
+         */
         private List<Classifier> classifiers = null;
-        
+
+        /*
+         * (non-Javadoc)
+         * 
+         * @see
+         * de.ugoe.cs.cpdp.training.GPTraining.GPVClassifier#buildClassifier(weka.core.Instances)
+         */
         @Override
         public void buildClassifier(Instances arg0) throws Exception {
             // TODO Auto-generated method stub
-            
-        }
-        
-        /** Build the GP Multiple Data Sets Validation-Voting Classifier
-         * 
-         * This is according to Section 6 of the Paper by Liu et al.
-         * It is basically the Multiple Data Sets Validation Classifier but here we keep the best models an let them vote.
+        }
+
+        /**
+         * Build the GP Multiple Data Sets Validation-Voting Classifier
+         * 
+         * This is according to Section 6 of the Paper by Liu et al. It is basically the Multiple
+         * Data Sets Validation Classifier but here we keep the best models an let them vote.
          * 
          * @param traindataSet
+         *            the training data
          * @throws Exception
+         *             thrown in case of a problem with the training
          */
         public void buildClassifier(SetUniqueList<Instances> traindataSet) throws Exception {
@@ -478 +916 @@
             // then is evaluated on the rest
             classifiers = new LinkedList<>();
-            for(int i=0; i < traindataSet.size(); i++) {
+            for (int i = 0; i < traindataSet.size(); i++) {
 
                 // candidates we get out of evaluation
                 LinkedList<Classifier> candidates = new LinkedList<>();
-                
+
                 // number of runs, yields the best of these
-                double smallest_error_count_train = Double.MAX_VALUE; 
+                double smallest_error_count_train = Double.MAX_VALUE;
                 Classifier bestTrain = null;
-                for(int k=0; k < this.numberRuns; k++) {
-                    double[] errors_eval = {0.0, 0.0};
+                for (int k = 0; k < this.numberRuns; k++) {
+                    double[] errors_eval =
+                        { 0.0, 0.0 };
                     Classifier classifier = new GPRun();
-                    ((GPRun)classifier).configure(this.populationSize, this.initMinDepth, this.initMaxDepth, this.tournamentSize, this.maxGenerations, this.errorType2Weight, this.maxDepth, this.maxNodes);
-                    
+                    ((GPRun) classifier).configure(this.populationSize, this.initMinDepth,
+                                                   this.initMaxDepth, this.tournamentSize,
+                                                   this.maxGenerations, this.errorType2Weight,
+                                                   this.maxDepth, this.maxNodes);
+
                     // one project is training data
                     classifier.buildClassifier(traindataSet.get(i));
-                    
+
                     double[] errors;
                     // rest of the set is evaluation data, we evaluate now
-                    for(int j=0; j < traindataSet.size(); j++) {
-                        if(j != i) {
-                            // if type1 and type2 errors are < 0.5 we allow the model in the candidates
-                            errors = this.evaluate((GPRun)classifier, traindataSet.get(j));
+                    for (int j = 0; j < traindataSet.size(); j++) {
+                        if (j != i) {
+                            // if type1 and type2 errors are < 0.5 we allow the model in the
+                            // candidates
+                            errors = this.evaluate((GPRun) classifier, traindataSet.get(j));
                             errors_eval[0] += errors[0];
                             errors_eval[1] += errors[1];
-                            if((errors[0] < 0.5) && (errors[1] < 0.5)) {
+                            if ((errors[0] < 0.5) && (errors[1] < 0.5)) {
                                 candidates.add(classifier);
                             }
                         }
                     }
-                    
+
                     // if the candidate made fewer errors it is now the best
-                    if(errors_eval[0] + errors_eval[1] < smallest_error_count_train) {
+                    if (errors_eval[0] + errors_eval[1] < smallest_error_count_train) {
                         bestTrain = classifier;
                         smallest_error_count_train = errors_eval[0] + errors_eval[1];
@@ -515 +958 @@
                 }
 
-                // now after the evaluation we do a model selection where only one model remains for the given training data
+                // now after the evaluation we do a model selection where only one model remains for
+                // the given training data
                 // we select the model which is best on all evaluation data
                 double smallest_error_count = Double.MAX_VALUE;
                 double[] errors;
                 Classifier best = null;
-                for(int ii=0; ii < candidates.size(); ii++) {
-                    double[] errors_eval = {0.0, 0.0};
-                    
+                for (int ii = 0; ii < candidates.size(); ii++) {
+                    double[] errors_eval =
+                        { 0.0, 0.0 };
+
                     // we add the errors the candidate makes over the evaldata
-                    for(int j=0; j < traindataSet.size(); j++) {
-                        if(j != i) {
-                            errors = this.evaluate((GPRun)candidates.get(ii), traindataSet.get(j));
+                    for (int j = 0; j < traindataSet.size(); j++) {
+                        if (j != i) {
+                            errors = this.evaluate((GPRun) candidates.get(ii), traindataSet.get(j));
                             errors_eval[0] += errors[0];
                             errors_eval[1] += errors[1];
                         }
                     }
-                    
+
                     // if the candidate made fewer errors it is now the best
-                    if(errors_eval[0] + errors_eval[1] < smallest_error_count) {
+                    if (errors_eval[0] + errors_eval[1] < smallest_error_count) {
                         best = candidates.get(ii);
                         smallest_error_count = errors_eval[0] + errors_eval[1];
                     }
                 }
-                
-                if( best==null ) {
+
+                if (best == null) {
                     best = bestTrain;
                 }
@@ -546 +991 @@
             }
         }
-        
+
         /**
          * Use the best classifiers for each training data in a majority voting
+         * 
+         * @param instance
+         *            instance that is classified
+         * 
+         * @see de.ugoe.cs.cpdp.training.GPTraining.GPVClassifier#classifyInstance(weka.core.Instance)
          */
         @Override
         public double classifyInstance(Instance instance) {
-            
+
             int vote_positive = 0;
-            
+
             for (int i = 0; i < classifiers.size(); i++) {
                 Classifier classifier = classifiers.get(i);
-                
-                GPGenotype gp = ((GPRun)classifier).getGp();
-                Variable[] vars = ((GPRun)classifier).getVariables();
-                
-                IGPProgram fitest = gp.getAllTimeBest();  // all time fitest
-                for(int j = 0; j < instance.numAttributes()-1; j++) {
-                   vars[j].set(instance.value(j));
-                }
-                
-                if(fitest.execute_double(0, vars) < 0.5) {
+
+                GPGenotype gp = ((GPRun) classifier).getGp();
+                Variable[] vars = ((GPRun) classifier).getVariables();
+
+                IGPProgram fitest = gp.getAllTimeBest(); // all time fitest
+                for (int j = 0; j < instance.numAttributes() - 1; j++) {
+                    vars[j].set(instance.value(j));
+                }
+
+                if (fitest.execute_double(0, vars) < 0.5) {
                     vote_positive += 1;
                 }
             }
-            
-            if(vote_positive >= (classifiers.size()/2)) {
+
+            if (vote_positive >= (classifiers.size() / 2)) {
                 return 1.0;
-            }else {
+            }
+            else {
                 return 0.0;
             }
         }
     }
-    
+
     /**
      * GP Multiple Data Sets Validation Classifier
      * 
-     * We train a Classifier with one training project $numberRun times.
-     * Then we evaluate the classifier on the rest of the training projects and keep the best classifier.
-     * After that we have for each training project the best classifier as per the evaluation on the rest of the data set.
-     * Then we determine the best classifier from these candidates and keep it to be used later.
+     * We train a Classifier with one training project $numberRun times. Then we evaluate the
+     * classifier on the rest of the training projects and keep the best classifier. After that we
+     * have for each training project the best classifier as per the evaluation on the rest of the
+     * data set. Then we determine the best classifier from these candidates and keep it to be used
+     * later.
+     * 
+     * @author sherbold Alexander Trautsch
      */
     public class GPVClassifier extends AbstractClassifier {
-        
+
         private List<Classifier> classifiers = null;
         private Classifier best = null;
@@ -594 +1048 @@
         private static final long serialVersionUID = 3708714057579101522L;
 
+        /**
+         * size of the population of the genetic program
+         */
         protected int populationSize;
+
+        /**
+         * minimal depth of the S-expression tree at the start of the training
+         */
         protected int initMinDepth;
+
+        /**
+         * maximal depth of the S-expression tree at the start of the training
+         */
         protected int initMaxDepth;
+
+        /**
+         * size of the tournaments used for selection
+         */
         protected int tournamentSize;
+
+        /**
+         * number of genetic generations considered (i.e., number of iterations
+         */
         protected int maxGenerations;
+
+        /**
+         * weight factor for the prediction errors for cost estimation
+         */
         protected double errorType2Weight;
-        protected int numberRuns;
+
+        /**
+         * number of internal replications from which the best result is picked
+         */
+        protected int numberRuns = 20;
+
+        /**
+         * maximal depth of the S-expression tree
+         */
         protected int maxDepth;
+
+        /**
+         * maximal number of nodes of the S-expression tree
+         */
         protected int maxNodes;
 
         /**
+         * 
+         * <p>
          * Configure the GP Params and number of Runs
+         * </p>
          * 
          * @param populationSize
+         *            the population size
          * @param initMinDepth
+         *            the initial minimal depth of the S-expression tree
          * @param initMaxDepth
+         *            the initial maximal depth of the S-expression tree
          * @param tournamentSize
+         *            the tournament size for selection
          * @param maxGenerations
+         *            the number of generations created
          * @param errorType2Weight
-         */
-        public void configure(int populationSize, int initMinDepth, int initMaxDepth, int tournamentSize, int maxGenerations, double errorType2Weight, int numberRuns, int maxDepth, int maxNodes) {
+         *            weigth factor for the prediction errors
+         * @param numberRuns
+         *            number of internal replications from which the best result is picked
+         * @param maxDepth
+         *            maximal depth of the S-expression tree
+         * @param maxNodes
+         *            maximal number of nodes of the S-expression tree
+         */
+        public void configure(int populationSize,
+                              int initMinDepth,
+                              int initMaxDepth,
+                              int tournamentSize,
+                              int maxGenerations,
+                              double errorType2Weight,
+                              int numberRuns,
+                              int maxDepth,
+                              int maxNodes)
+        {
             this.populationSize = populationSize;
             this.initMinDepth = initMinDepth;
@@ -625 +1138 @@
             this.maxNodes = maxNodes;
         }
-        
-        /** Build the GP Multiple Data Sets Validation Classifier
-         * 
-         * This is according to Section 6 of the Paper by Liu et al. except for the selection of the best model.
-         * Section 4 describes a slightly different approach.
+
+        /**
+         * Build the GP Multiple Data Sets Validation Classifier
+         * 
+         * This is according to Section 6 of the Paper by Liu et al. except for the selection of the
+         * best model. Section 4 describes a slightly different approach.
          * 
          * @param traindataSet
+         *            the training data
          * @throws Exception
+         *             thrown in case of a problem with the training
          */
         public void buildClassifier(SetUniqueList<Instances> traindataSet) throws Exception {
@@ -638 +1154 @@
             // each classifier is trained with one project from the set
             // then is evaluated on the rest
-            for(int i=0; i < traindataSet.size(); i++) {
-                
+            for (int i = 0; i < traindataSet.size(); i++) {
+
                 // candidates we get out of evaluation
                 LinkedList<Classifier> candidates = new LinkedList<>();
-                
+
                 // numberRuns full GPRuns, we generate numberRuns models for each traindata
-                for(int k=0; k < this.numberRuns; k++) {
+                for (int k = 0; k < this.numberRuns; k++) {
                     Classifier classifier = new GPRun();
-                    ((GPRun)classifier).configure(this.populationSize, this.initMinDepth, this.initMaxDepth, this.tournamentSize, this.maxGenerations, this.errorType2Weight, this.maxDepth, this.maxNodes);
-                    
+                    ((GPRun) classifier).configure(this.populationSize, this.initMinDepth,
+                                                   this.initMaxDepth, this.tournamentSize,
+                                                   this.maxGenerations, this.errorType2Weight,
+                                                   this.maxDepth, this.maxNodes);
+
                     classifier.buildClassifier(traindataSet.get(i));
-                    
+
                     double[] errors;
 
                     // rest of the set is evaluation data, we evaluate now
-                    for(int j=0; j < traindataSet.size(); j++) {
-                        if(j != i) {
-                            // if type1 and type2 errors are < 0.5 we allow the model in the candidate list
-                            errors = this.evaluate((GPRun)classifier, traindataSet.get(j));
-                            if((errors[0] < 0.5) && (errors[1] < 0.5)) {
+                    for (int j = 0; j < traindataSet.size(); j++) {
+                        if (j != i) {
+                            // if type1 and type2 errors are < 0.5 we allow the model in the
+                            // candidate list
+                            errors = this.evaluate((GPRun) classifier, traindataSet.get(j));
+                            if ((errors[0] < 0.5) && (errors[1] < 0.5)) {
                                 candidates.add(classifier);
                             }
@@ -663 +1183 @@
                     }
                 }
-                
-                // now after the evaluation we do a model selection where only one model remains for the given training data
+
+                // now after the evaluation we do a model selection where only one model remains for
+                // the given training data
                 // we select the model which is best on all evaluation data
                 double smallest_error_count = Double.MAX_VALUE;
                 double[] errors;
                 Classifier best = null;
-                for(int ii=0; ii < candidates.size(); ii++) {
-                    double[] errors_eval = {0.0, 0.0};
-                    
+                for (int ii = 0; ii < candidates.size(); ii++) {
+                    double[] errors_eval =
+                        { 0.0, 0.0 };
+
                     // we add the errors the candidate makes over the evaldata
-                    for(int j=0; j < traindataSet.size(); j++) {
-                        if(j != i) {
-                            errors = this.evaluate((GPRun)candidates.get(ii), traindataSet.get(j));
+                    for (int j = 0; j < traindataSet.size(); j++) {
+                        if (j != i) {
+                            errors = this.evaluate((GPRun) candidates.get(ii), traindataSet.get(j));
                             errors_eval[0] += errors[0];
                             errors_eval[1] += errors[1];
                         }
                     }
-                    
+
                     // if the candidate made fewer errors it is now the best
-                    if(errors_eval[0] + errors_eval[1] < smallest_error_count) {
+                    if (errors_eval[0] + errors_eval[1] < smallest_error_count) {
                         best = candidates.get(ii);
                         smallest_error_count = errors_eval[0] + errors_eval[1];
                     }
                 }
-                
-                
+
                 // now we have the best classifier for this training data
                 classifiers.add(best);
 
             } /* endfor trainData */
-            
-            // now we have one best classifier for each trainData 
+
+            // now we have one best classifier for each trainData
             // we evaluate again to find the best classifier of all time
-            // this selection is now according to section 4 of the paper and not 6 where an average of the 6 models is build 
+            // this selection is now according to section 4 of the paper and not 6 where an average
+            // of the 6 models is build
             double smallest_error_count = Double.MAX_VALUE;
             double error_count;
             double errors[];
-            for(int j=0; j < classifiers.size(); j++) {
+            for (int j = 0; j < classifiers.size(); j++) {
                 error_count = 0;
                 Classifier current = classifiers.get(j);
-                for(int i=0; i < traindataSet.size(); i++) {
-                    errors = this.evaluate((GPRun)current, traindataSet.get(i));
+                for (int i = 0; i < traindataSet.size(); i++) {
+                    errors = this.evaluate((GPRun) current, traindataSet.get(i));
                     error_count = errors[0] + errors[1];
                 }
-                
-                if(error_count < smallest_error_count) {
+
+                if (error_count < smallest_error_count) {
                     best = current;
                 }
             }
         }
-        
+
+        /*
+         * (non-Javadoc)
+         * 
+         * @see weka.classifiers.Classifier#buildClassifier(weka.core.Instances)
+         */
         @Override
         public void buildClassifier(Instances traindata) throws Exception {
             final Classifier classifier = new GPRun();
-            ((GPRun)classifier).configure(populationSize, initMinDepth, initMaxDepth, tournamentSize, maxGenerations, errorType2Weight, this.maxDepth, this.maxNodes);
+            ((GPRun) classifier).configure(populationSize, initMinDepth, initMaxDepth,
+                                           tournamentSize, maxGenerations, errorType2Weight,
+                                           this.maxDepth, this.maxNodes);
             classifier.buildClassifier(traindata);
             classifiers.add(classifier);
         }
-        
-        /**
-         * Evaluation of the Classifier
-         * 
-         * We evaluate the classifier with the Instances of the evalData.
-         * It basically assigns the instance attribute values to the variables of the s-expression-tree and 
-         * then counts the missclassifications. 
+
+        /**
+         * <p>
+         * Evaluation of the Classifier.
+         * </p>
+         * <p>
+         * We evaluate the classifier with the Instances of the evalData. It basically assigns the
+         * instance attribute values to the variables of the s-expression-tree and then counts the
+         * missclassifications.
+         * </p>
          * 
          * @param classifier
+         *            the classifier that is evaluated
          * @param evalData
+         *            the validation data
          * @return
          */
@@ -736 +1270 @@
             GPGenotype gp = classifier.getGp();
             Variable[] vars = classifier.getVariables();
-            
-            IGPProgram fitest = gp.getAllTimeBest();  // selects the fitest of all not just the last generation
-            
+
+            IGPProgram fitest = gp.getAllTimeBest(); // selects the fitest of all not just the last
+                                                     // generation
+
             double classification;
             int error_type1 = 0;
@@ -744 +1279 @@
             int positive = 0;
             int negative = 0;
-            
-            for(Instance instance: evalData) {
-                
+
+            for (Instance instance : evalData) {
+
                 // assign instance attribute values to the variables of the s-expression-tree
                 double[] tmp = WekaUtils.instanceValues(instance);
-                for(int i = 0; i < tmp.length; i++) {
+                for (int i = 0; i < tmp.length; i++) {
                     vars[i].set(tmp[i]);
                 }
-                
+
                 classification = fitest.execute_double(0, vars);
-                
+
                 // we need to count the absolutes of positives for percentage
-                if(instance.classValue() == 1.0) {
-                    positive +=1;
-                }else {
-                    negative +=1;
-                }
-                
+                if (instance.classValue() == 1.0) {
+                    positive += 1;
+                }
+                else {
+                    negative += 1;
+                }
+
                 // classification < 0.5 we say defective
-                if(classification < 0.5) {
-                    if(instance.classValue() != 1.0) {
+                if (classification < 0.5) {
+                    if (instance.classValue() != 1.0) {
                         error_type1 += 1;
                     }
-                }else {
-                    if(instance.classValue() == 1.0) {
+                }
+                else {
+                    if (instance.classValue() == 1.0) {
                         error_type2 += 1;
                     }
                 }
             }
-            
-            // return error types percentages for the types 
+
+            // return error types percentages for the types
             double et1_per = error_type1 / negative;
-            double et2_per = error_type2 / positive; 
-            return new double[]{et1_per, et2_per};
-        }
-        
+            double et2_per = error_type2 / positive;
+            return new double[]
+                { et1_per, et2_per };
+        }
+
         /**
          * Use only the best classifier from our evaluation phase
+         * 
+         * @param instance
+         *            instance that is classified
+         * 
+         * @see weka.classifiers.AbstractClassifier#classifyInstance(weka.core.Instance)
          */
         @Override
         public double classifyInstance(Instance instance) {
-            GPGenotype gp = ((GPRun)best).getGp();
-            Variable[] vars = ((GPRun)best).getVariables();
-            
-            IGPProgram fitest = gp.getAllTimeBest();  // all time fitest
-            for(int i = 0; i < instance.numAttributes()-1; i++) {
-               vars[i].set(instance.value(i));
-            }
-            
+            GPGenotype gp = ((GPRun) best).getGp();
+            Variable[] vars = ((GPRun) best).getVariables();
+
+            IGPProgram fitest = gp.getAllTimeBest(); // all time fitest
+            for (int i = 0; i < instance.numAttributes() - 1; i++) {
+                vars[i].set(instance.value(i));
+            }
+
             double classification = fitest.execute_double(0, vars);
-            
-            if(classification < 0.5) {
+
+            if (classification < 0.5) {
                 return 1.0;
-            }else {
+            }
+            else {
                 return 0.0;
             }

trunk/CrossPare/src/de/ugoe/cs/cpdp/training/ISetWiseTestdataAwareTrainingStrategy.java

@@ +1 @@
+
 package de.ugoe.cs.cpdp.training;
 
@@ -4 +5 @@
 import weka.core.Instances;
 
+/**
+ * <p>
+ * Training strategy for training with access to the target data and one data set per input product.
+ * </p>
+ * 
+ * @author Steffen Herbold
+ */
 public interface ISetWiseTestdataAwareTrainingStrategy extends ITrainer {
 
+    /**
+     * <p>
+     * Applies the training strategy.
+     * </p>
+     *
+     * @param traindataSet
+     *            the training data per product
+     * @param testdata
+     *            the test data from the target product
+     */
     void apply(SetUniqueList<Instances> traindataSet, Instances testdata);
 
+    /**
+     * <p>
+     * returns the name of the training strategy
+     * </p>
+     *
+     * @return the name
+     */
     String getName();
-    
+
+    // TODO: these two methods look like they should be removed and instead be handled using the parameters
     void setMethod(String method);
+
     void setThreshold(String threshold);
 }

trunk/CrossPare/src/de/ugoe/cs/cpdp/training/ISetWiseTrainingStrategy.java

@@ -19 +19 @@
 import weka.core.Instances;
 
-// Bagging Strategy: separate models for each training data set
+/**
+ * <p>
+ * Training strategy for training with one data set per input product.
+ * </p>
+ * 
+ * @author Steffen Herbold
+ */
 public interface ISetWiseTrainingStrategy extends ITrainer {
 
+    /**
+     * <p>
+     * Applies the training strategy.
+     * </p>
+     *
+     * @param traindataSet
+     *            the training data per product
+     */
     void apply(SetUniqueList<Instances> traindataSet);
 
+    /**
+     * <p>
+     * returns the name of the training strategy
+     * </p>
+     *
+     * @return the name
+     */
     String getName();
 }

trunk/CrossPare/src/de/ugoe/cs/cpdp/training/ITestAwareTrainingStrategy.java

@@ -3 +3 @@
 import weka.core.Instances;
 
+/**
+ * <p>
+ * Training strategy for training with access to the target data and the training data as a single data set.
+ * </p>
+ * 
+ * @author Steffen Herbold
+ */
 public interface ITestAwareTrainingStrategy extends ITrainer {
     
+    /**
+     * <p>
+     * Applies the training strategy.
+     * </p>
+     *
+     * @param traindata
+     *            the training data for all products
+     * @param testdata
+     *            the test data from the target product
+     */
     void apply(Instances testdata, Instances traindata);
 
+    /**
+     * <p>
+     * returns the name of the training strategy
+     * </p>
+     *
+     * @return the name
+     */
     String getName();
 }

trunk/CrossPare/src/de/ugoe/cs/cpdp/training/ITrainer.java

@@ -17 +17 @@
 import de.ugoe.cs.cpdp.IParameterizable;
 
+/**
+ * <p>
+ * Marker interface for all CrossPare trainers.
+ * </p>
+ * 
+ * @author Steffen Herbold
+ */
 public interface ITrainer extends IParameterizable {
 

trunk/CrossPare/src/de/ugoe/cs/cpdp/training/ITrainingStrategy.java

@@ -17 +17 @@
 import weka.core.Instances;
 
+/**
+ * <p>
+ * Training strategy for training with the training data as a single data set.
+ * </p>
+ * 
+ * @author Steffen Herbold
+ */
 public interface ITrainingStrategy extends ITrainer {
 
+    /**
+     * <p>
+     * Applies the training strategy.
+     * </p>
+     *
+     * @param traindata
+     *            the training data for all target products
+     */
     void apply(Instances traindata);
 
+    /**
+     * <p>
+     * returns the name of the training strategy
+     * </p>
+     *
+     * @return the name
+     */
     String getName();
 }

trunk/CrossPare/src/de/ugoe/cs/cpdp/training/IWekaCompatibleTrainer.java

@@ -17 +17 @@
 import weka.classifiers.Classifier;
 
+/**
+ * <p>
+ * Common interface for all training strategies that internally use the {@link Classifier} from WEKA. 
+ * </p>
+ * 
+ * @author Steffen Herbold
+ */
 public interface IWekaCompatibleTrainer extends ITrainer {
 
+    /**
+     * <p>
+     * returns the WEKA classifier
+     * </p>
+     *
+     * @return the classifier
+     */
     Classifier getClassifier();
 
+    /**
+     * <p>
+     * returns the name of the training strategy
+     * </p>
+     *
+     * @return the name
+     */
     String getName();
 }

trunk/CrossPare/src/de/ugoe/cs/cpdp/training/QuadTree.java

@@ -24 +24 @@
 
 /**
- * QuadTree implementation
+ * <p>
+ * QuadTree implementation.
+ * </p>
+ * <p>
+ * QuadTree gets a list of instances and then recursively split them into 4 children For this it
+ * uses the median of the 2 values x,y.
+ * </p>
  * 
- * QuadTree gets a list of instances and then recursively split them into 4 childs For this it uses
- * the median of the 2 values x,y
+ * @author Alexander Trautsch
  */
 public class QuadTree {
 
-    /* 1 parent or null */
+    /**
+     * 1 parent or null
+     */
     private QuadTree parent = null;
 
-    /* 4 childs, 1 per quadrant */
+    /**
+     * north-west quadrant
+     */
     private QuadTree child_nw;
+
+    /**
+     * north-east quadrant
+     */
     private QuadTree child_ne;
+
+    /**
+     * south-east quadrant
+     */
     private QuadTree child_se;
+
+    /**
+     * south-west quadrant
+     */
     private QuadTree child_sw;
 
-    /* list (only helps with generation of list of childs!) */
+    /**
+     * helper list for child quadrant generation
+     */
     private ArrayList<QuadTree> l = new ArrayList<QuadTree>();
 
-    /* level only used for debugging */
+    /**
+     * debugging attribute
+     */
     public int level = 0;
 
-    /* size of the quadrant */
+    /**
+     * size of the quadrant in x-dimension
+     */
     private double[] x;
+
+    /**
+     * size of the quadrant in y-dimension
+     */
     private double[] y;
 
+    /**
+     * debugging parameter
+     */
     public static boolean verbose = false;
+
+    /**
+     * global size of the QuadTree.
+     */
     public static int size = 0;
+
+    /**
+     * recursion parameter alpha
+     */
     public static double alpha = 0;
 
-    /* cluster payloads */
+    /**
+     * data for each cluster
+     */
     public static ArrayList<ArrayList<QuadTreePayload<Instance>>> ccluster =
         new ArrayList<ArrayList<QuadTreePayload<Instance>>>();
 
-    /* cluster sizes (index is cluster number, arraylist is list of boxes (x0,y0,x1,y1) */
+    /**
+     * cluster sizes (index is cluster number, {@link ArrayList} is list of boxes (x0,y0,x1,y1
+     */
     public static HashMap<Integer, ArrayList<Double[][]>> csize =
         new HashMap<Integer, ArrayList<Double[][]>>();
 
-    /* payload of this instance */
+    /**
+     * data within this quadrant
+     */
     private ArrayList<QuadTreePayload<Instance>> payload;
 
+    /**
+     * <p>
+     * Constructor. Creates a new QuadTree.
+     * </p>
+     *
+     * @param parent
+     *            parent of this tree
+     * @param payload
+     *            data within the quadrant
+     */
     public QuadTree(QuadTree parent, ArrayList<QuadTreePayload<Instance>> payload) {
         this.parent = parent;
@@ -70 +128 @@
     }
 
+    /*
+     * (non-Javadoc)
+     * 
+     * @see java.lang.Object#toString()
+     */
+    @Override
     public String toString() {
         String n = "";
@@ -81 +145 @@
 
     /**
+     * <p>
      * Returns the payload, used for clustering in the clustering list we only have children with
-     * paylod
-     * 
-     * @return payload
+     * payload
+     * </p>
+     * 
+     * @return payload the payload
      */
     public ArrayList<QuadTreePayload<Instance>> getPayload() {
@@ -91 +157 @@
 
     /**
-     * Calculate the density of this quadrant
-     * 
-     * density = number of instances / global size (all instances)
-     * 
-     * @return density
+     * <p>
+     * Calculate the density of this quadrant as
+     * <ul>
+     * <li>density = number of instances / global size (all instances)</li>
+     * </ul>
+     * 
+     * @return density the density
      */
     public double getDensity() {
@@ -103 +171 @@
     }
 
+    /**
+     * <p>
+     * sets the size coordinates of the quadrant
+     * </p>
+     *
+     * @param x
+     *            x-dimension
+     * @param y
+     *            y-dimension
+     */
     public void setSize(double[] x, double[] y) {
         this.x = x;
@@ -108 +186 @@
     }
 
+    /**
+     * <p>
+     * returns the size of the quadrant
+     * </p>
+     *
+     * @return size of the current quadrant
+     */
     public double[][] getSize() {
         return new double[][]
@@ -113 +198 @@
     }
 
+    /**
+     * <p>
+     * returns the size of the quadrant
+     * </p>
+     *
+     * @return size of the current quadrant
+     */
     public Double[][] getSizeDouble() {
         Double[] tmpX = new Double[2];
@@ -128 +220 @@
 
     /**
-     * TODO: DRY, median ist immer dasselbe
+     * <p>
+     * calculates the median for the x axis
+     * </p>
      * 
      * @return median for x
@@ -161 +255 @@
     }
 
+    /**
+     * <p>
+     * calculates the median for the y axis
+     * </p>
+     * 
+     * @return median for y
+     */
     private double getMedianForY() {
         double med_y = 0;
@@ -191 +292 @@
 
     /**
-     * Reurns the number of instances in the payload
-     * 
-     * @return int number of instances
+     * <p>
+     * Returns the number of instances in the payload
+     * </p>
+     * 
+     * @return number of instances
      */
     public int getNumbers() {
@@ -204 +307 @@
 
     /**
+     * <p>
      * Calculate median values of payload for x, y and split into 4 sectors
+     * </p>
      * 
      * @return Array of QuadTree nodes (4 childs)
@@ -295 +400 @@
 
     /**
-     * TODO: static method
-     * 
+     * <p>
+     * creates the children of a QuadTree and recursively splits them as well
+     * </p>
+     *
      * @param q
-     */
-    public void recursiveSplit(QuadTree q) {
+     *            tree that is split
+     */
+    public static void recursiveSplit(QuadTree q) {
         if (QuadTree.verbose) {
             System.out.println("splitting: " + q);
@@ -310 +418 @@
             try {
                 QuadTree[] childs = q.split();
-                this.recursiveSplit(childs[0]);
-                this.recursiveSplit(childs[1]);
-                this.recursiveSplit(childs[2]);
-                this.recursiveSplit(childs[3]);
+                recursiveSplit(childs[0]);
+                recursiveSplit(childs[1]);
+                recursiveSplit(childs[2]);
+                recursiveSplit(childs[3]);
             }
             catch (Exception e) {
@@ -322 +430 @@
 
     /**
-     * returns an list of childs sorted by density
+     * <p>
+     * returns an list of children sorted by density
+     * </p>
      * 
      * @param q
      *            QuadTree
-     * @return list of QuadTrees
      */
     private void generateList(QuadTree q) {
@@ -350 +459 @@
 
     /**
+     * <p>
      * Checks if passed QuadTree is neighboring to us
+     * </p>
      * 
      * @param q
@@ -396 +507 @@
 
     /**
+     * <p>
      * Perform pruning and clustering of the quadtree
-     * 
+     * </p>
+     * <p>
      * Pruning according to: Tim Menzies, Andrew Butcher, David Cok, Andrian Marcus, Lucas Layman,
      * Forrest Shull, Burak Turhan, Thomas Zimmermann,
      * "Local versus Global Lessons for Defect Prediction and Effort Estimation," IEEE Transactions
      * on Software Engineering, vol. 39, no. 6, pp. 822-834, June, 2013
-     * 
-     * 1) get list of leaf quadrants 2) sort by their density 3) set stop_rule to 0.5 * highest
-     * Density in the list 4) merge all nodes with a density > stop_rule to the new cluster and
-     * remove all from list 5) repeat
+     * </p>
+     * <ol>
+     * <li>get list of leaf quadrants</li>
+     * <li>sort by their density</li>
+     * <li>set stop_rule to 0.5*highest Density in the list</li>
+     * <li>merge all nodes with a density > stop_rule to the new cluster and remove all from list
+     * </li>
+     * <li>repeat</li>
+     * </ol>
      * 
      * @param q
@@ -479 +597 @@
     }
 
+    /**
+     * <p>
+     * debugging function that prints information about the QuadTree
+     * </p>
+     *
+     */
     public void printInfo() {
         System.out.println("we have " + ccluster.size() + " clusters");
@@ -488 +612 @@
 
     /**
+     * <p>
      * Helper Method to get a sorted list (by density) for all children
+     * </p>
      * 
      * @param q

trunk/CrossPare/src/de/ugoe/cs/cpdp/training/WekaBaggingTraining.java

@@ -29 +29 @@
 
 /**
- * Programmatic WekaBaggingTraining
- * 
- * first parameter is Trainer Name. second parameter is class name
- * 
- * all subsequent parameters are configuration params (for example for trees) Cross Validation
- * params always come last and are prepended with -CVPARAM
- * 
+ * <p>
+ * The first parameter is the trainer name, second parameter is class name. All subsequent
+ * parameters are configuration parameters of the algorithms. Cross validation parameters always
+ * come last and are prepended with -CVPARAM
+ * </p>
+ * <p>
  * XML Configurations for Weka Classifiers:
  * 
@@ -45 +44 @@
  * }
  * </pre>
+ * </p>
  * 
+ * @author Alexander Trautsch
  */
 public class WekaBaggingTraining extends WekaBaseTraining implements ISetWiseTrainingStrategy {
 
+    /**
+     * the classifier
+     */
     private final TraindatasetBagging classifier = new TraindatasetBagging();
 
+    /*
+     * (non-Javadoc)
+     * 
+     * @see de.ugoe.cs.cpdp.training.WekaBaseTraining#getClassifier()
+     */
     @Override
     public Classifier getClassifier() {
@@ -56 +65 @@
     }
 
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * de.ugoe.cs.cpdp.training.ISetWiseTrainingStrategy#apply(org.apache.commons.collections4.list.
+     * SetUniqueList)
+     */
     @Override
     public void apply(SetUniqueList<Instances> traindataSet) {
@@ -66 +82 @@
     }
 
+    /**
+     * <p>
+     * Helper class for bagging classifiers.
+     * </p>
+     * 
+     * @author Steffen Herbold
+     */
     public class TraindatasetBagging extends AbstractClassifier {
 
+        /**
+         * default serialization ID.
+         */
         private static final long serialVersionUID = 1L;
 
+        /**
+         * internal storage of the training data
+         */
         private List<Instances> trainingData = null;
 
+        /**
+         * bagging classifier for each training data set
+         */
         private List<Classifier> classifiers = null;
 
+        /*
+         * (non-Javadoc)
+         * 
+         * @see weka.classifiers.AbstractClassifier#classifyInstance(weka.core.Instance)
+         */
         @Override
         public double classifyInstance(Instance instance) {
@@ -115 +152 @@
         }
 
+        /**
+         * <p>
+         * trains a new dataset wise bagging classifier
+         * </p>
+         *
+         * @param traindataSet
+         *            the training data per prodcut
+         * @throws Exception
+         *             thrown if an error occurs during the training of the classifiers for any
+         *             product
+         */
         public void buildClassifier(SetUniqueList<Instances> traindataSet) throws Exception {
             classifiers = new LinkedList<>();
@@ -126 +174 @@
         }
 
+        /*
+         * (non-Javadoc)
+         * 
+         * @see weka.classifiers.Classifier#buildClassifier(weka.core.Instances)
+         */
         @Override
         public void buildClassifier(Instances traindata) throws Exception {

trunk/CrossPare/src/de/ugoe/cs/cpdp/training/WekaBaseTraining.java

@@ -27 +27 @@
 
 /**
- * WekaBaseTraining2
+ * <p>
+ * Allows specification of the Weka classifier and its params in the XML experiment configuration.
+ * </p>
+ * <p>
+ * Important conventions of the XML format: Cross Validation params always come last and are
+ * prepended with -CVPARAM.<br>
+ * Example:
  * 
- * Allows specification of the Weka classifier and its params in the XML experiment configuration.
+ * <pre>
+ * {@code
+ * <trainer name="WekaTraining" param="RandomForestLocal weka.classifiers.trees.RandomForest -CVPARAM I 5 25 5"/>
+ * }
+ * </pre>
  * 
- * Important conventions of the XML format: Cross Validation params always come last and are
- * prepended with -CVPARAM Example: <trainer name="WekaTraining"
- * param="RandomForestLocal weka.classifiers.trees.RandomForest -CVPARAM I 5 25 5"/>
+ * @author Alexander Trautsch
  */
 public abstract class WekaBaseTraining implements IWekaCompatibleTrainer {
 
+    /**
+     * reference to the Weka classifier
+     */
     protected Classifier classifier = null;
+
+    /**
+     * qualified class name of the weka classifier
+     */
     protected String classifierClassName;
+
+    /**
+     * name of the classifier
+     */
     protected String classifierName;
+
+    /**
+     * parameters of the training
+     */
     protected String[] classifierParams;
 
+    /*
+     * (non-Javadoc)
+     * 
+     * @see de.ugoe.cs.cpdp.IParameterizable#setParameter(java.lang.String)
+     */
     @Override
     public void setParameter(String parameters) {
@@ -58 +86 @@
         classifierParams = Arrays.copyOfRange(params, 2, params.length);
 
-        //classifier = setupClassifier();
+        // classifier = setupClassifier();
     }
 
+    /*
+     * (non-Javadoc)
+     * 
+     * @see de.ugoe.cs.cpdp.training.IWekaCompatibleTrainer#getClassifier()
+     */
     @Override
     public Classifier getClassifier() {
@@ -66 +99 @@
     }
 
+    /**
+     * <p>
+     * helper function that sets up the Weka classifier including its parameters
+     * </p>
+     *
+     * @return
+     */
     protected Classifier setupClassifier() {
         Classifier cl = null;
@@ -95 +135 @@
             cl = obj;
 
-            if( cl instanceof Vote ) {
+            if (cl instanceof Vote) {
                 Vote votingClassifier = (Vote) cl;
-                for( Classifier classifier : votingClassifier.getClassifiers() ) {
-                    if( classifier instanceof BayesNet ) {
+                for (Classifier classifier : votingClassifier.getClassifiers()) {
+                    if (classifier instanceof BayesNet) {
                         ((BayesNet) classifier).setUseADTree(false);
                     }
@@ -141 +181 @@
     }
 
+    /*
+     * (non-Javadoc)
+     * 
+     * @see de.ugoe.cs.cpdp.training.IWekaCompatibleTrainer#getName()
+     */
     @Override
     public String getName() {

trunk/CrossPare/src/de/ugoe/cs/cpdp/training/WekaLASERTraining.java

@@ -24 +24 @@
 import weka.core.Instances;
 
-
 /**
  * <p>
- * TODO comment
+ * Implements training following the LASER classification scheme.
  * </p>
  * 
@@ -34 +33 @@
 public class WekaLASERTraining extends WekaBaseTraining implements ITrainingStrategy {
 
+    /**
+     * Internal classifier used for LASER.
+     */
     private final LASERClassifier internalClassifier = new LASERClassifier();
 
+    /*
+     * (non-Javadoc)
+     * 
+     * @see de.ugoe.cs.cpdp.training.WekaBaseTraining#getClassifier()
+     */
     @Override
     public Classifier getClassifier() {
@@ -41 +48 @@
     }
 
+    /*
+     * (non-Javadoc)
+     * 
+     * @see de.ugoe.cs.cpdp.training.ITrainingStrategy#apply(weka.core.Instances)
+     */
     @Override
     public void apply(Instances traindata) {
@@ -51 +63 @@
     }
 
+    /**
+     * <p>
+     * Internal helper class that defines the laser classifier.
+     * </p>
+     * 
+     * @author Steffen Herbold
+     */
     public class LASERClassifier extends AbstractClassifier {
 
+        /**
+         * Default serial ID.
+         */
         private static final long serialVersionUID = 1L;
-        
+
+        /**
+         * Internal reference to the classifier.
+         */
         private Classifier laserClassifier = null;
+
+        /**
+         * Internal storage of the training data required for NN analysis.
+         */
         private Instances traindata = null;
 
+        /*
+         * (non-Javadoc)
+         * 
+         * @see weka.classifiers.AbstractClassifier#classifyInstance(weka.core.Instance)
+         */
         @Override
         public double classifyInstance(Instance instance) throws Exception {
             List<Integer> closestInstances = new LinkedList<>();
             double minDistance = Double.MAX_VALUE;
-            for( int i=0; i<traindata.size(); i++ ) {
+            for (int i = 0; i < traindata.size(); i++) {
                 double distance = WekaUtils.hammingDistance(instance, traindata.get(i));
-                if( distance<minDistance) {
+                if (distance < minDistance) {
                     minDistance = distance;
                 }
             }
-            for( int i=0; i<traindata.size(); i++ ) {
+            for (int i = 0; i < traindata.size(); i++) {
                 double distance = WekaUtils.hammingDistance(instance, traindata.get(i));
-                if( distance<=minDistance ) {
+                if (distance <= minDistance) {
                     closestInstances.add(i);
                 }
             }
-            if( closestInstances.size()==1 ) {
+            if (closestInstances.size() == 1) {
                 int closestIndex = closestInstances.get(0);
                 Instance closestTrainingInstance = traindata.get(closestIndex);
                 List<Integer> closestToTrainingInstance = new LinkedList<>();
                 double minTrainingDistance = Double.MAX_VALUE;
-                for( int i=0; i<traindata.size(); i++ ) {
-                    if( closestIndex!=i ) {
-                        double distance = WekaUtils.hammingDistance(closestTrainingInstance, traindata.get(i));
-                        if( distance<minTrainingDistance ) {
+                for (int i = 0; i < traindata.size(); i++) {
+                    if (closestIndex != i) {
+                        double distance =
+                            WekaUtils.hammingDistance(closestTrainingInstance, traindata.get(i));
+                        if (distance < minTrainingDistance) {
                             minTrainingDistance = distance;
                         }
                     }
                 }
-                for( int i=0; i<traindata.size(); i++ ) {
-                    if( closestIndex!=i ) {
-                        double distance = WekaUtils.hammingDistance(closestTrainingInstance, traindata.get(i));
-                        if( distance<=minTrainingDistance ) {
+                for (int i = 0; i < traindata.size(); i++) {
+                    if (closestIndex != i) {
+                        double distance =
+                            WekaUtils.hammingDistance(closestTrainingInstance, traindata.get(i));
+                        if (distance <= minTrainingDistance) {
                             closestToTrainingInstance.add(i);
                         }
                     }
                 }
-                if( closestToTrainingInstance.size()==1 ) {
+                if (closestToTrainingInstance.size() == 1) {
                     return laserClassifier.classifyInstance(instance);
                 }
@@ -101 +137 @@
                     double label = Double.NaN;
                     boolean allEqual = true;
-                    for( Integer index : closestToTrainingInstance ) {
-                        if( Double.isNaN(label) ) {
+                    for (Integer index : closestToTrainingInstance) {
+                        if (Double.isNaN(label)) {
                             label = traindata.get(index).classValue();
                         }
-                        else if( label!=traindata.get(index).classValue() ) {
+                        else if (label != traindata.get(index).classValue()) {
                             allEqual = false;
                             break;
                         }
                     }
-                    if( allEqual ) {
+                    if (allEqual) {
                         return label;
                     }
@@ -117 +153 @@
                     }
                 }
-            } else {
+            }
+            else {
                 double label = Double.NaN;
                 boolean allEqual = true;
-                for( Integer index : closestInstances ) {
-                    if( Double.isNaN(label) ) {
+                for (Integer index : closestInstances) {
+                    if (Double.isNaN(label)) {
                         label = traindata.get(index).classValue();
                     }
-                    else if( label!=traindata.get(index).classValue() ) {
+                    else if (label != traindata.get(index).classValue()) {
                         allEqual = false;
                         break;
                     }
                 }
-                if( allEqual ) {
+                if (allEqual) {
                     return label;
                 }
@@ -138 +175 @@
         }
 
+        /*
+         * (non-Javadoc)
+         * 
+         * @see weka.classifiers.Classifier#buildClassifier(weka.core.Instances)
+         */
         @Override
         public void buildClassifier(Instances traindata) throws Exception {

trunk/CrossPare/src/de/ugoe/cs/cpdp/training/WekaLocalEMTraining.java

@@ -33 +33 @@
 
 /**
- * WekaLocalEMTraining
+ * <p>
+ * Local Trainer with EM Clustering for data partitioning. Currently supports only EM Clustering.
+ * </p>
+ * <ol>
+ * <li>Cluster training data</li>
+ * <li>for each cluster train a classifier with training data from cluster</li>
+ * <li>match test data instance to a cluster, then classify with classifier from the cluster</li>
+ * </ol>
  * 
- * Local Trainer with EM Clustering for data partitioning. Currently supports only EM Clustering.
+ * XML configuration:
  * 
- * 1. Cluster training data 2. for each cluster train a classifier with training data from cluster
- * 3. match test data instance to a cluster, then classify with classifier from the cluster
- * 
- * XML configuration: <!-- because of clustering --> <preprocessor name="Normalization" param=""/>
- * 
- * <!-- cluster trainer --> <trainer name="WekaLocalEMTraining"
- * param="NaiveBayes weka.classifiers.bayes.NaiveBayes" />
+ * <pre>
+ * {@code
+ * <trainer name="WekaLocalEMTraining" param="NaiveBayes weka.classifiers.bayes.NaiveBayes" />
+ * }
+ * </pre>
  */
 public class WekaLocalEMTraining extends WekaBaseTraining implements ITrainingStrategy {
 
+    /**
+     * the classifier
+     */
     private final TraindatasetCluster classifier = new TraindatasetCluster();
 
+    /*
+     * (non-Javadoc)
+     * 
+     * @see de.ugoe.cs.cpdp.training.WekaBaseTraining#getClassifier()
+     */
     @Override
     public Classifier getClassifier() {
@@ -54 +67 @@
     }
 
+    /*
+     * (non-Javadoc)
+     * 
+     * @see de.ugoe.cs.cpdp.training.ITrainingStrategy#apply(weka.core.Instances)
+     */
     @Override
     public void apply(Instances traindata) {
@@ -64 +82 @@
     }
 
+    /**
+     * <p>
+     * Weka classifier for the local model with EM clustering.
+     * </p>
+     * 
+     * @author Alexander Trautsch
+     */
     public class TraindatasetCluster extends AbstractClassifier {
 
+        /**
+         * default serializtion ID
+         */
         private static final long serialVersionUID = 1L;
 
+        /**
+         * EM clusterer used
+         */
         private EM clusterer = null;
 
+        /**
+         * classifiers for each cluster
+         */
         private HashMap<Integer, Classifier> cclassifier;
+
+        /**
+         * training data for each cluster
+         */
         private HashMap<Integer, Instances> ctraindata;
 
@@ -107 +145 @@
         }
 
+        /*
+         * (non-Javadoc)
+         * 
+         * @see weka.classifiers.AbstractClassifier#classifyInstance(weka.core.Instance)
+         */
         @Override
         public double classifyInstance(Instance instance) {
@@ -139 +182 @@
         }
 
+        /*
+         * (non-Javadoc)
+         * 
+         * @see weka.classifiers.Classifier#buildClassifier(weka.core.Instances)
+         */
         @Override
         public void buildClassifier(Instances traindata) throws Exception {

trunk/CrossPare/src/de/ugoe/cs/cpdp/training/WekaLocalFQTraining.java

@@ -35 +35 @@
 
 /**
+ * <p>
  * Trainer with reimplementation of WHERE clustering algorithm from: Tim Menzies, Andrew Butcher,
  * David Cok, Andrian Marcus, Lucas Layman, Forrest Shull, Burak Turhan, Thomas Zimmermann,
  * "Local versus Global Lessons for Defect Prediction and Effort Estimation," IEEE Transactions on
  * Software Engineering, vol. 39, no. 6, pp. 822-834, June, 2013
- * 
- * With WekaLocalFQTraining we do the following: 1) Run the Fastmap algorithm on all training data,
- * let it calculate the 2 most significant dimensions and projections of each instance to these
- * dimensions 2) With these 2 dimensions we span a QuadTree which gets recursively split on
- * median(x) and median(y) values. 3) We cluster the QuadTree nodes together if they have similar
- * density (50%) 4) We save the clusters and their training data 5) We only use clusters with >
- * ALPHA instances (currently Math.sqrt(SIZE)), rest is discarded with the training data of this
- * cluster 6) We train a Weka classifier for each cluster with the clusters training data 7) We
- * recalculate Fastmap distances for a single instance with the old pivots and then try to find a
- * cluster containing the coords of the instance. 7.1.) If we can not find a cluster (due to coords
- * outside of all clusters) we find the nearest cluster. 8) We classify the Instance with the
- * classifier and traindata from the Cluster we found in 7.
+ * </p>
+ * <p>
+ * With WekaLocalFQTraining we do the following:
+ * <ol>
+ * <li>Run the Fastmap algorithm on all training data, let it calculate the 2 most significant
+ * dimensions and projections of each instance to these dimensions</li>
+ * <li>With these 2 dimensions we span a QuadTree which gets recursively split on median(x) and
+ * median(y) values.</li>
+ * <li>We cluster the QuadTree nodes together if they have similar density (50%)</li>
+ * <li>We save the clusters and their training data</li>
+ * <li>We only use clusters with > ALPHA instances (currently Math.sqrt(SIZE)), the rest is
+ * discarded with the training data of this cluster</li>
+ * <li>We train a Weka classifier for each cluster with the clusters training data</li>
+ * <li>We recalculate Fastmap distances for a single instance with the old pivots and then try to
+ * find a cluster containing the coords of the instance. If we can not find a cluster (due to coords
+ * outside of all clusters) we find the nearest cluster.</li>
+ * <li>We classify the Instance with the classifier and traindata from the Cluster we found in 7.
+ * </li>
+ * </p>
  */
 public class WekaLocalFQTraining extends WekaBaseTraining implements ITrainingStrategy {
 
+    /**
+     * the classifier
+     */
     private final TraindatasetCluster classifier = new TraindatasetCluster();
 
+    /*
+     * (non-Javadoc)
+     * 
+     * @see de.ugoe.cs.cpdp.training.WekaBaseTraining#getClassifier()
+     */
     @Override
     public Classifier getClassifier() {
@@ -61 +77 @@
     }
 
+    /*
+     * (non-Javadoc)
+     * 
+     * @see de.ugoe.cs.cpdp.training.ITrainingStrategy#apply(weka.core.Instances)
+     */
     @Override
     public void apply(Instances traindata) {
@@ -71 +92 @@
     }
 
+    /**
+     * <p>
+     * Weka classifier for the local model with WHERE clustering
+     * </p>
+     * 
+     * @author Alexander Trautsch
+     */
     public class TraindatasetCluster extends AbstractClassifier {
 
+        /**
+         * default serialization ID
+         */
         private static final long serialVersionUID = 1L;
 
-        /* classifier per cluster */
+        /**
+         * classifiers for each cluster
+         */
         private HashMap<Integer, Classifier> cclassifier;
 
-        /* instances per cluster */
+        /**
+         * training data for each cluster
+         */
         private HashMap<Integer, Instances> ctraindata;
 
-        /*
+        /**
          * holds the instances and indices of the pivot objects of the Fastmap calculation in
          * buildClassifier
@@ -87 +122 @@
         private HashMap<Integer, Instance> cpivots;
 
-        /* holds the indices of the pivot objects for x,y and the dimension [x,y][dimension] */
+        /**
+         * holds the indices of the pivot objects for x,y and the dimension [x,y][dimension]
+         */
         private int[][] cpivotindices;
 
-        /* holds the sizes of the cluster multiple "boxes" per cluster */
+        /**
+         * holds the sizes of the cluster multiple "boxes" per cluster
+         */
         private HashMap<Integer, ArrayList<Double[][]>> csize;
 
-        /* debug vars */
+        /**
+         * debug variable
+         */
         @SuppressWarnings("unused")
         private boolean show_biggest = true;
 
+        /**
+         * debug variable
+         */
         @SuppressWarnings("unused")
         private int CFOUND = 0;
+
+        /**
+         * debug variable
+         */
         @SuppressWarnings("unused")
         private int CNOTFOUND = 0;
 
+        /**
+         * <p>
+         * copies an instance such that is is compatible with the local model
+         * </p>
+         *
+         * @param instances
+         *            instance format
+         * @param instance
+         *            instance that is copied
+         * @return
+         */
         private Instance createInstance(Instances instances, Instance instance) {
             // attributes for feeding instance to classifier
@@ -127 +186 @@
 
         /**
+         * <p>
          * Because Fastmap saves only the image not the values of the attributes it used we can not
          * use the old data directly to classify single instances to clusters.
+         * </p>
+         * <p>
+         * To classify a single instance we do a new Fastmap computation with only the instance and
+         * the old pivot elements.
+         * </p>
+         * </p>
+         * After that we find the cluster with our Fastmap result for x and y.
+         * </p>
          * 
-         * To classify a single instance we do a new fastmap computation with only the instance and
-         * the old pivot elements.
-         * 
-         * After that we find the cluster with our fastmap result for x and y.
+         * @param instance
+         *            instance that is classified
+         * @see weka.classifiers.AbstractClassifier#classifyInstance(weka.core.Instance)
          */
         @Override
@@ -169 +236 @@
                 double[][] distmat = new double[2 * FMAP.target_dims + 1][2 * FMAP.target_dims + 1];
                 distmat[0][0] = 0;
-                distmat[0][1] =
-                    dist.distance(clusterInstance,
-                                  this.cpivots.get((Integer) this.cpivotindices[0][0]));
-                distmat[0][2] =
-                    dist.distance(clusterInstance,
-                                  this.cpivots.get((Integer) this.cpivotindices[1][0]));
-                distmat[0][3] =
-                    dist.distance(clusterInstance,
-                                  this.cpivots.get((Integer) this.cpivotindices[0][1]));
-                distmat[0][4] =
-                    dist.distance(clusterInstance,
-                                  this.cpivots.get((Integer) this.cpivotindices[1][1]));
-
-                distmat[1][0] =
-                    dist.distance(this.cpivots.get((Integer) this.cpivotindices[0][0]),
-                                  clusterInstance);
+                distmat[0][1] = dist.distance(clusterInstance,
+                                              this.cpivots.get((Integer) this.cpivotindices[0][0]));
+                distmat[0][2] = dist.distance(clusterInstance,
+                                              this.cpivots.get((Integer) this.cpivotindices[1][0]));
+                distmat[0][3] = dist.distance(clusterInstance,
+                                              this.cpivots.get((Integer) this.cpivotindices[0][1]));
+                distmat[0][4] = dist.distance(clusterInstance,
+                                              this.cpivots.get((Integer) this.cpivotindices[1][1]));
+
+                distmat[1][0] = dist.distance(this.cpivots.get((Integer) this.cpivotindices[0][0]),
+                                              clusterInstance);
                 distmat[1][1] = 0;
-                distmat[1][2] =
-                    dist.distance(this.cpivots.get((Integer) this.cpivotindices[0][0]),
-                                  this.cpivots.get((Integer) this.cpivotindices[1][0]));
-                distmat[1][3] =
-                    dist.distance(this.cpivots.get((Integer) this.cpivotindices[0][0]),
-                                  this.cpivots.get((Integer) this.cpivotindices[0][1]));
-                distmat[1][4] =
-                    dist.distance(this.cpivots.get((Integer) this.cpivotindices[0][0]),
-                                  this.cpivots.get((Integer) this.cpivotindices[1][1]));
-
-                distmat[2][0] =
-                    dist.distance(this.cpivots.get((Integer) this.cpivotindices[1][0]),
-                                  clusterInstance);
-                distmat[2][1] =
-                    dist.distance(this.cpivots.get((Integer) this.cpivotindices[1][0]),
-                                  this.cpivots.get((Integer) this.cpivotindices[0][0]));
+                distmat[1][2] = dist.distance(this.cpivots.get((Integer) this.cpivotindices[0][0]),
+                                              this.cpivots.get((Integer) this.cpivotindices[1][0]));
+                distmat[1][3] = dist.distance(this.cpivots.get((Integer) this.cpivotindices[0][0]),
+                                              this.cpivots.get((Integer) this.cpivotindices[0][1]));
+                distmat[1][4] = dist.distance(this.cpivots.get((Integer) this.cpivotindices[0][0]),
+                                              this.cpivots.get((Integer) this.cpivotindices[1][1]));
+
+                distmat[2][0] = dist.distance(this.cpivots.get((Integer) this.cpivotindices[1][0]),
+                                              clusterInstance);
+                distmat[2][1] = dist.distance(this.cpivots.get((Integer) this.cpivotindices[1][0]),
+                                              this.cpivots.get((Integer) this.cpivotindices[0][0]));
                 distmat[2][2] = 0;
-                distmat[2][3] =
-                    dist.distance(this.cpivots.get((Integer) this.cpivotindices[1][0]),
-                                  this.cpivots.get((Integer) this.cpivotindices[0][1]));
-                distmat[2][4] =
-                    dist.distance(this.cpivots.get((Integer) this.cpivotindices[1][0]),
-                                  this.cpivots.get((Integer) this.cpivotindices[1][1]));
-
-                distmat[3][0] =
-                    dist.distance(this.cpivots.get((Integer) this.cpivotindices[0][1]),
-                                  clusterInstance);
-                distmat[3][1] =
-                    dist.distance(this.cpivots.get((Integer) this.cpivotindices[0][1]),
-                                  this.cpivots.get((Integer) this.cpivotindices[0][0]));
-                distmat[3][2] =
-                    dist.distance(this.cpivots.get((Integer) this.cpivotindices[0][1]),
-                                  this.cpivots.get((Integer) this.cpivotindices[1][0]));
+                distmat[2][3] = dist.distance(this.cpivots.get((Integer) this.cpivotindices[1][0]),
+                                              this.cpivots.get((Integer) this.cpivotindices[0][1]));
+                distmat[2][4] = dist.distance(this.cpivots.get((Integer) this.cpivotindices[1][0]),
+                                              this.cpivots.get((Integer) this.cpivotindices[1][1]));
+
+                distmat[3][0] = dist.distance(this.cpivots.get((Integer) this.cpivotindices[0][1]),
+                                              clusterInstance);
+                distmat[3][1] = dist.distance(this.cpivots.get((Integer) this.cpivotindices[0][1]),
+                                              this.cpivots.get((Integer) this.cpivotindices[0][0]));
+                distmat[3][2] = dist.distance(this.cpivots.get((Integer) this.cpivotindices[0][1]),
+                                              this.cpivots.get((Integer) this.cpivotindices[1][0]));
                 distmat[3][3] = 0;
-                distmat[3][4] =
-                    dist.distance(this.cpivots.get((Integer) this.cpivotindices[0][1]),
-                                  this.cpivots.get((Integer) this.cpivotindices[1][1]));
-
-                distmat[4][0] =
-                    dist.distance(this.cpivots.get((Integer) this.cpivotindices[1][1]),
-                                  clusterInstance);
-                distmat[4][1] =
-                    dist.distance(this.cpivots.get((Integer) this.cpivotindices[1][1]),
-                                  this.cpivots.get((Integer) this.cpivotindices[0][0]));
-                distmat[4][2] =
-                    dist.distance(this.cpivots.get((Integer) this.cpivotindices[1][1]),
-                                  this.cpivots.get((Integer) this.cpivotindices[1][0]));
-                distmat[4][3] =
-                    dist.distance(this.cpivots.get((Integer) this.cpivotindices[1][1]),
-                                  this.cpivots.get((Integer) this.cpivotindices[0][1]));
+                distmat[3][4] = dist.distance(this.cpivots.get((Integer) this.cpivotindices[0][1]),
+                                              this.cpivots.get((Integer) this.cpivotindices[1][1]));
+
+                distmat[4][0] = dist.distance(this.cpivots.get((Integer) this.cpivotindices[1][1]),
+                                              clusterInstance);
+                distmat[4][1] = dist.distance(this.cpivots.get((Integer) this.cpivotindices[1][1]),
+                                              this.cpivots.get((Integer) this.cpivotindices[0][0]));
+                distmat[4][2] = dist.distance(this.cpivots.get((Integer) this.cpivotindices[1][1]),
+                                              this.cpivots.get((Integer) this.cpivotindices[1][0]));
+                distmat[4][3] = dist.distance(this.cpivots.get((Integer) this.cpivotindices[1][1]),
+                                              this.cpivots.get((Integer) this.cpivotindices[0][1]));
                 distmat[4][4] = 0;
 
@@ -243 +290 @@
                  * distmat[0].length; j++) { if(biggest < distmat[i][j]) { biggest = distmat[i][j];
                  * } } } if(this.show_biggest) { Console.traceln(Level.INFO,
-                 * String.format(""+clusterInstance)); Console.traceln(Level.INFO,
-                 * String.format("biggest distances: "+ biggest)); this.show_biggest = false; }
+                 * String.format(""+clusterInstance)); Console.traceln(Level.INFO, String.format(
+                 * "biggest distances: "+ biggest)); this.show_biggest = false; }
                  */
 
@@ -316 +363 @@
                         cnumber = clusternumber.next();
                         for (int i = 0; i < ctraindata.get(cnumber).size(); i++) {
-                            if (dist.distance(instance, ctraindata.get(cnumber).get(i)) <= min_distance)
+                            if (dist.distance(instance,
+                                              ctraindata.get(cnumber).get(i)) <= min_distance)
                             {
                                 found_cnumber = cnumber;
@@ -347 +395 @@
         }
 
+        /*
+         * (non-Javadoc)
+         * 
+         * @see weka.classifiers.Classifier#buildClassifier(weka.core.Instances)
+         */
         @Override
         public void buildClassifier(Instances traindata) throws Exception {
@@ -421 +474 @@
 
             // Console.traceln(Level.INFO,
-            // String.format("size for cluster ("+small[0]+","+small[1]+") - ("+big[0]+","+big[1]+")"));
+            // String.format("size for cluster ("+small[0]+","+small[1]+") -
+            // ("+big[0]+","+big[1]+")"));
 
             // 5. generate quadtree
@@ -439 +493 @@
 
             // recursive split und grid clustering eher static
-            TREE.recursiveSplit(TREE);
+            QuadTree.recursiveSplit(TREE);
 
             // generate list of nodes sorted by density (childs only)
@@ -465 +519 @@
                 }
                 else {
-                    Console.traceln(Level.INFO,
-                                    String.format("drop cluster, only: " + current.size() +
-                                        " instances"));
+                    Console.traceln(Level.INFO, String
+                        .format("drop cluster, only: " + current.size() + " instances"));
                 }
             }
@@ -505 +558 @@
                 // traindata_count += ctraindata.get(cnumber).size();
                 // Console.traceln(Level.INFO,
-                // String.format("building classifier in cluster "+cnumber +"  with "+
+                // String.format("building classifier in cluster "+cnumber +" with "+
                 // ctraindata.get(cnumber).size() +" traindata instances"));
             }
@@ -516 +569 @@
 
     /**
-     * Payload for the QuadTree. x and y are the calculated Fastmap values. T is a weka instance.
+     * <p>
+     * Payload for the QuadTree. x and y are the calculated Fastmap values. T is a Weka instance.
+     * </p>
+     * 
+     * @author Alexander Trautsch
      */
     public class QuadTreePayload<T> {
 
-        public double x;
-        public double y;
+        /**
+         * x-value
+         */
+        public final double x;
+
+        /**
+         * y-value
+         */
+        public final double y;
+
+        /**
+         * associated instance
+         */
         private T inst;
 
+        /**
+         * <p>
+         * Constructor. Creates the payload.
+         * </p>
+         *
+         * @param x
+         *            x-value
+         * @param y
+         *            y-value
+         * @param value
+         *            associated instace
+         */
         public QuadTreePayload(double x, double y, T value) {
             this.x = x;
@@ -530 +610 @@
         }
 
+        /**
+         * <p>
+         * returns the instance
+         * </p>
+         *
+         * @return
+         */
         public T getInst() {
             return this.inst;
@@ -536 +623 @@
 
     /**
-     * Fastmap implementation
-     * 
-     * Faloutsos, C., & Lin, K. I. (1995). FastMap: A fast algorithm for indexing, data-mining and
+     * <p>
+     * Fastmap implementation after:<br>
+     * * Faloutsos, C., & Lin, K. I. (1995). FastMap: A fast algorithm for indexing, data-mining and
      * visualization of traditional and multimedia datasets (Vol. 24, No. 2, pp. 163-174). ACM.
+     * </p>
      */
     public class Fastmap {
 
-        /* N x k Array, at the end, the i-th row will be the image of the i-th object */
+        /**
+         * N x k Array, at the end, the i-th row will be the image of the i-th object
+         */
         private double[][] X;
 
-        /* 2 x k pivot Array one pair per recursive call */
+        /**
+         * 2 x k pivot Array one pair per recursive call
+         */
         private int[][] PA;
 
-        /* Objects we got (distance matrix) */
+        /**
+         * Objects we got (distance matrix)
+         */
         private double[][] O;
 
-        /* column of X currently updated (also the dimension) */
+        /**
+         * column of X currently updated (also the dimension)
+         */
         private int col = 0;
 
-        /* number of dimensions we want */
+        /**
+         * number of dimensions we want
+         */
         private int target_dims = 0;
 
-        // if we already have the pivot elements
+        /**
+         * if we already have the pivot elements
+         */
         private boolean pivot_set = false;
 
+        /**
+         * <p>
+         * Constructor. Creates a new Fastmap object.
+         * </p>
+         *
+         * @param k
+         */
         public Fastmap(int k) {
             this.target_dims = k;
@@ -566 +673 @@
 
         /**
-         * Sets the distance matrix and params that depend on this
+         * <p>
+         * Sets the distance matrix and params that depend on this.
+         * </p>
          * 
          * @param O
+         *            distance matrix
          */
         public void setDistmat(double[][] O) {
@@ -578 +688 @@
 
         /**
+         * <p>
          * Set pivot elements, we need that to classify instances after the calculation is complete
          * (because we then want to reuse only the pivot elements).
+         * </p>
          * 
          * @param pi
+         *            the pivots
          */
         public void setPivots(int[][] pi) {
@@ -589 +702 @@
 
         /**
+         * <p>
          * Return the pivot elements that were chosen during the calculation
+         * </p>
          * 
-         * @return
+         * @return the pivots
          */
         public int[][] getPivots() {
@@ -598 +713 @@
 
         /**
-         * The distance function for euclidean distance
-         * 
-         * Acts according to equation 4 of the fastmap paper
+         * <p>
+         * The distance function for euclidean distance. Acts according to equation 4 of the Fastmap
+         * paper.
+         * </p>
          * 
          * @param x
@@ -606 +722 @@
          * @param y
          *            y index of y image (if k==0 y object)
-         * @param kdimensionality
-         * @return distance
+         * @param k
+         *            dimensionality
+         * @return the distance
          */
         private double dist(int x, int y, int k) {
@@ -624 +741 @@
 
         /**
-         * Find the object farthest from the given index This method is a helper Method for
-         * findDistandObjects
+         * <p>
+         * Find the object farthest from the given index. This method is a helper Method for
+         * findDistandObjects.
+         * </p>
          * 
          * @param index
@@ -646 +765 @@
 
         /**
-         * Finds the pivot objects
+         * <p>
+         * Finds the pivot objects. This method is basically algorithm 1 of the Fastmap paper.
+         * </p>
          * 
-         * This method is basically algorithm 1 of the fastmap paper.
-         * 
-         * @return 2 indexes of the choosen pivot objects
+         * @return 2 indexes of the chosen pivot objects
          */
         private int[] findDistantObjects() {
@@ -668 +787 @@
 
         /**
-         * Calculates the new k-vector values (projections)
-         * 
-         * This is basically algorithm 2 of the fastmap paper. We just added the possibility to
-         * pre-set the pivot elements because we need to classify single instances after the
-         * computation is already done.
-         * 
-         * @param dims
-         *            dimensionality
+         * <p>
+         * Calculates the new k-vector values (projections) This is basically algorithm 2 of the
+         * fastmap paper. We just added the possibility to pre-set the pivot elements because we
+         * need to classify single instances after the computation is already done.
+         * </p>
          */
         public void calculate() {
@@ -713 +829 @@
 
         /**
+         * <p>
          * returns the result matrix of the projections
+         * </p>
          * 
          * @return calculated result

trunk/CrossPare/src/de/ugoe/cs/cpdp/training/WekaTestAwareTraining.java

@@ -22 +22 @@
 import weka.core.Instances;
 
-// TODO comment
+/**
+ * <p>
+ * Trainer that allows classifiers access to the training data. Classifiers need to make sure that
+ * they do not use the classification.
+ * </p>
+ * 
+ * @author Steffen Herbold
+ */
 public class WekaTestAwareTraining extends WekaBaseTraining implements ITestAwareTrainingStrategy {
 
+    /*
+     * (non-Javadoc)
+     * 
+     * @see de.ugoe.cs.cpdp.training.ITestAwareTrainingStrategy#apply(weka.core.Instances,
+     * weka.core.Instances)
+     */
     @Override
     public void apply(Instances testdata, Instances traindata) {
         classifier = setupClassifier();
-        if( !(classifier instanceof ITestAwareClassifier) ) {
+        if (!(classifier instanceof ITestAwareClassifier)) {
             throw new RuntimeException("classifier must implement the ITestAwareClassifier interface in order to be used as TestAwareTrainingStrategy");
         }

trunk/CrossPare/src/de/ugoe/cs/cpdp/training/WekaTraining.java

@@ -22 +22 @@
 
 /**
- * Programmatic WekaTraining
- * 
- * first parameter is Trainer Name. second parameter is class name
- * 
- * all subsequent parameters are configuration params (for example for trees) Cross Validation
- * params always come last and are prepended with -CVPARAM
- * 
- * XML Configurations for Weka Classifiers:
- * 
+ * <p>
+ * The first parameter is the trainer name, second parameter is class name. All subsequent
+ * parameters are configuration parameters of the algorithms. Cross validation parameters always
+ * come last and are prepended with -CVPARAM
+ * </p>
+ * XML Configurations for Weka Classifiers: 
  * <pre>
  * {@code